2006-04-07 10:13:41 +08:00
|
|
|
/*
|
|
|
|
* iSCSI lib definitions
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 Red Hat, Inc. All rights reserved.
|
|
|
|
* Copyright (C) 2004 - 2006 Mike Christie
|
|
|
|
* Copyright (C) 2004 - 2005 Dmitry Yusupov
|
|
|
|
* Copyright (C) 2004 - 2005 Alex Aizman
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
#ifndef LIBISCSI_H
|
|
|
|
#define LIBISCSI_H
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
2008-05-22 04:53:56 +08:00
|
|
|
#include <linux/wait.h>
|
2006-04-07 10:13:41 +08:00
|
|
|
#include <linux/mutex.h>
|
2006-10-18 13:47:25 +08:00
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/workqueue.h>
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 06:37:26 +08:00
|
|
|
#include <linux/kfifo.h>
|
2006-04-07 10:13:41 +08:00
|
|
|
#include <scsi/iscsi_proto.h>
|
|
|
|
#include <scsi/iscsi_if.h>
|
2008-12-02 14:32:13 +08:00
|
|
|
#include <scsi/scsi_transport_iscsi.h>
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
struct scsi_transport_template;
|
2008-05-22 04:54:00 +08:00
|
|
|
struct scsi_host_template;
|
2006-04-07 10:13:41 +08:00
|
|
|
struct scsi_device;
|
|
|
|
struct Scsi_Host;
|
2009-04-22 04:32:32 +08:00
|
|
|
struct scsi_target;
|
2006-04-07 10:13:41 +08:00
|
|
|
struct scsi_cmnd;
|
|
|
|
struct socket;
|
|
|
|
struct iscsi_transport;
|
|
|
|
struct iscsi_cls_session;
|
|
|
|
struct iscsi_cls_conn;
|
|
|
|
struct iscsi_session;
|
|
|
|
struct iscsi_nopin;
|
2008-05-22 04:54:00 +08:00
|
|
|
struct device;
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2007-05-31 01:57:19 +08:00
|
|
|
#define ISCSI_DEF_XMIT_CMDS_MAX 128 /* must be power of 2 */
|
2008-05-22 04:54:17 +08:00
|
|
|
#define ISCSI_MGMT_CMDS_MAX 15
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2009-03-06 04:46:01 +08:00
|
|
|
#define ISCSI_DEF_CMD_PER_LUN 32
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
/* Task Mgmt states */
|
2007-12-14 02:43:20 +08:00
|
|
|
enum {
|
|
|
|
TMF_INITIAL,
|
|
|
|
TMF_QUEUED,
|
|
|
|
TMF_SUCCESS,
|
|
|
|
TMF_FAILED,
|
|
|
|
TMF_TIMEDOUT,
|
|
|
|
TMF_NOT_FOUND,
|
|
|
|
};
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2013-07-01 17:54:12 +08:00
|
|
|
#define ISID_SIZE 6
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/* Connection suspend "bit" */
|
|
|
|
#define ISCSI_SUSPEND_BIT 1
|
|
|
|
|
2008-12-02 14:32:13 +08:00
|
|
|
#define ISCSI_ITT_MASK 0x1fff
|
2008-05-22 04:54:17 +08:00
|
|
|
#define ISCSI_TOTAL_CMDS_MAX 4096
|
|
|
|
/* this must be a power of two greater than ISCSI_MGMT_CMDS_MAX */
|
|
|
|
#define ISCSI_TOTAL_CMDS_MIN 16
|
2006-04-07 10:13:41 +08:00
|
|
|
#define ISCSI_AGE_SHIFT 28
|
2008-12-02 14:32:13 +08:00
|
|
|
#define ISCSI_AGE_MASK 0xf
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2007-05-31 01:57:24 +08:00
|
|
|
#define ISCSI_ADDRESS_BUF_LEN 64
|
|
|
|
|
2007-12-14 02:43:21 +08:00
|
|
|
enum {
|
2007-12-14 02:43:23 +08:00
|
|
|
/* this is the maximum possible storage for AHSs */
|
|
|
|
ISCSI_MAX_AHS_SIZE = sizeof(struct iscsi_ecdb_ahdr) +
|
|
|
|
sizeof(struct iscsi_rlength_ahdr),
|
2007-12-14 02:43:21 +08:00
|
|
|
ISCSI_DIGEST_SIZE = sizeof(__u32),
|
|
|
|
};
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2006-07-25 04:47:15 +08:00
|
|
|
enum {
|
2009-05-14 06:57:46 +08:00
|
|
|
ISCSI_TASK_FREE,
|
2006-07-25 04:47:15 +08:00
|
|
|
ISCSI_TASK_COMPLETED,
|
|
|
|
ISCSI_TASK_PENDING,
|
|
|
|
ISCSI_TASK_RUNNING,
|
2009-05-14 06:57:49 +08:00
|
|
|
ISCSI_TASK_ABRT_TMF, /* aborted due to TMF */
|
|
|
|
ISCSI_TASK_ABRT_SESS_RECOV, /* aborted due to session recovery */
|
2010-12-31 16:22:21 +08:00
|
|
|
ISCSI_TASK_REQUEUE_SCSIQ, /* qcmd requeueing to scsi-ml */
|
2006-07-25 04:47:15 +08:00
|
|
|
};
|
|
|
|
|
2008-12-02 14:32:05 +08:00
|
|
|
struct iscsi_r2t_info {
|
|
|
|
__be32 ttt; /* copied from R2T */
|
|
|
|
__be32 exp_statsn; /* copied from R2T */
|
|
|
|
uint32_t data_length; /* copied from R2T */
|
|
|
|
uint32_t data_offset; /* copied from R2T */
|
|
|
|
int data_count; /* DATA-Out payload progress */
|
|
|
|
int datasn;
|
|
|
|
/* LLDs should set/update these values */
|
|
|
|
int sent; /* R2T sequence progress */
|
|
|
|
};
|
|
|
|
|
2008-05-22 04:54:09 +08:00
|
|
|
struct iscsi_task {
|
2006-04-07 10:13:41 +08:00
|
|
|
/*
|
2007-12-14 02:43:23 +08:00
|
|
|
* Because LLDs allocate their hdr differently, this is a pointer
|
|
|
|
* and length to that storage. It must be setup at session
|
|
|
|
* creation time.
|
2006-04-07 10:13:41 +08:00
|
|
|
*/
|
2008-12-02 14:32:05 +08:00
|
|
|
struct iscsi_hdr *hdr;
|
2007-12-14 02:43:23 +08:00
|
|
|
unsigned short hdr_max;
|
|
|
|
unsigned short hdr_len; /* accumulated size of hdr used */
|
2008-12-02 14:32:05 +08:00
|
|
|
/* copied values in case we need to send tmfs */
|
|
|
|
itt_t hdr_itt;
|
|
|
|
__be32 cmdsn;
|
2011-06-17 06:57:09 +08:00
|
|
|
struct scsi_lun lun;
|
2008-12-02 14:32:05 +08:00
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
int itt; /* this ITT */
|
|
|
|
|
2007-05-31 01:57:15 +08:00
|
|
|
unsigned imm_count; /* imm-data (bytes) */
|
2006-09-01 06:09:24 +08:00
|
|
|
/* offset in unsolicited stream (bytes); */
|
2008-12-02 14:32:05 +08:00
|
|
|
struct iscsi_r2t_info unsol_r2t;
|
2008-05-22 04:54:06 +08:00
|
|
|
char *data; /* mgmt payload */
|
2008-12-02 14:32:05 +08:00
|
|
|
unsigned data_count;
|
2006-04-07 10:13:41 +08:00
|
|
|
struct scsi_cmnd *sc; /* associated SCSI cmd*/
|
|
|
|
struct iscsi_conn *conn; /* used connection */
|
|
|
|
|
2009-06-16 11:11:08 +08:00
|
|
|
/* data processing tracking */
|
|
|
|
unsigned long last_xfer;
|
|
|
|
unsigned long last_timeout;
|
|
|
|
bool have_checked_conn;
|
2014-03-06 01:43:49 +08:00
|
|
|
|
|
|
|
/* T10 protection information */
|
|
|
|
bool protected;
|
|
|
|
|
2006-07-25 04:47:15 +08:00
|
|
|
/* state set/tested under session->lock */
|
|
|
|
int state;
|
2006-09-01 06:09:25 +08:00
|
|
|
atomic_t refcount;
|
2006-04-07 10:13:41 +08:00
|
|
|
struct list_head running; /* running cmd list */
|
|
|
|
void *dd_data; /* driver/transport data */
|
|
|
|
};
|
|
|
|
|
2008-12-02 14:32:05 +08:00
|
|
|
static inline int iscsi_task_has_unsol_data(struct iscsi_task *task)
|
|
|
|
{
|
|
|
|
return task->unsol_r2t.data_length > task->unsol_r2t.sent;
|
|
|
|
}
|
|
|
|
|
2008-05-22 04:54:09 +08:00
|
|
|
static inline void* iscsi_next_hdr(struct iscsi_task *task)
|
2007-12-14 02:43:23 +08:00
|
|
|
{
|
2008-05-22 04:54:09 +08:00
|
|
|
return (void*)task->hdr + task->hdr_len;
|
2007-12-14 02:43:23 +08:00
|
|
|
}
|
|
|
|
|
2008-02-01 03:36:43 +08:00
|
|
|
/* Connection's states */
|
|
|
|
enum {
|
|
|
|
ISCSI_CONN_INITIAL_STAGE,
|
|
|
|
ISCSI_CONN_STARTED,
|
|
|
|
ISCSI_CONN_STOPPED,
|
|
|
|
ISCSI_CONN_CLEANUP_WAIT,
|
|
|
|
};
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
struct iscsi_conn {
|
|
|
|
struct iscsi_cls_conn *cls_conn; /* ptr to class connection */
|
|
|
|
void *dd_data; /* iscsi_transport data */
|
|
|
|
struct iscsi_session *session; /* parent session */
|
|
|
|
/*
|
|
|
|
* conn_stop() flag: stop to recover, stop to terminate
|
|
|
|
*/
|
|
|
|
int stop_stage;
|
2007-12-14 02:43:30 +08:00
|
|
|
struct timer_list transport_timer;
|
|
|
|
unsigned long last_recv;
|
|
|
|
unsigned long last_ping;
|
|
|
|
int ping_timeout;
|
|
|
|
int recv_timeout;
|
2008-05-22 04:54:09 +08:00
|
|
|
struct iscsi_task *ping_task;
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
/* iSCSI connection-wide sequencing */
|
|
|
|
uint32_t exp_statsn;
|
2013-07-01 17:54:12 +08:00
|
|
|
uint32_t statsn;
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
/* control data */
|
|
|
|
int id; /* CID */
|
|
|
|
int c_stage; /* connection state */
|
2006-07-25 04:47:39 +08:00
|
|
|
/*
|
|
|
|
* Preallocated buffer for pdus that have data but do not
|
|
|
|
* originate from scsi-ml. We never have two pdus using the
|
|
|
|
* buffer at the same time. It is only allocated to
|
|
|
|
* the default max recv size because the pdus we support
|
|
|
|
* should always fit in this buffer
|
|
|
|
*/
|
|
|
|
char *data;
|
2008-05-22 04:54:09 +08:00
|
|
|
struct iscsi_task *login_task; /* mtask used for login/text */
|
|
|
|
struct iscsi_task *task; /* xmit task in progress */
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
/* xmit */
|
2007-12-14 02:43:20 +08:00
|
|
|
struct list_head mgmtqueue; /* mgmt (control) xmit queue */
|
2009-05-14 06:57:46 +08:00
|
|
|
struct list_head cmdqueue; /* data-path cmd queue */
|
2007-12-14 02:43:20 +08:00
|
|
|
struct list_head requeue; /* tasks needing another run */
|
2006-04-07 10:13:41 +08:00
|
|
|
struct work_struct xmitwork; /* per-conn. xmit workqueue */
|
|
|
|
unsigned long suspend_tx; /* suspend Tx */
|
|
|
|
unsigned long suspend_rx; /* suspend Rx */
|
|
|
|
|
|
|
|
/* abort */
|
|
|
|
wait_queue_head_t ehwait; /* used in eh_abort() */
|
|
|
|
struct iscsi_tm tmhdr;
|
2007-12-14 02:43:20 +08:00
|
|
|
struct timer_list tmf_timer;
|
|
|
|
int tmf_state; /* see TMF_INITIAL, etc.*/
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
/* negotiated params */
|
2007-05-31 01:57:15 +08:00
|
|
|
unsigned max_recv_dlength; /* initiator_max_recv_dsl*/
|
|
|
|
unsigned max_xmit_dlength; /* target_max_recv_dsl */
|
2006-04-07 10:13:41 +08:00
|
|
|
int hdrdgst_en;
|
|
|
|
int datadgst_en;
|
2006-06-29 01:00:23 +08:00
|
|
|
int ifmarker_en;
|
|
|
|
int ofmarker_en;
|
|
|
|
/* values userspace uses to id a conn */
|
|
|
|
int persistent_port;
|
|
|
|
char *persistent_address;
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2013-07-01 17:54:12 +08:00
|
|
|
unsigned max_segment_size;
|
|
|
|
unsigned tcp_xmit_wsf;
|
|
|
|
unsigned tcp_recv_wsf;
|
|
|
|
uint16_t keepalive_tmo;
|
|
|
|
uint16_t local_port;
|
|
|
|
uint8_t tcp_timestamp_stat;
|
|
|
|
uint8_t tcp_nagle_disable;
|
|
|
|
uint8_t tcp_wsf_disable;
|
|
|
|
uint8_t tcp_timer_scale;
|
|
|
|
uint8_t tcp_timestamp_en;
|
|
|
|
uint8_t fragment_disable;
|
|
|
|
uint8_t ipv4_tos;
|
|
|
|
uint8_t ipv6_traffic_class;
|
|
|
|
uint8_t ipv6_flow_label;
|
|
|
|
uint8_t is_fw_assigned_ipv6;
|
2013-11-22 18:28:21 +08:00
|
|
|
char *local_ipaddr;
|
2013-07-01 17:54:12 +08:00
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/* MIB-statistics */
|
|
|
|
uint64_t txdata_octets;
|
|
|
|
uint64_t rxdata_octets;
|
|
|
|
uint32_t scsicmd_pdus_cnt;
|
|
|
|
uint32_t dataout_pdus_cnt;
|
|
|
|
uint32_t scsirsp_pdus_cnt;
|
|
|
|
uint32_t datain_pdus_cnt;
|
|
|
|
uint32_t r2t_pdus_cnt;
|
|
|
|
uint32_t tmfcmd_pdus_cnt;
|
|
|
|
int32_t tmfrsp_pdus_cnt;
|
|
|
|
|
|
|
|
/* custom statistics */
|
|
|
|
uint32_t eh_abort_cnt;
|
2008-04-30 04:46:52 +08:00
|
|
|
uint32_t fmr_unalign_cnt;
|
2006-04-07 10:13:41 +08:00
|
|
|
};
|
|
|
|
|
2007-12-14 02:43:25 +08:00
|
|
|
struct iscsi_pool {
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 06:37:26 +08:00
|
|
|
struct kfifo queue; /* FIFO Queue */
|
2006-04-07 10:13:41 +08:00
|
|
|
void **pool; /* Pool of elements */
|
|
|
|
int max; /* Max number of elements */
|
|
|
|
};
|
|
|
|
|
2008-02-01 03:36:43 +08:00
|
|
|
/* Session's states */
|
|
|
|
enum {
|
|
|
|
ISCSI_STATE_FREE = 1,
|
|
|
|
ISCSI_STATE_LOGGED_IN,
|
|
|
|
ISCSI_STATE_FAILED,
|
|
|
|
ISCSI_STATE_TERMINATE,
|
|
|
|
ISCSI_STATE_IN_RECOVERY,
|
|
|
|
ISCSI_STATE_RECOVERY_FAILED,
|
|
|
|
ISCSI_STATE_LOGGING_OUT,
|
|
|
|
};
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
struct iscsi_session {
|
2008-05-22 04:53:59 +08:00
|
|
|
struct iscsi_cls_session *cls_session;
|
2007-08-15 14:38:30 +08:00
|
|
|
/*
|
|
|
|
* Syncs up the scsi eh thread with the iscsi eh thread when sending
|
|
|
|
* task management functions. This must be taken before the session
|
|
|
|
* and recv lock.
|
|
|
|
*/
|
|
|
|
struct mutex eh_mutex;
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/* iSCSI session-wide sequencing */
|
|
|
|
uint32_t cmdsn;
|
|
|
|
uint32_t exp_cmdsn;
|
|
|
|
uint32_t max_cmdsn;
|
|
|
|
|
2007-07-27 01:46:48 +08:00
|
|
|
/* This tracks the reqs queued into the initiator */
|
|
|
|
uint32_t queued_cmdsn;
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/* configuration */
|
2007-12-14 02:43:30 +08:00
|
|
|
int abort_timeout;
|
|
|
|
int lu_reset_timeout;
|
2009-11-12 06:34:33 +08:00
|
|
|
int tgt_reset_timeout;
|
2006-04-07 10:13:41 +08:00
|
|
|
int initial_r2t_en;
|
2012-01-27 11:13:10 +08:00
|
|
|
unsigned short max_r2t;
|
2006-04-07 10:13:41 +08:00
|
|
|
int imm_data_en;
|
2007-05-31 01:57:15 +08:00
|
|
|
unsigned first_burst;
|
|
|
|
unsigned max_burst;
|
2006-04-07 10:13:41 +08:00
|
|
|
int time2wait;
|
|
|
|
int time2retain;
|
|
|
|
int pdu_inorder_en;
|
|
|
|
int dataseq_inorder_en;
|
|
|
|
int erl;
|
2007-12-14 02:43:20 +08:00
|
|
|
int fast_abort;
|
2006-06-29 01:00:23 +08:00
|
|
|
int tpgt;
|
2007-05-31 01:57:16 +08:00
|
|
|
char *username;
|
|
|
|
char *username_in;
|
|
|
|
char *password;
|
|
|
|
char *password_in;
|
2006-06-29 01:00:23 +08:00
|
|
|
char *targetname;
|
2012-01-19 19:06:53 +08:00
|
|
|
char *targetalias;
|
2008-05-22 04:54:16 +08:00
|
|
|
char *ifacename;
|
|
|
|
char *initiatorname;
|
2013-06-21 01:21:26 +08:00
|
|
|
char *boot_root;
|
|
|
|
char *boot_nic;
|
|
|
|
char *boot_target;
|
2013-07-01 17:54:12 +08:00
|
|
|
char *portal_type;
|
|
|
|
char *discovery_parent_type;
|
|
|
|
uint16_t discovery_parent_idx;
|
|
|
|
uint16_t def_taskmgmt_tmo;
|
|
|
|
uint16_t tsid;
|
|
|
|
uint8_t auto_snd_tgt_disable;
|
|
|
|
uint8_t discovery_sess;
|
|
|
|
uint8_t chap_auth_en;
|
|
|
|
uint8_t discovery_logout_en;
|
|
|
|
uint8_t bidi_chap_en;
|
|
|
|
uint8_t discovery_auth_optional;
|
|
|
|
uint8_t isid[ISID_SIZE];
|
2013-06-21 01:21:26 +08:00
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/* control data */
|
|
|
|
struct iscsi_transport *tt;
|
|
|
|
struct Scsi_Host *host;
|
|
|
|
struct iscsi_conn *leadconn; /* leading connection */
|
[SCSI] libiscsi: Reduce locking contention in fast path
Replace the session lock with two locks, a forward lock and
a backwards lock named frwd_lock and back_lock respectively.
The forward lock protects resources that change while sending a
request to the target, such as cmdsn, queued_cmdsn, and allocating
task from the commands' pool with kfifo_out.
The backward lock protects resources that change while processing
a response or in error path, such as cmdsn_exp, cmdsn_max, and
returning tasks to the commands' pool with kfifo_in.
Under a steady state fast-path situation, that is when one
or more processes/threads submit IO to an iscsi device and
a single kernel upcall (e.g softirq) is dealing with processing
of responses without errors, this patch eliminates the contention
between the queuecommand()/request response/scsi_done() flows
associated with iscsi sessions.
Between the forward and the backward locks exists a strict locking
hierarchy. The mutual exclusion zone protected by the forward lock can
enclose the mutual exclusion zone protected by the backward lock but not
vice versa.
For example, in iscsi_conn_teardown or in iscsi_xmit_data when there is
a failure and __iscsi_put_task is called, the backward lock is taken while
the forward lock is still taken. On the other hand, if in the RX path a nop
is to be sent, for example in iscsi_handle_reject or __iscsi_complete_pdu
than the forward lock is released and the backward lock is taken for the
duration of iscsi_send_nopout, later the backward lock is released and the
forward lock is retaken.
libiscsi_tcp uses two kernel fifos the r2t pool and the r2t queue.
The insertion and deletion from these queues didn't corespond to the
assumption taken by the new forward/backwards session locking paradigm.
That is, in iscsi_tcp_clenup_task which belongs to the RX (backwards)
path, r2t is taken out from r2t queue and inserted to the r2t pool.
In iscsi_tcp_get_curr_r2t which belong to the TX (forward) path, r2t
is also inserted to the r2t pool and another r2t is pulled from r2t
queue.
Only in iscsi_tcp_r2t_rsp which is called in the RX path but can requeue
to the TX path, r2t is taken from the r2t pool and inserted to the r2t
queue.
In order to cope with this situation, two spin locks were added,
pool2queue and queue2pool. The former protects extracting from the
r2t pool and inserting to the r2t queue, and the later protects the
extracing from the r2t queue and inserting to the r2t pool.
Signed-off-by: Shlomo Pongratz <shlomop@mellanox.com>
Signed-off-by: Or Gerlitz <ogerlitz@mellanox.com>
[minor fix up to apply cleanly and compile fix]
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2014-02-07 14:41:38 +08:00
|
|
|
/* Between the forward and the backward locks exists a strict locking
|
|
|
|
* hierarchy. The mutual exclusion zone protected by the forward lock
|
|
|
|
* can enclose the mutual exclusion zone protected by the backward lock
|
|
|
|
* but not vice versa.
|
|
|
|
*/
|
|
|
|
spinlock_t frwd_lock; /* protects session state, *
|
|
|
|
* cmdsn, queued_cmdsn *
|
2006-04-07 10:13:41 +08:00
|
|
|
* session resources: *
|
[SCSI] libiscsi: Reduce locking contention in fast path
Replace the session lock with two locks, a forward lock and
a backwards lock named frwd_lock and back_lock respectively.
The forward lock protects resources that change while sending a
request to the target, such as cmdsn, queued_cmdsn, and allocating
task from the commands' pool with kfifo_out.
The backward lock protects resources that change while processing
a response or in error path, such as cmdsn_exp, cmdsn_max, and
returning tasks to the commands' pool with kfifo_in.
Under a steady state fast-path situation, that is when one
or more processes/threads submit IO to an iscsi device and
a single kernel upcall (e.g softirq) is dealing with processing
of responses without errors, this patch eliminates the contention
between the queuecommand()/request response/scsi_done() flows
associated with iscsi sessions.
Between the forward and the backward locks exists a strict locking
hierarchy. The mutual exclusion zone protected by the forward lock can
enclose the mutual exclusion zone protected by the backward lock but not
vice versa.
For example, in iscsi_conn_teardown or in iscsi_xmit_data when there is
a failure and __iscsi_put_task is called, the backward lock is taken while
the forward lock is still taken. On the other hand, if in the RX path a nop
is to be sent, for example in iscsi_handle_reject or __iscsi_complete_pdu
than the forward lock is released and the backward lock is taken for the
duration of iscsi_send_nopout, later the backward lock is released and the
forward lock is retaken.
libiscsi_tcp uses two kernel fifos the r2t pool and the r2t queue.
The insertion and deletion from these queues didn't corespond to the
assumption taken by the new forward/backwards session locking paradigm.
That is, in iscsi_tcp_clenup_task which belongs to the RX (backwards)
path, r2t is taken out from r2t queue and inserted to the r2t pool.
In iscsi_tcp_get_curr_r2t which belong to the TX (forward) path, r2t
is also inserted to the r2t pool and another r2t is pulled from r2t
queue.
Only in iscsi_tcp_r2t_rsp which is called in the RX path but can requeue
to the TX path, r2t is taken from the r2t pool and inserted to the r2t
queue.
In order to cope with this situation, two spin locks were added,
pool2queue and queue2pool. The former protects extracting from the
r2t pool and inserting to the r2t queue, and the later protects the
extracing from the r2t queue and inserting to the r2t pool.
Signed-off-by: Shlomo Pongratz <shlomop@mellanox.com>
Signed-off-by: Or Gerlitz <ogerlitz@mellanox.com>
[minor fix up to apply cleanly and compile fix]
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2014-02-07 14:41:38 +08:00
|
|
|
* - cmdpool kfifo_out , *
|
|
|
|
* - mgmtpool, */
|
|
|
|
spinlock_t back_lock; /* protects cmdsn_exp *
|
|
|
|
* cmdsn_max, *
|
|
|
|
* cmdpool kfifo_in */
|
2006-04-07 10:13:41 +08:00
|
|
|
int state; /* session state */
|
|
|
|
int age; /* counts session re-opens */
|
|
|
|
|
2008-05-22 04:54:06 +08:00
|
|
|
int scsi_cmds_max; /* max scsi commands */
|
2006-04-07 10:13:41 +08:00
|
|
|
int cmds_max; /* size of cmds array */
|
2008-05-22 04:54:09 +08:00
|
|
|
struct iscsi_task **cmds; /* Original Cmds arr */
|
2007-12-14 02:43:25 +08:00
|
|
|
struct iscsi_pool cmdpool; /* PDU's pool */
|
2009-09-22 10:51:22 +08:00
|
|
|
void *dd_data; /* LLD private data */
|
2006-04-07 10:13:41 +08:00
|
|
|
};
|
|
|
|
|
2008-09-25 00:46:10 +08:00
|
|
|
enum {
|
|
|
|
ISCSI_HOST_SETUP,
|
|
|
|
ISCSI_HOST_REMOVED,
|
|
|
|
};
|
|
|
|
|
2008-05-22 04:53:59 +08:00
|
|
|
struct iscsi_host {
|
|
|
|
char *initiatorname;
|
|
|
|
/* hw address or netdev iscsi connection is bound to */
|
|
|
|
char *hwaddress;
|
|
|
|
char *netdev;
|
2008-09-25 00:46:10 +08:00
|
|
|
|
|
|
|
wait_queue_head_t session_removal_wq;
|
|
|
|
/* protects sessions and state */
|
|
|
|
spinlock_t lock;
|
|
|
|
int num_sessions;
|
|
|
|
int state;
|
2009-03-06 04:46:03 +08:00
|
|
|
|
|
|
|
struct workqueue_struct *workq;
|
|
|
|
char workq_name[20];
|
2008-05-22 04:53:59 +08:00
|
|
|
};
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/*
|
|
|
|
* scsi host template
|
|
|
|
*/
|
2009-10-16 08:46:39 +08:00
|
|
|
extern int iscsi_change_queue_depth(struct scsi_device *sdev, int depth,
|
|
|
|
int reason);
|
2006-04-07 10:13:41 +08:00
|
|
|
extern int iscsi_eh_abort(struct scsi_cmnd *sc);
|
2010-02-20 10:32:10 +08:00
|
|
|
extern int iscsi_eh_recover_target(struct scsi_cmnd *sc);
|
|
|
|
extern int iscsi_eh_session_reset(struct scsi_cmnd *sc);
|
2007-12-14 02:43:20 +08:00
|
|
|
extern int iscsi_eh_device_reset(struct scsi_cmnd *sc);
|
2010-12-31 16:22:21 +08:00
|
|
|
extern int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc);
|
2007-05-31 01:57:12 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* iSCSI host helpers.
|
|
|
|
*/
|
2008-05-22 04:54:01 +08:00
|
|
|
#define iscsi_host_priv(_shost) \
|
|
|
|
(shost_priv(_shost) + sizeof(struct iscsi_host))
|
|
|
|
|
2007-05-31 01:57:12 +08:00
|
|
|
extern int iscsi_host_set_param(struct Scsi_Host *shost,
|
|
|
|
enum iscsi_host_param param, char *buf,
|
|
|
|
int buflen);
|
|
|
|
extern int iscsi_host_get_param(struct Scsi_Host *shost,
|
|
|
|
enum iscsi_host_param param, char *buf);
|
2008-05-22 04:54:00 +08:00
|
|
|
extern int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev);
|
|
|
|
extern struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht,
|
2009-03-06 04:46:04 +08:00
|
|
|
int dd_data_size,
|
2009-03-06 04:46:03 +08:00
|
|
|
bool xmit_can_sleep);
|
2008-05-22 04:54:00 +08:00
|
|
|
extern void iscsi_host_remove(struct Scsi_Host *shost);
|
|
|
|
extern void iscsi_host_free(struct Scsi_Host *shost);
|
2009-04-22 04:32:32 +08:00
|
|
|
extern int iscsi_target_alloc(struct scsi_target *starget);
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* session management
|
|
|
|
*/
|
|
|
|
extern struct iscsi_cls_session *
|
2008-05-22 04:53:59 +08:00
|
|
|
iscsi_session_setup(struct iscsi_transport *, struct Scsi_Host *shost,
|
2009-09-22 10:51:22 +08:00
|
|
|
uint16_t, int, int, uint32_t, unsigned int);
|
2006-04-07 10:13:41 +08:00
|
|
|
extern void iscsi_session_teardown(struct iscsi_cls_session *);
|
|
|
|
extern void iscsi_session_recovery_timedout(struct iscsi_cls_session *);
|
2006-06-29 01:00:23 +08:00
|
|
|
extern int iscsi_set_param(struct iscsi_cls_conn *cls_conn,
|
|
|
|
enum iscsi_param param, char *buf, int buflen);
|
|
|
|
extern int iscsi_session_get_param(struct iscsi_cls_session *cls_session,
|
|
|
|
enum iscsi_param param, char *buf);
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2008-02-01 03:36:52 +08:00
|
|
|
#define iscsi_session_printk(prefix, _sess, fmt, a...) \
|
2008-05-22 04:53:59 +08:00
|
|
|
iscsi_cls_session_printk(prefix, _sess->cls_session, fmt, ##a)
|
2008-02-01 03:36:52 +08:00
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/*
|
|
|
|
* connection management
|
|
|
|
*/
|
|
|
|
extern struct iscsi_cls_conn *iscsi_conn_setup(struct iscsi_cls_session *,
|
2008-05-22 04:54:01 +08:00
|
|
|
int, uint32_t);
|
2006-04-07 10:13:41 +08:00
|
|
|
extern void iscsi_conn_teardown(struct iscsi_cls_conn *);
|
|
|
|
extern int iscsi_conn_start(struct iscsi_cls_conn *);
|
|
|
|
extern void iscsi_conn_stop(struct iscsi_cls_conn *, int);
|
|
|
|
extern int iscsi_conn_bind(struct iscsi_cls_session *, struct iscsi_cls_conn *,
|
|
|
|
int);
|
|
|
|
extern void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err);
|
2009-03-06 04:46:05 +08:00
|
|
|
extern void iscsi_session_failure(struct iscsi_session *session,
|
2008-09-25 00:46:10 +08:00
|
|
|
enum iscsi_err err);
|
2006-06-29 01:00:23 +08:00
|
|
|
extern int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
|
|
|
|
enum iscsi_param param, char *buf);
|
2011-02-17 05:04:35 +08:00
|
|
|
extern int iscsi_conn_get_addr_param(struct sockaddr_storage *addr,
|
|
|
|
enum iscsi_param param, char *buf);
|
2008-05-22 04:54:02 +08:00
|
|
|
extern void iscsi_suspend_tx(struct iscsi_conn *conn);
|
2009-09-05 10:05:33 +08:00
|
|
|
extern void iscsi_suspend_queue(struct iscsi_conn *conn);
|
2009-03-06 04:46:03 +08:00
|
|
|
extern void iscsi_conn_queue_work(struct iscsi_conn *conn);
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2008-02-01 03:36:52 +08:00
|
|
|
#define iscsi_conn_printk(prefix, _c, fmt, a...) \
|
2008-05-22 04:54:02 +08:00
|
|
|
iscsi_cls_conn_printk(prefix, ((struct iscsi_conn *)_c)->cls_conn, \
|
|
|
|
fmt, ##a)
|
2008-02-01 03:36:52 +08:00
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
/*
|
|
|
|
* pdu and task processing
|
|
|
|
*/
|
2007-05-31 01:57:18 +08:00
|
|
|
extern void iscsi_update_cmdsn(struct iscsi_session *, struct iscsi_nopin *);
|
2008-12-02 14:32:05 +08:00
|
|
|
extern void iscsi_prep_data_out_pdu(struct iscsi_task *task,
|
|
|
|
struct iscsi_r2t_info *r2t,
|
|
|
|
struct iscsi_data *hdr);
|
2006-04-07 10:13:41 +08:00
|
|
|
extern int iscsi_conn_send_pdu(struct iscsi_cls_conn *, struct iscsi_hdr *,
|
|
|
|
char *, uint32_t);
|
|
|
|
extern int iscsi_complete_pdu(struct iscsi_conn *, struct iscsi_hdr *,
|
|
|
|
char *, int);
|
2008-05-22 04:54:18 +08:00
|
|
|
extern int __iscsi_complete_pdu(struct iscsi_conn *, struct iscsi_hdr *,
|
|
|
|
char *, int);
|
2008-05-22 04:54:04 +08:00
|
|
|
extern int iscsi_verify_itt(struct iscsi_conn *, itt_t);
|
2008-05-22 04:54:09 +08:00
|
|
|
extern struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *, itt_t);
|
2009-05-14 06:57:41 +08:00
|
|
|
extern struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *, itt_t);
|
2008-05-22 04:54:09 +08:00
|
|
|
extern void iscsi_requeue_task(struct iscsi_task *task);
|
|
|
|
extern void iscsi_put_task(struct iscsi_task *task);
|
2010-11-24 07:29:21 +08:00
|
|
|
extern void __iscsi_put_task(struct iscsi_task *task);
|
2008-05-22 04:54:18 +08:00
|
|
|
extern void __iscsi_get_task(struct iscsi_task *task);
|
2009-09-05 10:04:23 +08:00
|
|
|
extern void iscsi_complete_scsi_task(struct iscsi_task *task,
|
|
|
|
uint32_t exp_cmdsn, uint32_t max_cmdsn);
|
2006-04-07 10:13:41 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* generic helpers
|
|
|
|
*/
|
2007-12-14 02:43:25 +08:00
|
|
|
extern void iscsi_pool_free(struct iscsi_pool *);
|
|
|
|
extern int iscsi_pool_init(struct iscsi_pool *, int, void ***, int);
|
2013-03-22 19:41:30 +08:00
|
|
|
extern int iscsi_switch_str_param(char **, char *);
|
2006-04-07 10:13:41 +08:00
|
|
|
|
2007-12-14 02:43:23 +08:00
|
|
|
/*
|
|
|
|
* inline functions to deal with padding.
|
|
|
|
*/
|
|
|
|
static inline unsigned int
|
|
|
|
iscsi_padded(unsigned int len)
|
|
|
|
{
|
|
|
|
return (len + ISCSI_PAD_LEN - 1) & ~(ISCSI_PAD_LEN - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int
|
|
|
|
iscsi_padding(unsigned int len)
|
|
|
|
{
|
|
|
|
len &= (ISCSI_PAD_LEN - 1);
|
|
|
|
if (len)
|
|
|
|
len = ISCSI_PAD_LEN - len;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2006-04-07 10:13:41 +08:00
|
|
|
#endif
|