static struct workqueue_struct *isert_release_wq;
static int
-isert_put_response(struct iscsi_conn *conn, struct iscsit_cmd *cmd);
+isert_put_response(struct iscsit_conn *conn, struct iscsit_cmd *cmd);
static int
isert_login_post_recv(struct isert_conn *isert_conn);
static int
}
static int
-isert_put_login_tx(struct iscsi_conn *conn, struct iscsi_login *login,
+isert_put_login_tx(struct iscsit_conn *conn, struct iscsi_login *login,
u32 length)
{
struct isert_conn *isert_conn = conn->context;
{
struct iser_rx_desc *rx_desc = isert_conn->login_desc;
int rx_buflen = isert_conn->login_req_len;
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
struct iscsi_login *login = conn->conn_login;
int size;
}
static struct iscsit_cmd
-*isert_allocate_cmd(struct iscsi_conn *conn, struct iser_rx_desc *rx_desc)
+*isert_allocate_cmd(struct iscsit_conn *conn, struct iser_rx_desc *rx_desc)
{
struct isert_conn *isert_conn = conn->context;
struct isert_cmd *isert_cmd;
struct isert_cmd *isert_cmd, struct iscsit_cmd *cmd,
struct iser_rx_desc *rx_desc, unsigned char *buf)
{
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
struct iscsi_scsi_req *hdr = (struct iscsi_scsi_req *)buf;
int imm_data, imm_data_len, unsol_data, sg_nents, rc;
bool dump_payload = false;
struct iser_rx_desc *rx_desc, unsigned char *buf)
{
struct scatterlist *sg_start;
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
struct iscsit_cmd *cmd = NULL;
struct iscsi_data *hdr = (struct iscsi_data *)buf;
u32 unsol_data_len = ntoh24(hdr->dlength);
struct iscsit_cmd *cmd, struct iser_rx_desc *rx_desc,
unsigned char *buf)
{
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
struct iscsi_nopout *hdr = (struct iscsi_nopout *)buf;
int rc;
struct iscsit_cmd *cmd, struct iser_rx_desc *rx_desc,
struct iscsi_text *hdr)
{
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
u32 payload_length = ntoh24(hdr->dlength);
int rc;
unsigned char *text_in = NULL;
uint32_t write_stag, uint64_t write_va)
{
struct iscsi_hdr *hdr = isert_get_iscsi_hdr(rx_desc);
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
struct iscsit_cmd *cmd;
struct isert_cmd *isert_cmd;
int ret = -EINVAL;
{
struct iscsit_cmd *cmd = isert_cmd->iscsit_cmd;
struct isert_conn *isert_conn = isert_cmd->conn;
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
struct iscsi_text_rsp *hdr;
isert_dbg("Cmd %p\n", isert_cmd);
}
static int
-isert_put_response(struct iscsi_conn *conn, struct iscsit_cmd *cmd)
+isert_put_response(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
struct isert_conn *isert_conn = conn->context;
}
static void
-isert_aborted_task(struct iscsi_conn *conn, struct iscsit_cmd *cmd)
+isert_aborted_task(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
struct isert_conn *isert_conn = conn->context;
}
static enum target_prot_op
-isert_get_sup_prot_ops(struct iscsi_conn *conn)
+isert_get_sup_prot_ops(struct iscsit_conn *conn)
{
struct isert_conn *isert_conn = conn->context;
struct isert_device *device = isert_conn->device;
}
static int
-isert_put_nopin(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+isert_put_nopin(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
bool nopout_response)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
}
static int
-isert_put_logout_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+isert_put_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
struct isert_conn *isert_conn = conn->context;
}
static int
-isert_put_tm_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+isert_put_tm_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
struct isert_conn *isert_conn = conn->context;
}
static int
-isert_put_reject(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+isert_put_reject(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
struct isert_conn *isert_conn = conn->context;
}
static int
-isert_put_text_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+isert_put_text_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
struct isert_conn *isert_conn = conn->context;
}
static int
-isert_put_datain(struct iscsi_conn *conn, struct iscsit_cmd *cmd)
+isert_put_datain(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
{
struct se_cmd *se_cmd = &cmd->se_cmd;
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
}
static int
-isert_get_dataout(struct iscsi_conn *conn, struct iscsit_cmd *cmd, bool recovery)
+isert_get_dataout(struct iscsit_conn *conn, struct iscsit_cmd *cmd, bool recovery)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
int ret;
}
static int
-isert_immediate_queue(struct iscsi_conn *conn, struct iscsit_cmd *cmd, int state)
+isert_immediate_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int state)
{
struct isert_cmd *isert_cmd = iscsit_priv_cmd(cmd);
int ret = 0;
}
static int
-isert_response_queue(struct iscsi_conn *conn, struct iscsit_cmd *cmd, int state)
+isert_response_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int state)
{
struct isert_conn *isert_conn = conn->context;
int ret;
}
static int
-isert_get_login_rx(struct iscsi_conn *conn, struct iscsi_login *login)
+isert_get_login_rx(struct iscsit_conn *conn, struct iscsi_login *login)
{
struct isert_conn *isert_conn = conn->context;
int ret;
}
static void
-isert_set_conn_info(struct iscsi_np *np, struct iscsi_conn *conn,
+isert_set_conn_info(struct iscsi_np *np, struct iscsit_conn *conn,
struct isert_conn *isert_conn)
{
struct rdma_cm_id *cm_id = isert_conn->cm_id;
}
static int
-isert_accept_np(struct iscsi_np *np, struct iscsi_conn *conn)
+isert_accept_np(struct iscsi_np *np, struct iscsit_conn *conn)
{
struct isert_np *isert_np = np->np_context;
struct isert_conn *isert_conn;
static void
isert_wait4logout(struct isert_conn *isert_conn)
{
- struct iscsi_conn *conn = isert_conn->conn;
+ struct iscsit_conn *conn = isert_conn->conn;
isert_info("conn %p\n", isert_conn);
}
static void
-isert_wait4cmds(struct iscsi_conn *conn)
+isert_wait4cmds(struct iscsit_conn *conn)
{
- isert_info("iscsi_conn %p\n", conn);
+ isert_info("iscsit_conn %p\n", conn);
if (conn->sess) {
target_stop_session(conn->sess->se_sess);
* before blocking on the target_wait_for_session_cmds
*/
static void
-isert_put_unsol_pending_cmds(struct iscsi_conn *conn)
+isert_put_unsol_pending_cmds(struct iscsit_conn *conn)
{
struct iscsit_cmd *cmd, *tmp;
static LIST_HEAD(drop_cmd_list);
}
}
-static void isert_wait_conn(struct iscsi_conn *conn)
+static void isert_wait_conn(struct iscsit_conn *conn)
{
struct isert_conn *isert_conn = conn->context;
queue_work(isert_release_wq, &isert_conn->release_work);
}
-static void isert_free_conn(struct iscsi_conn *conn)
+static void isert_free_conn(struct iscsit_conn *conn)
{
struct isert_conn *isert_conn = conn->context;
isert_put_conn(isert_conn);
}
-static void isert_get_rx_pdu(struct iscsi_conn *conn)
+static void isert_get_rx_pdu(struct iscsit_conn *conn)
{
struct completion comp;
u64 login_rsp_dma;
struct iser_rx_desc *rx_descs;
struct ib_recv_wr rx_wr[ISERT_QP_MAX_RECV_DTOS];
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
struct list_head node;
struct completion login_comp;
struct completion login_req_comp;
struct cxgbit_sock {
struct cxgbit_sock_common com;
struct cxgbit_np *cnp;
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
struct l2t_entry *l2t;
struct dst_entry *dst;
struct list_head list;
int cxgbit_setup_np(struct iscsi_np *, struct sockaddr_storage *);
int cxgbit_setup_conn_digest(struct cxgbit_sock *);
-int cxgbit_accept_np(struct iscsi_np *, struct iscsi_conn *);
+int cxgbit_accept_np(struct iscsi_np *, struct iscsit_conn *);
void cxgbit_free_np(struct iscsi_np *);
void cxgbit_abort_conn(struct cxgbit_sock *csk);
-void cxgbit_free_conn(struct iscsi_conn *);
+void cxgbit_free_conn(struct iscsit_conn *);
extern cxgbit_cplhandler_func cxgbit_cplhandlers[NUM_CPL_CMDS];
-int cxgbit_get_login_rx(struct iscsi_conn *, struct iscsi_login *);
+int cxgbit_get_login_rx(struct iscsit_conn *, struct iscsi_login *);
int cxgbit_rx_data_ack(struct cxgbit_sock *);
int cxgbit_l2t_send(struct cxgbit_device *, struct sk_buff *,
struct l2t_entry *);
void cxgbit_push_tx_frames(struct cxgbit_sock *);
-int cxgbit_put_login_tx(struct iscsi_conn *, struct iscsi_login *, u32);
-int cxgbit_xmit_pdu(struct iscsi_conn *, struct iscsit_cmd *,
+int cxgbit_put_login_tx(struct iscsit_conn *, struct iscsi_login *, u32);
+int cxgbit_xmit_pdu(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_datain_req *, const void *, u32);
-void cxgbit_get_r2t_ttt(struct iscsi_conn *, struct iscsit_cmd *,
+void cxgbit_get_r2t_ttt(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_r2t *);
u32 cxgbit_send_tx_flowc_wr(struct cxgbit_sock *);
int cxgbit_ofld_send(struct cxgbit_device *, struct sk_buff *);
-void cxgbit_get_rx_pdu(struct iscsi_conn *);
-int cxgbit_validate_params(struct iscsi_conn *);
+void cxgbit_get_rx_pdu(struct iscsit_conn *);
+int cxgbit_validate_params(struct iscsit_conn *);
struct cxgbit_device *cxgbit_find_device(struct net_device *, u8 *);
/* DDP */
int cxgbit_ddp_init(struct cxgbit_device *);
int cxgbit_setup_conn_pgidx(struct cxgbit_sock *, u32);
int cxgbit_reserve_ttt(struct cxgbit_sock *, struct iscsit_cmd *);
-void cxgbit_unmap_cmd(struct iscsi_conn *, struct iscsit_cmd *);
+void cxgbit_unmap_cmd(struct iscsit_conn *, struct iscsit_cmd *);
static inline
struct cxgbi_ppm *cdev2ppm(struct cxgbit_device *cdev)
}
static void
-cxgbit_set_conn_info(struct iscsi_np *np, struct iscsi_conn *conn,
+cxgbit_set_conn_info(struct iscsi_np *np, struct iscsit_conn *conn,
struct cxgbit_sock *csk)
{
conn->login_family = np->np_sockaddr.ss_family;
conn->local_sockaddr = csk->com.local_addr;
}
-int cxgbit_accept_np(struct iscsi_np *np, struct iscsi_conn *conn)
+int cxgbit_accept_np(struct iscsi_np *np, struct iscsit_conn *conn)
{
struct cxgbit_np *cnp = np->np_context;
struct cxgbit_sock *csk;
static void __cxgbit_free_conn(struct cxgbit_sock *csk)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
bool release = false;
pr_debug("%s: state %d\n",
cxgbit_put_csk(csk);
}
-void cxgbit_free_conn(struct iscsi_conn *conn)
+void cxgbit_free_conn(struct iscsit_conn *conn)
{
__cxgbit_free_conn(conn->context);
}
}
void
-cxgbit_get_r2t_ttt(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+cxgbit_get_r2t_ttt(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_r2t *r2t)
{
struct cxgbit_sock *csk = conn->context;
r2t->targ_xfer_tag = ttinfo->tag;
}
-void cxgbit_unmap_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd)
+void cxgbit_unmap_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
{
struct cxgbit_cmd *ccmd = iscsit_priv_cmd(cmd);
}
#endif
-static enum target_prot_op cxgbit_get_sup_prot_ops(struct iscsi_conn *conn)
+static enum target_prot_op cxgbit_get_sup_prot_ops(struct iscsit_conn *conn)
{
return TARGET_PROT_NORMAL;
}
cxgbit_tx_datain_iso(struct cxgbit_sock *csk, struct iscsit_cmd *cmd,
struct iscsi_datain_req *dr)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct sk_buff *skb;
struct iscsi_datain datain;
struct cxgbit_iso_info iso_info;
}
static int
-cxgbit_xmit_datain_pdu(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+cxgbit_xmit_datain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_datain_req *dr,
const struct iscsi_datain *datain)
{
}
static int
-cxgbit_xmit_nondatain_pdu(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+cxgbit_xmit_nondatain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
const void *data_buf, u32 data_buf_len)
{
struct cxgbit_sock *csk = conn->context;
}
int
-cxgbit_xmit_pdu(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+cxgbit_xmit_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_datain_req *dr, const void *buf, u32 buf_len)
{
if (dr)
return cxgbit_xmit_nondatain_pdu(conn, cmd, buf, buf_len);
}
-int cxgbit_validate_params(struct iscsi_conn *conn)
+int cxgbit_validate_params(struct iscsit_conn *conn)
{
struct cxgbit_sock *csk = conn->context;
struct cxgbit_device *cdev = csk->com.cdev;
static int cxgbit_set_digest(struct cxgbit_sock *csk)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct iscsi_param *param;
param = iscsi_find_param_from_key(HEADERDIGEST, conn->param_list);
static int cxgbit_set_iso_npdu(struct cxgbit_sock *csk)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct iscsi_conn_ops *conn_ops = conn->conn_ops;
struct iscsi_param *param;
u32 mrdsl, mbl;
*/
static int cxgbit_seq_pdu_inorder(struct cxgbit_sock *csk)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct iscsi_param *param;
if (conn->login->leading_connection) {
return 0;
}
-static int cxgbit_set_params(struct iscsi_conn *conn)
+static int cxgbit_set_params(struct iscsit_conn *conn)
{
struct cxgbit_sock *csk = conn->context;
struct cxgbit_device *cdev = csk->com.cdev;
}
int
-cxgbit_put_login_tx(struct iscsi_conn *conn, struct iscsi_login *login,
+cxgbit_put_login_tx(struct iscsit_conn *conn, struct iscsi_login *login,
u32 length)
{
struct cxgbit_sock *csk = conn->context;
static struct iscsit_cmd *cxgbit_allocate_cmd(struct cxgbit_sock *csk)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct cxgbi_ppm *ppm = cdev2ppm(csk->com.cdev);
struct cxgbit_cmd *ccmd;
struct iscsit_cmd *cmd;
cxgbit_handle_immediate_data(struct iscsit_cmd *cmd, struct iscsi_scsi_req *hdr,
u32 length)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct cxgbit_sock *csk = conn->context;
struct cxgbit_lro_pdu_cb *pdu_cb = cxgbit_rx_pdu_cb(csk->skb);
cxgbit_get_immediate_data(struct iscsit_cmd *cmd, struct iscsi_scsi_req *hdr,
bool dump_payload)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
int cmdsn_ret = 0, immed_ret = IMMEDIATE_DATA_NORMAL_OPERATION;
/*
* Special case for Unsupported SAM WRITE Opcodes and ImmediateData=Yes.
static int
cxgbit_handle_scsi_cmd(struct cxgbit_sock *csk, struct iscsit_cmd *cmd)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct cxgbit_lro_pdu_cb *pdu_cb = cxgbit_rx_pdu_cb(csk->skb);
struct iscsi_scsi_req *hdr = (struct iscsi_scsi_req *)pdu_cb->hdr;
int rc;
static int cxgbit_handle_iscsi_dataout(struct cxgbit_sock *csk)
{
struct scatterlist *sg_start;
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct iscsit_cmd *cmd = NULL;
struct cxgbit_cmd *ccmd;
struct cxgbi_task_tag_info *ttinfo;
static int cxgbit_handle_nop_out(struct cxgbit_sock *csk, struct iscsit_cmd *cmd)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct cxgbit_lro_pdu_cb *pdu_cb = cxgbit_rx_pdu_cb(csk->skb);
struct iscsi_nopout *hdr = (struct iscsi_nopout *)pdu_cb->hdr;
unsigned char *ping_data = NULL;
static int
cxgbit_handle_text_cmd(struct cxgbit_sock *csk, struct iscsit_cmd *cmd)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct cxgbit_lro_pdu_cb *pdu_cb = cxgbit_rx_pdu_cb(csk->skb);
struct iscsi_text *hdr = (struct iscsi_text *)pdu_cb->hdr;
u32 payload_length = pdu_cb->dlen;
{
struct cxgbit_lro_pdu_cb *pdu_cb = cxgbit_rx_pdu_cb(csk->skb);
struct iscsi_hdr *hdr = (struct iscsi_hdr *)pdu_cb->hdr;
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct iscsit_cmd *cmd = NULL;
u8 opcode = (hdr->opcode & ISCSI_OPCODE_MASK);
int ret = -EINVAL;
static int cxgbit_rx_opcode(struct cxgbit_sock *csk)
{
struct cxgbit_lro_pdu_cb *pdu_cb = cxgbit_rx_pdu_cb(csk->skb);
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct iscsi_hdr *hdr = pdu_cb->hdr;
u8 opcode;
static int cxgbit_rx_login_pdu(struct cxgbit_sock *csk)
{
- struct iscsi_conn *conn = csk->conn;
+ struct iscsit_conn *conn = csk->conn;
struct iscsi_login *login = conn->login;
struct cxgbit_lro_pdu_cb *pdu_cb = cxgbit_rx_pdu_cb(csk->skb);
struct iscsi_login_req *login_req;
return -1;
}
-int cxgbit_get_login_rx(struct iscsi_conn *conn, struct iscsi_login *login)
+int cxgbit_get_login_rx(struct iscsit_conn *conn, struct iscsi_login *login)
{
struct cxgbit_sock *csk = conn->context;
int ret = -1;
return ret;
}
-void cxgbit_get_rx_pdu(struct iscsi_conn *conn)
+void cxgbit_get_rx_pdu(struct iscsit_conn *conn)
{
struct cxgbit_sock *csk = conn->context;
return 0;
}
-static void iscsit_get_rx_pdu(struct iscsi_conn *);
+static void iscsit_get_rx_pdu(struct iscsit_conn *);
-int iscsit_queue_rsp(struct iscsi_conn *conn, struct iscsit_cmd *cmd)
+int iscsit_queue_rsp(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
{
return iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
}
EXPORT_SYMBOL(iscsit_queue_rsp);
-void iscsit_aborted_task(struct iscsi_conn *conn, struct iscsit_cmd *cmd)
+void iscsit_aborted_task(struct iscsit_conn *conn, struct iscsit_cmd *cmd)
{
spin_lock_bh(&conn->cmd_lock);
if (!list_empty(&cmd->i_conn_node))
static void iscsit_do_crypto_hash_buf(struct ahash_request *, const void *,
u32, u32, const void *, void *);
-static void iscsit_tx_thread_wait_for_tcp(struct iscsi_conn *);
+static void iscsit_tx_thread_wait_for_tcp(struct iscsit_conn *);
static int
-iscsit_xmit_nondatain_pdu(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_xmit_nondatain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
const void *data_buf, u32 data_buf_len)
{
struct iscsi_hdr *hdr = (struct iscsi_hdr *)cmd->pdu;
static u32 iscsit_do_crypto_hash_sg(struct ahash_request *, struct iscsit_cmd *,
u32, u32, u32, u8 *);
static int
-iscsit_xmit_datain_pdu(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_xmit_datain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
const struct iscsi_datain *datain)
{
struct kvec *iov;
return 0;
}
-static int iscsit_xmit_pdu(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+static int iscsit_xmit_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_datain_req *dr, const void *buf,
u32 buf_len)
{
return iscsit_xmit_nondatain_pdu(conn, cmd, buf, buf_len);
}
-static enum target_prot_op iscsit_get_sup_prot_ops(struct iscsi_conn *conn)
+static enum target_prot_op iscsit_get_sup_prot_ops(struct iscsit_conn *conn)
{
return TARGET_PROT_NORMAL;
}
}
int iscsit_add_reject(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u8 reason,
unsigned char *buf)
{
bool add_to_conn,
unsigned char *buf)
{
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
const bool do_put = cmd->se_cmd.se_tfo != NULL;
if (!cmd->conn) {
kunmap(sg_page(&sg[i]));
}
-static void iscsit_ack_from_expstatsn(struct iscsi_conn *conn, u32 exp_statsn)
+static void iscsit_ack_from_expstatsn(struct iscsit_conn *conn, u32 exp_statsn)
{
LIST_HEAD(ack_list);
struct iscsit_cmd *cmd, *cmd_p;
return 0;
}
-int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char *buf)
{
int data_direction, payload_length;
}
EXPORT_SYMBOL(iscsit_set_unsolicited_dataout);
-int iscsit_process_scsi_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+int iscsit_process_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_scsi_req *hdr)
{
int cmdsn_ret = 0;
}
static int
-iscsit_handle_scsi_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_handle_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char *buf)
{
struct iscsi_scsi_req *hdr = (struct iscsi_scsi_req *)buf;
}
int
-__iscsit_check_dataout_hdr(struct iscsi_conn *conn, void *buf,
+__iscsit_check_dataout_hdr(struct iscsit_conn *conn, void *buf,
struct iscsit_cmd *cmd, u32 payload_length,
bool *success)
{
EXPORT_SYMBOL(__iscsit_check_dataout_hdr);
int
-iscsit_check_dataout_hdr(struct iscsi_conn *conn, void *buf,
+iscsit_check_dataout_hdr(struct iscsit_conn *conn, void *buf,
struct iscsit_cmd **out_cmd)
{
struct iscsi_data *hdr = buf;
EXPORT_SYMBOL(iscsit_check_dataout_hdr);
static int
-iscsit_get_dataout(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_get_dataout(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_data *hdr)
{
struct kvec *iov;
iscsit_check_dataout_payload(struct iscsit_cmd *cmd, struct iscsi_data *hdr,
bool data_crc_failed)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
int rc, ooo_cmdsn;
/*
* Increment post receive data and CRC values or perform
}
EXPORT_SYMBOL(iscsit_check_dataout_payload);
-static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf)
+static int iscsit_handle_data_out(struct iscsit_conn *conn, unsigned char *buf)
{
struct iscsit_cmd *cmd = NULL;
struct iscsi_data *hdr = (struct iscsi_data *)buf;
return iscsit_check_dataout_payload(cmd, hdr, data_crc_failed);
}
-int iscsit_setup_nop_out(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+int iscsit_setup_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_nopout *hdr)
{
u32 payload_length = ntoh24(hdr->dlength);
}
EXPORT_SYMBOL(iscsit_setup_nop_out);
-int iscsit_process_nop_out(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+int iscsit_process_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_nopout *hdr)
{
struct iscsit_cmd *cmd_p = NULL;
}
EXPORT_SYMBOL(iscsit_process_nop_out);
-static int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+static int iscsit_handle_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char *buf)
{
unsigned char *ping_data = NULL;
}
int
-iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char *buf)
{
struct se_tmr_req *se_tmr;
/* #warning FIXME: Support Text Command parameters besides SendTargets */
int
-iscsit_setup_text_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_setup_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_text *hdr)
{
u32 payload_length = ntoh24(hdr->dlength);
EXPORT_SYMBOL(iscsit_setup_text_cmd);
int
-iscsit_process_text_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_process_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
struct iscsi_text *hdr)
{
unsigned char *text_in = cmd->text_in_ptr, *text_ptr;
EXPORT_SYMBOL(iscsit_process_text_cmd);
static int
-iscsit_handle_text_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_handle_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char *buf)
{
struct iscsi_text *hdr = (struct iscsi_text *)buf;
return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
}
-int iscsit_logout_closesession(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+int iscsit_logout_closesession(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
- struct iscsi_conn *conn_p;
+ struct iscsit_conn *conn_p;
struct iscsi_session *sess = conn->sess;
pr_debug("Received logout request CLOSESESSION on CID: %hu"
return 0;
}
-int iscsit_logout_closeconnection(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+int iscsit_logout_closeconnection(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
- struct iscsi_conn *l_conn;
+ struct iscsit_conn *l_conn;
struct iscsi_session *sess = conn->sess;
pr_debug("Received logout request CLOSECONNECTION for CID:"
return 0;
}
-int iscsit_logout_removeconnforrecovery(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+int iscsit_logout_removeconnforrecovery(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
}
int
-iscsit_handle_logout_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+iscsit_handle_logout_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char *buf)
{
int cmdsn_ret, logout_remove = 0;
EXPORT_SYMBOL(iscsit_handle_logout_cmd);
int iscsit_handle_snack(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
unsigned char *buf)
{
struct iscsi_snack *hdr;
}
EXPORT_SYMBOL(iscsit_handle_snack);
-static void iscsit_rx_thread_wait_for_tcp(struct iscsi_conn *conn)
+static void iscsit_rx_thread_wait_for_tcp(struct iscsit_conn *conn)
{
if ((conn->sock->sk->sk_shutdown & SEND_SHUTDOWN) ||
(conn->sock->sk->sk_shutdown & RCV_SHUTDOWN)) {
{
int iov_ret, rx_got = 0, rx_size = 0;
u32 checksum, iov_count = 0, padding = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct kvec *iov;
void *overflow_buf = NULL;
/* #warning iscsi_build_conn_drop_async_message() only sends out on connections
with active network interface */
-static void iscsit_build_conn_drop_async_message(struct iscsi_conn *conn)
+static void iscsit_build_conn_drop_async_message(struct iscsit_conn *conn)
{
struct iscsit_cmd *cmd;
- struct iscsi_conn *conn_p;
+ struct iscsit_conn *conn_p;
bool found = false;
lockdep_assert_held(&conn->sess->conn_lock);
static int iscsit_send_conn_drop_async_message(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_async *hdr;
return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
}
-static void iscsit_tx_thread_wait_for_tcp(struct iscsi_conn *conn)
+static void iscsit_tx_thread_wait_for_tcp(struct iscsit_conn *conn)
{
if ((conn->sock->sk->sk_shutdown & SEND_SHUTDOWN) ||
(conn->sock->sk->sk_shutdown & RCV_SHUTDOWN)) {
}
void
-iscsit_build_datain_pdu(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+iscsit_build_datain_pdu(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
struct iscsi_datain *datain, struct iscsi_data_rsp *hdr,
bool set_statsn)
{
}
EXPORT_SYMBOL(iscsit_build_datain_pdu);
-static int iscsit_send_datain(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+static int iscsit_send_datain(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct iscsi_data_rsp *hdr = (struct iscsi_data_rsp *)&cmd->pdu[0];
struct iscsi_datain datain;
}
int
-iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
struct iscsi_logout_rsp *hdr)
{
- struct iscsi_conn *logout_conn = NULL;
+ struct iscsit_conn *logout_conn = NULL;
struct iscsi_conn_recovery *cr = NULL;
struct iscsi_session *sess = conn->sess;
/*
EXPORT_SYMBOL(iscsit_build_logout_rsp);
static int
-iscsit_send_logout(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+iscsit_send_logout(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
int rc;
}
void
-iscsit_build_nopin_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+iscsit_build_nopin_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
struct iscsi_nopin *hdr, bool nopout_response)
{
hdr->opcode = ISCSI_OP_NOOP_IN;
*/
static int iscsit_send_unsolicited_nopin(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
int want_response)
{
struct iscsi_nopin *hdr = (struct iscsi_nopin *)&cmd->pdu[0];
}
static int
-iscsit_send_nopin(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+iscsit_send_nopin(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct iscsi_nopin *hdr = (struct iscsi_nopin *)&cmd->pdu[0];
static int iscsit_send_r2t(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_r2t *r2t;
struct iscsi_r2t_rsp *hdr;
* connection recovery.
*/
int iscsit_build_r2ts_for_cmd(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsit_cmd *cmd,
bool recovery)
{
}
EXPORT_SYMBOL(iscsit_build_r2ts_for_cmd);
-void iscsit_build_rsp_pdu(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+void iscsit_build_rsp_pdu(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
bool inc_stat_sn, struct iscsi_scsi_rsp *hdr)
{
if (inc_stat_sn)
}
EXPORT_SYMBOL(iscsit_build_rsp_pdu);
-static int iscsit_send_response(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+static int iscsit_send_response(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct iscsi_scsi_rsp *hdr = (struct iscsi_scsi_rsp *)&cmd->pdu[0];
bool inc_stat_sn = (cmd->i_state == ISTATE_SEND_STATUS);
}
void
-iscsit_build_task_mgt_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+iscsit_build_task_mgt_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
struct iscsi_tm_rsp *hdr)
{
struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
EXPORT_SYMBOL(iscsit_build_task_mgt_rsp);
static int
-iscsit_send_task_mgt_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+iscsit_send_task_mgt_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct iscsi_tm_rsp *hdr = (struct iscsi_tm_rsp *)&cmd->pdu[0];
int skip_bytes, bool *completed)
{
char *payload = NULL;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_portal_group *tpg;
struct iscsi_tiqn *tiqn;
struct iscsi_tpg_np *tpg_np;
}
int
-iscsit_build_text_rsp(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+iscsit_build_text_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
struct iscsi_text_rsp *hdr,
enum iscsit_transport_type network_transport)
{
static int iscsit_send_text_rsp(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_text_rsp *hdr = (struct iscsi_text_rsp *)cmd->pdu;
int text_length;
}
void
-iscsit_build_reject(struct iscsit_cmd *cmd, struct iscsi_conn *conn,
+iscsit_build_reject(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
struct iscsi_reject *hdr)
{
hdr->opcode = ISCSI_OP_REJECT;
static int iscsit_send_reject(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_reject *hdr = (struct iscsi_reject *)&cmd->pdu[0];
ISCSI_HDR_LEN);
}
-void iscsit_thread_get_cpumask(struct iscsi_conn *conn)
+void iscsit_thread_get_cpumask(struct iscsit_conn *conn)
{
int ord, cpu;
cpumask_t conn_allowed_cpumask;
cpumask_setall(conn->conn_cpumask);
}
-static void iscsit_thread_reschedule(struct iscsi_conn *conn)
+static void iscsit_thread_reschedule(struct iscsit_conn *conn)
{
/*
* If iscsit_global->allowed_cpumask modified, reschedule iSCSI
}
void iscsit_thread_check_cpumask(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct task_struct *p,
int mode)
{
EXPORT_SYMBOL(iscsit_thread_check_cpumask);
int
-iscsit_immediate_queue(struct iscsi_conn *conn, struct iscsit_cmd *cmd, int state)
+iscsit_immediate_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int state)
{
int ret;
EXPORT_SYMBOL(iscsit_immediate_queue);
static int
-iscsit_handle_immediate_queue(struct iscsi_conn *conn)
+iscsit_handle_immediate_queue(struct iscsit_conn *conn)
{
struct iscsit_transport *t = conn->conn_transport;
struct iscsi_queue_req *qr;
}
int
-iscsit_response_queue(struct iscsi_conn *conn, struct iscsit_cmd *cmd, int state)
+iscsit_response_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int state)
{
int ret;
}
EXPORT_SYMBOL(iscsit_response_queue);
-static int iscsit_handle_response_queue(struct iscsi_conn *conn)
+static int iscsit_handle_response_queue(struct iscsit_conn *conn)
{
struct iscsit_transport *t = conn->conn_transport;
struct iscsi_queue_req *qr;
int iscsi_target_tx_thread(void *arg)
{
int ret = 0;
- struct iscsi_conn *conn = arg;
+ struct iscsit_conn *conn = arg;
bool conn_freed = false;
/*
return 0;
}
-static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)
+static int iscsi_target_rx_opcode(struct iscsit_conn *conn, unsigned char *buf)
{
struct iscsi_hdr *hdr = (struct iscsi_hdr *)buf;
struct iscsit_cmd *cmd;
return iscsit_add_reject(conn, ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
}
-static bool iscsi_target_check_conn_state(struct iscsi_conn *conn)
+static bool iscsi_target_check_conn_state(struct iscsit_conn *conn)
{
bool ret;
return ret;
}
-static void iscsit_get_rx_pdu(struct iscsi_conn *conn)
+static void iscsit_get_rx_pdu(struct iscsit_conn *conn)
{
int ret;
u8 *buffer, opcode;
int iscsi_target_rx_thread(void *arg)
{
int rc;
- struct iscsi_conn *conn = arg;
+ struct iscsit_conn *conn = arg;
bool conn_freed = false;
/*
return 0;
}
-static void iscsit_release_commands_from_conn(struct iscsi_conn *conn)
+static void iscsit_release_commands_from_conn(struct iscsit_conn *conn)
{
LIST_HEAD(tmp_list);
struct iscsit_cmd *cmd = NULL, *cmd_tmp = NULL;
}
static void iscsit_stop_timers_for_cmds(
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsit_cmd *cmd;
}
int iscsit_close_connection(
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
int conn_logout = (conn->conn_state == TARG_CONN_STATE_IN_LOGOUT);
struct iscsi_session *sess = conn->sess;
* However for iser-target, isert_wait4logout() is using conn_logout_comp
* to signal logout response TX interrupt completion. Go ahead and skip
* this for iser since isert_rx_opcode() does not wait on logout failure,
- * and to avoid iscsi_conn pointer dereference in iser-target code.
+ * and to avoid iscsit_conn pointer dereference in iser-target code.
*/
if (!conn->conn_transport->rdma_shutdown)
complete(&conn->conn_logout_comp);
}
static void iscsit_logout_post_handler_closesession(
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
int sleep = 1;
}
static void iscsit_logout_post_handler_samecid(
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
int sleep = 1;
}
static void iscsit_logout_post_handler_diffcid(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u16 cid)
{
- struct iscsi_conn *l_conn;
+ struct iscsit_conn *l_conn;
struct iscsi_session *sess = conn->sess;
bool conn_found = false;
*/
int iscsit_logout_post_handler(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
int ret = 0;
void iscsit_fail_session(struct iscsi_session *sess)
{
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
spin_lock_bh(&sess->conn_lock);
list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
int connection_sleep)
{
u16 conn_count = atomic_read(&sess->nconn);
- struct iscsi_conn *conn, *conn_tmp = NULL;
+ struct iscsit_conn *conn, *conn_tmp = NULL;
int is_last;
spin_lock_bh(&sess->conn_lock);
#include <linux/spinlock.h>
struct iscsit_cmd;
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_np;
struct iscsi_portal_group;
struct iscsi_session;
extern int iscsit_del_np(struct iscsi_np *);
extern int iscsit_reject_cmd(struct iscsit_cmd *cmd, u8, unsigned char *);
extern void iscsit_set_unsolicited_dataout(struct iscsit_cmd *);
-extern int iscsit_logout_closesession(struct iscsit_cmd *, struct iscsi_conn *);
-extern int iscsit_logout_closeconnection(struct iscsit_cmd *, struct iscsi_conn *);
-extern int iscsit_logout_removeconnforrecovery(struct iscsit_cmd *, struct iscsi_conn *);
-extern int iscsit_send_async_msg(struct iscsi_conn *, u16, u8, u8);
-extern int iscsit_build_r2ts_for_cmd(struct iscsi_conn *, struct iscsit_cmd *, bool recovery);
-extern void iscsit_thread_get_cpumask(struct iscsi_conn *);
+extern int iscsit_logout_closesession(struct iscsit_cmd *, struct iscsit_conn *);
+extern int iscsit_logout_closeconnection(struct iscsit_cmd *, struct iscsit_conn *);
+extern int iscsit_logout_removeconnforrecovery(struct iscsit_cmd *, struct iscsit_conn *);
+extern int iscsit_send_async_msg(struct iscsit_conn *, u16, u8, u8);
+extern int iscsit_build_r2ts_for_cmd(struct iscsit_conn *, struct iscsit_cmd *, bool recovery);
+extern void iscsit_thread_get_cpumask(struct iscsit_conn *);
extern int iscsi_target_tx_thread(void *);
extern int iscsi_target_rx_thread(void *);
-extern int iscsit_close_connection(struct iscsi_conn *);
+extern int iscsit_close_connection(struct iscsit_conn *);
extern int iscsit_close_session(struct iscsi_session *, bool can_sleep);
extern void iscsit_fail_session(struct iscsi_session *);
extern void iscsit_stop_session(struct iscsi_session *, int, int);
}
static int chap_gen_challenge(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
int caller,
char *c_str,
unsigned int *c_len)
return r;
}
-static void chap_close(struct iscsi_conn *conn)
+static void chap_close(struct iscsit_conn *conn)
{
kfree(conn->auth_protocol);
conn->auth_protocol = NULL;
}
static struct iscsi_chap *chap_server_open(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_node_auth *auth,
const char *a_str,
char *aic_str,
}
static int chap_server_compute_hash(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_node_auth *auth,
char *nr_in_ptr,
char *nr_out_ptr,
}
u32 chap_main_loop(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_node_auth *auth,
char *in_text,
char *out_text,
#define CHAP_STAGE_SERVER_NR 5
struct iscsi_node_auth;
-struct iscsi_conn;
+struct iscsit_conn;
-extern u32 chap_main_loop(struct iscsi_conn *, struct iscsi_node_auth *, char *, char *,
+extern u32 chap_main_loop(struct iscsit_conn *, struct iscsi_node_auth *, char *, char *,
int *, int *);
struct iscsi_chap {
{
struct se_node_acl *se_nacl = acl_to_nacl(item);
struct iscsi_session *sess;
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
struct se_session *se_sess;
ssize_t rb = 0;
u32 max_cmd_sn;
static int lio_queue_data_in(struct se_cmd *se_cmd)
{
struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
cmd->i_state = ISTATE_SEND_DATAIN;
return conn->conn_transport->iscsit_queue_data_in(conn, cmd);
static int lio_write_pending(struct se_cmd *se_cmd)
{
struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
if (!cmd->immediate_data && !cmd->unsolicited_data)
return conn->conn_transport->iscsit_get_dataout(conn, cmd, false);
static int lio_queue_status(struct se_cmd *se_cmd)
{
struct iscsit_cmd *cmd = container_of(se_cmd, struct iscsit_cmd, se_cmd);
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
cmd->i_state = ISTATE_SEND_STATUS;
struct iscsi_datain *datain)
{
u32 next_burst_len, read_data_done, read_data_left;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_datain_req *dr;
dr = iscsit_get_datain_req(cmd);
struct iscsi_datain *datain)
{
u32 offset, read_data_done, read_data_left, seq_send_order;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_datain_req *dr;
struct iscsi_seq *seq;
struct iscsi_datain *datain)
{
u32 next_burst_len, read_data_done, read_data_left;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_datain_req *dr;
struct iscsi_pdu *pdu;
struct iscsi_datain *datain)
{
u32 read_data_done, read_data_left, seq_send_order;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_datain_req *dr;
struct iscsi_pdu *pdu;
struct iscsi_seq *seq = NULL;
struct iscsit_cmd *cmd,
struct iscsi_datain *datain)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
if (conn->sess->sess_ops->DataSequenceInOrder &&
conn->sess->sess_ops->DataPDUInOrder)
void iscsit_set_dataout_sequence_values(
struct iscsit_cmd *cmd)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
/*
* Still set seq_start_offset and seq_end_offset for Unsolicited
* DataOUT, even if DataSequenceInOrder=No.
struct iscsit_cmd *cmd,
unsigned char *buf)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
unsigned char *buf)
{
u32 first_burst_len;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
unsigned char *buf)
{
u32 next_burst_len;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_seq *seq = NULL;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
unsigned char *buf)
{
u32 data_sn = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
unsigned char *buf)
{
int dump = 0, recovery = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
unsigned char *buf)
{
int ret, send_r2t = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_seq *seq = NULL;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
struct iscsit_cmd *cmd,
unsigned char *buf)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_pdu *pdu;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
unsigned char *buf)
{
int ret;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
ret = iscsit_dataout_within_command_recovery_check(cmd, buf);
if ((ret == DATAOUT_WITHIN_COMMAND_RECOVERY) ||
unsigned char *buf,
u8 data_crc_failed)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
cmd->dataout_timeout_retries = 0;
return 0;
}
-void iscsit_connection_reinstatement_rcfr(struct iscsi_conn *conn)
+void iscsit_connection_reinstatement_rcfr(struct iscsit_conn *conn)
{
spin_lock_bh(&conn->state_lock);
if (atomic_read(&conn->connection_exit)) {
complete(&conn->conn_post_wait_comp);
}
-void iscsit_cause_connection_reinstatement(struct iscsi_conn *conn, int sleep)
+void iscsit_cause_connection_reinstatement(struct iscsit_conn *conn, int sleep)
{
spin_lock_bh(&conn->state_lock);
if (atomic_read(&conn->connection_exit)) {
atomic_set(&sess->session_fall_back_to_erl0, 1);
}
-static void iscsit_handle_connection_cleanup(struct iscsi_conn *conn)
+static void iscsit_handle_connection_cleanup(struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
}
}
-void iscsit_take_action_for_connection_exit(struct iscsi_conn *conn, bool *conn_freed)
+void iscsit_take_action_for_connection_exit(struct iscsit_conn *conn, bool *conn_freed)
{
*conn_freed = false;
#include <linux/types.h>
struct iscsit_cmd;
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_session;
extern void iscsit_set_dataout_sequence_values(struct iscsit_cmd *);
extern void iscsit_start_time2retain_handler(struct iscsi_session *);
extern void iscsit_handle_time2retain_timeout(struct timer_list *t);
extern int iscsit_stop_time2retain_timer(struct iscsi_session *);
-extern void iscsit_connection_reinstatement_rcfr(struct iscsi_conn *);
-extern void iscsit_cause_connection_reinstatement(struct iscsi_conn *, int);
+extern void iscsit_connection_reinstatement_rcfr(struct iscsit_conn *);
+extern void iscsit_cause_connection_reinstatement(struct iscsit_conn *, int);
extern void iscsit_fall_back_to_erl0(struct iscsi_session *);
-extern void iscsit_take_action_for_connection_exit(struct iscsi_conn *, bool *);
+extern void iscsit_take_action_for_connection_exit(struct iscsit_conn *, bool *);
#endif /*** ISCSI_TARGET_ERL0_H ***/
* to be dumped.
*/
int iscsit_dump_data_payload(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u32 buf_len,
int dump_padding_digest)
{
u32 data_sn = 0, data_sn_count = 0;
u32 pdu_start = 0, seq_no = 0;
u32 begrun = dr->begrun;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
while (begrun > data_sn++) {
data_sn_count++;
u32 data_sn, read_data_done = 0, seq_send_order = 0;
u32 begrun = dr->begrun;
u32 runlength = dr->runlength;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_seq *first_seq = NULL, *seq = NULL;
if (!cmd->seq_list) {
u32 begrun,
u32 runlength)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_datain_req *dr;
struct se_cmd *se_cmd = &cmd->se_cmd;
}
int iscsit_handle_recovery_datain_or_r2t(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
unsigned char *buf,
itt_t init_task_tag,
u32 targ_xfer_tag,
/* #warning FIXME: Status SNACK needs to be dependent on OPCODE!!! */
int iscsit_handle_status_snack(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
itt_t init_task_tag,
u32 targ_xfer_tag,
u32 begrun,
}
int iscsit_handle_data_ack(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u32 targ_xfer_tag,
u32 begrun,
u32 runlength)
{
int i, send_recovery_r2t = 0, recovery = 0;
u32 length = 0, offset = 0, pdu_count = 0, xfer_len = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_pdu *first_pdu = NULL;
/*
u32 *r2t_length)
{
int i;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_pdu *pdu = NULL;
if (conn->sess->sess_ops->DataSequenceInOrder) {
kmem_cache_free(lio_ooo_cache, ooo_cmdsn);
}
-void iscsit_clear_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
+void iscsit_clear_ooo_cmdsns_for_conn(struct iscsit_conn *conn)
{
struct iscsi_ooo_cmdsn *ooo_cmdsn;
struct iscsi_session *sess = conn->sess;
int iscsit_execute_cmd(struct iscsit_cmd *cmd, int ooo)
{
struct se_cmd *se_cmd = &cmd->se_cmd;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
int lr = 0;
spin_lock_bh(&cmd->istate_lock);
u32 *offset,
u32 *length)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_r2t *r2t;
if (cmd->unsolicited_data) {
u32 pdu_length = 0, pdu_offset = 0;
u32 r2t_length = 0, r2t_offset = 0;
struct iscsit_cmd *cmd = from_timer(cmd, t, dataout_timer);
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_session *sess = NULL;
struct iscsi_node_attrib *na;
void iscsit_mod_dataout_timer(struct iscsit_cmd *cmd)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_session *sess = conn->sess;
struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
void iscsit_start_dataout_timer(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
#include <scsi/iscsi_proto.h> /* itt_t */
struct iscsit_cmd;
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_datain_req;
struct iscsi_ooo_cmdsn;
struct iscsi_pdu;
struct iscsi_session;
-extern int iscsit_dump_data_payload(struct iscsi_conn *, u32, int);
+extern int iscsit_dump_data_payload(struct iscsit_conn *, u32, int);
extern int iscsit_create_recovery_datain_values_datasequenceinorder_yes(
struct iscsit_cmd *, struct iscsi_datain_req *);
extern int iscsit_create_recovery_datain_values_datasequenceinorder_no(
struct iscsit_cmd *, struct iscsi_datain_req *);
-extern int iscsit_handle_recovery_datain_or_r2t(struct iscsi_conn *, unsigned char *,
+extern int iscsit_handle_recovery_datain_or_r2t(struct iscsit_conn *, unsigned char *,
itt_t, u32, u32, u32);
-extern int iscsit_handle_status_snack(struct iscsi_conn *, itt_t, u32,
+extern int iscsit_handle_status_snack(struct iscsit_conn *, itt_t, u32,
u32, u32);
-extern int iscsit_handle_data_ack(struct iscsi_conn *, u32, u32, u32);
+extern int iscsit_handle_data_ack(struct iscsit_conn *, u32, u32, u32);
extern int iscsit_dataout_datapduinorder_no_fbit(struct iscsit_cmd *, struct iscsi_pdu *);
extern int iscsit_recover_dataout_sequence(struct iscsit_cmd *, u32, u32);
-extern void iscsit_clear_ooo_cmdsns_for_conn(struct iscsi_conn *);
+extern void iscsit_clear_ooo_cmdsns_for_conn(struct iscsit_conn *);
extern void iscsit_free_all_ooo_cmdsns(struct iscsi_session *);
extern int iscsit_execute_ooo_cmdsns(struct iscsi_session *);
extern int iscsit_execute_cmd(struct iscsit_cmd *, int);
extern void iscsit_remove_ooo_cmdsn(struct iscsi_session *, struct iscsi_ooo_cmdsn *);
extern void iscsit_handle_dataout_timeout(struct timer_list *t);
extern void iscsit_mod_dataout_timer(struct iscsit_cmd *);
-extern void iscsit_start_dataout_timer(struct iscsit_cmd *, struct iscsi_conn *);
+extern void iscsit_start_dataout_timer(struct iscsit_cmd *, struct iscsit_conn *);
extern void iscsit_stop_dataout_timer(struct iscsit_cmd *);
#endif /* ISCSI_TARGET_ERL1_H */
__be32 exp_data_sn)
{
u32 data_sn = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
cmd->next_burst_len = 0;
cmd->read_data_done = 0;
struct iscsit_cmd *cmd)
{
u32 write_data_done = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
cmd->data_sn = 0;
cmd->next_burst_len = 0;
}
}
-int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
+int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsit_conn *conn)
{
u32 dropped_count = 0;
struct iscsit_cmd *cmd, *cmd_tmp;
return 0;
}
-int iscsit_prepare_cmds_for_reallegiance(struct iscsi_conn *conn)
+int iscsit_prepare_cmds_for_reallegiance(struct iscsit_conn *conn)
{
u32 cmd_count = 0;
struct iscsit_cmd *cmd, *cmd_tmp;
return 0;
}
-int iscsit_connection_recovery_transport_reset(struct iscsi_conn *conn)
+int iscsit_connection_recovery_transport_reset(struct iscsit_conn *conn)
{
atomic_set(&conn->connection_recovery, 1);
#include <linux/types.h>
struct iscsit_cmd;
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_conn_recovery;
struct iscsi_session;
extern int iscsit_remove_cmd_from_connection_recovery(struct iscsit_cmd *,
struct iscsi_session *);
extern void iscsit_discard_cr_cmds_by_expstatsn(struct iscsi_conn_recovery *, u32);
-extern int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *);
-extern int iscsit_prepare_cmds_for_reallegiance(struct iscsi_conn *);
-extern int iscsit_connection_recovery_transport_reset(struct iscsi_conn *);
+extern int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsit_conn *);
+extern int iscsit_prepare_cmds_for_reallegiance(struct iscsit_conn *);
+extern int iscsit_connection_recovery_transport_reset(struct iscsit_conn *);
#endif /*** ISCSI_TARGET_ERL2_H ***/
#include <target/iscsi/iscsi_transport.h>
-static struct iscsi_login *iscsi_login_init_conn(struct iscsi_conn *conn)
+static struct iscsi_login *iscsi_login_init_conn(struct iscsit_conn *conn)
{
struct iscsi_login *login;
/*
* Used by iscsi_target_nego.c:iscsi_target_locate_portal() to setup
- * per struct iscsi_conn libcrypto contexts for crc32c and crc32-intel
+ * per struct iscsit_conn libcrypto contexts for crc32c and crc32-intel
*/
-int iscsi_login_setup_crypto(struct iscsi_conn *conn)
+int iscsi_login_setup_crypto(struct iscsit_conn *conn)
{
struct crypto_ahash *tfm;
}
static int iscsi_login_check_initiator_version(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u8 version_max,
u8 version_min)
{
return 0;
}
-int iscsi_check_for_session_reinstatement(struct iscsi_conn *conn)
+int iscsi_check_for_session_reinstatement(struct iscsit_conn *conn)
{
int sessiontype;
struct iscsi_param *initiatorname_param = NULL, *sessiontype_param = NULL;
static int iscsi_login_set_conn_values(
struct iscsi_session *sess,
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
__be16 cid)
{
int ret;
}
__printf(2, 3) int iscsi_change_param_sprintf(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
const char *fmt, ...)
{
va_list args;
* or session reinstatement.
*/
static int iscsi_login_zero_tsih_s1(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
unsigned char *buf)
{
struct iscsi_session *sess = NULL;
}
static int iscsi_login_zero_tsih_s2(
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_node_attrib *na;
struct iscsi_session *sess = conn->sess;
}
static int iscsi_login_non_zero_tsih_s1(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
unsigned char *buf)
{
struct iscsi_login_req *pdu = (struct iscsi_login_req *)buf;
* Add a new connection to an existing session.
*/
static int iscsi_login_non_zero_tsih_s2(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
unsigned char *buf)
{
struct iscsi_portal_group *tpg = conn->tpg;
}
int iscsi_login_post_auth_non_zero_tsih(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u16 cid,
u32 exp_statsn)
{
- struct iscsi_conn *conn_ptr = NULL;
+ struct iscsit_conn *conn_ptr = NULL;
struct iscsi_conn_recovery *cr = NULL;
struct iscsi_session *sess = conn->sess;
return 0;
}
-static void iscsi_post_login_start_timers(struct iscsi_conn *conn)
+static void iscsi_post_login_start_timers(struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
/*
iscsit_start_nopin_timer(conn);
}
-int iscsit_start_kthreads(struct iscsi_conn *conn)
+int iscsit_start_kthreads(struct iscsit_conn *conn)
{
int ret = 0;
void iscsi_post_login_handler(
struct iscsi_np *np,
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u8 zero_tsih)
{
int stop_timer = 0;
conn->conn_tx_reset_cpumask = 1;
/*
* Wakeup the sleeping iscsi_target_rx_thread() now that
- * iscsi_conn is in TARG_CONN_STATE_LOGGED_IN state.
+ * iscsit_conn is in TARG_CONN_STATE_LOGGED_IN state.
*/
complete(&conn->rx_login_comp);
iscsit_dec_conn_usage_count(conn);
conn->conn_tx_reset_cpumask = 1;
/*
* Wakeup the sleeping iscsi_target_rx_thread() now that
- * iscsi_conn is in TARG_CONN_STATE_LOGGED_IN state.
+ * iscsit_conn is in TARG_CONN_STATE_LOGGED_IN state.
*/
complete(&conn->rx_login_comp);
iscsit_dec_conn_usage_count(conn);
return 0;
}
-int iscsit_accept_np(struct iscsi_np *np, struct iscsi_conn *conn)
+int iscsit_accept_np(struct iscsi_np *np, struct iscsit_conn *conn)
{
struct socket *new_sock, *sock = np->np_socket;
struct sockaddr_in sock_in;
return 0;
}
-int iscsit_get_login_rx(struct iscsi_conn *conn, struct iscsi_login *login)
+int iscsit_get_login_rx(struct iscsit_conn *conn, struct iscsi_login *login)
{
struct iscsi_login_req *login_req;
u32 padding = 0, payload_length;
return 0;
}
-int iscsit_put_login_tx(struct iscsi_conn *conn, struct iscsi_login *login,
+int iscsit_put_login_tx(struct iscsit_conn *conn, struct iscsi_login *login,
u32 length)
{
if (iscsi_login_tx_data(conn, login->rsp, login->rsp_buf, length) < 0)
}
static int
-iscsit_conn_set_transport(struct iscsi_conn *conn, struct iscsit_transport *t)
+iscsit_conn_set_transport(struct iscsit_conn *conn, struct iscsit_transport *t)
{
int rc;
return 0;
}
-static struct iscsi_conn *iscsit_alloc_conn(struct iscsi_np *np)
+static struct iscsit_conn *iscsit_alloc_conn(struct iscsi_np *np)
{
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
- conn = kzalloc(sizeof(struct iscsi_conn), GFP_KERNEL);
+ conn = kzalloc(sizeof(struct iscsit_conn), GFP_KERNEL);
if (!conn) {
pr_err("Could not allocate memory for new connection\n");
return NULL;
return NULL;
}
-void iscsit_free_conn(struct iscsi_conn *conn)
+void iscsit_free_conn(struct iscsit_conn *conn)
{
free_cpumask_var(conn->allowed_cpumask);
free_cpumask_var(conn->conn_cpumask);
kfree(conn);
}
-void iscsi_target_login_sess_out(struct iscsi_conn *conn,
+void iscsi_target_login_sess_out(struct iscsit_conn *conn,
bool zero_tsih, bool new_sess)
{
if (!new_sess)
{
u8 *buffer, zero_tsih = 0;
int ret = 0, rc;
- struct iscsi_conn *conn = NULL;
+ struct iscsit_conn *conn = NULL;
struct iscsi_login *login;
struct iscsi_portal_group *tpg = NULL;
struct iscsi_login_req *pdu;
tpg = conn->tpg;
if (!tpg) {
- pr_err("Unable to locate struct iscsi_conn->tpg\n");
+ pr_err("Unable to locate struct iscsit_conn->tpg\n");
goto new_sess_out;
}
#include <linux/types.h>
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_login;
struct iscsi_np;
struct sockaddr_storage;
-extern int iscsi_login_setup_crypto(struct iscsi_conn *);
-extern int iscsi_check_for_session_reinstatement(struct iscsi_conn *);
-extern int iscsi_login_post_auth_non_zero_tsih(struct iscsi_conn *, u16, u32);
+extern int iscsi_login_setup_crypto(struct iscsit_conn *);
+extern int iscsi_check_for_session_reinstatement(struct iscsit_conn *);
+extern int iscsi_login_post_auth_non_zero_tsih(struct iscsit_conn *, u16, u32);
extern int iscsit_setup_np(struct iscsi_np *,
struct sockaddr_storage *);
extern int iscsi_target_setup_login_socket(struct iscsi_np *,
struct sockaddr_storage *);
-extern int iscsit_accept_np(struct iscsi_np *, struct iscsi_conn *);
-extern int iscsit_get_login_rx(struct iscsi_conn *, struct iscsi_login *);
-extern int iscsit_put_login_tx(struct iscsi_conn *, struct iscsi_login *, u32);
-extern void iscsit_free_conn(struct iscsi_conn *);
-extern int iscsit_start_kthreads(struct iscsi_conn *);
-extern void iscsi_post_login_handler(struct iscsi_np *, struct iscsi_conn *, u8);
-extern void iscsi_target_login_sess_out(struct iscsi_conn *, bool, bool);
+extern int iscsit_accept_np(struct iscsi_np *, struct iscsit_conn *);
+extern int iscsit_get_login_rx(struct iscsit_conn *, struct iscsi_login *);
+extern int iscsit_put_login_tx(struct iscsit_conn *, struct iscsi_login *, u32);
+extern void iscsit_free_conn(struct iscsit_conn *);
+extern int iscsit_start_kthreads(struct iscsit_conn *);
+extern void iscsi_post_login_handler(struct iscsi_np *, struct iscsit_conn *, u8);
+extern void iscsi_target_login_sess_out(struct iscsit_conn *, bool, bool);
extern int iscsi_target_login_thread(void *);
extern void iscsi_handle_login_thread_timeout(struct timer_list *t);
}
static u32 iscsi_handle_authentication(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
char *in_buf,
char *out_buf,
int in_length,
return 2;
}
-static void iscsi_remove_failed_auth_entry(struct iscsi_conn *conn)
+static void iscsi_remove_failed_auth_entry(struct iscsit_conn *conn)
{
kfree(conn->auth_protocol);
}
int iscsi_target_check_login_request(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_login *login)
{
int req_csg, req_nsg;
EXPORT_SYMBOL(iscsi_target_check_login_request);
static int iscsi_target_check_first_request(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_login *login)
{
struct iscsi_param *param = NULL;
return 0;
}
-static int iscsi_target_do_tx_login_io(struct iscsi_conn *conn, struct iscsi_login *login)
+static int iscsi_target_do_tx_login_io(struct iscsit_conn *conn, struct iscsi_login *login)
{
u32 padding = 0;
struct iscsi_login_rsp *login_rsp;
static void iscsi_target_sk_data_ready(struct sock *sk)
{
- struct iscsi_conn *conn = sk->sk_user_data;
+ struct iscsit_conn *conn = sk->sk_user_data;
bool rc;
pr_debug("Entering iscsi_target_sk_data_ready: conn: %p\n", conn);
static void iscsi_target_sk_state_change(struct sock *);
-static void iscsi_target_set_sock_callbacks(struct iscsi_conn *conn)
+static void iscsi_target_set_sock_callbacks(struct iscsit_conn *conn)
{
struct sock *sk;
sk->sk_rcvtimeo = TA_LOGIN_TIMEOUT * HZ;
}
-static void iscsi_target_restore_sock_callbacks(struct iscsi_conn *conn)
+static void iscsi_target_restore_sock_callbacks(struct iscsit_conn *conn)
{
struct sock *sk;
sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
}
-static int iscsi_target_do_login(struct iscsi_conn *, struct iscsi_login *);
+static int iscsi_target_do_login(struct iscsit_conn *, struct iscsi_login *);
static bool __iscsi_target_sk_check_close(struct sock *sk)
{
return false;
}
-static bool iscsi_target_sk_check_close(struct iscsi_conn *conn)
+static bool iscsi_target_sk_check_close(struct iscsit_conn *conn)
{
bool state = false;
return state;
}
-static bool iscsi_target_sk_check_flag(struct iscsi_conn *conn, unsigned int flag)
+static bool iscsi_target_sk_check_flag(struct iscsit_conn *conn, unsigned int flag)
{
bool state = false;
return state;
}
-static bool iscsi_target_sk_check_and_clear(struct iscsi_conn *conn, unsigned int flag)
+static bool iscsi_target_sk_check_and_clear(struct iscsit_conn *conn, unsigned int flag)
{
bool state = false;
return state;
}
-static void iscsi_target_login_drop(struct iscsi_conn *conn, struct iscsi_login *login)
+static void iscsi_target_login_drop(struct iscsit_conn *conn, struct iscsi_login *login)
{
bool zero_tsih = login->zero_tsih;
struct conn_timeout {
struct timer_list timer;
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
};
static void iscsi_target_login_timeout(struct timer_list *t)
{
struct conn_timeout *timeout = from_timer(timeout, t, timer);
- struct iscsi_conn *conn = timeout->conn;
+ struct iscsit_conn *conn = timeout->conn;
pr_debug("Entering iscsi_target_login_timeout >>>>>>>>>>>>>>>>>>>\n");
static void iscsi_target_do_login_rx(struct work_struct *work)
{
- struct iscsi_conn *conn = container_of(work,
- struct iscsi_conn, login_work.work);
+ struct iscsit_conn *conn = container_of(work,
+ struct iscsit_conn, login_work.work);
struct iscsi_login *login = conn->login;
struct iscsi_np *np = login->np;
struct iscsi_portal_group *tpg = conn->tpg;
static void iscsi_target_sk_state_change(struct sock *sk)
{
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
void (*orig_state_change)(struct sock *);
bool state;
* ISID/TSIH combinations.
*/
static int iscsi_target_check_for_existing_instances(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_login *login)
{
if (login->checked_for_existing)
}
static int iscsi_target_do_authentication(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_login *login)
{
int authret;
}
static int iscsi_target_handle_csg_zero(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_login *login)
{
int ret;
return iscsi_target_do_authentication(conn, login);
}
-static int iscsi_target_handle_csg_one(struct iscsi_conn *conn, struct iscsi_login *login)
+static int iscsi_target_handle_csg_one(struct iscsit_conn *conn, struct iscsi_login *login)
{
int ret;
u32 payload_length;
return 0;
}
-static int iscsi_target_do_login(struct iscsi_conn *conn, struct iscsi_login *login)
+static int iscsi_target_do_login(struct iscsit_conn *conn, struct iscsi_login *login)
{
int pdu_count = 0;
struct iscsi_login_req *login_req;
*/
int iscsi_target_locate_portal(
struct iscsi_np *np,
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_login *login)
{
char *i_buf = NULL, *s_buf = NULL, *t_buf = NULL;
int iscsi_target_start_negotiation(
struct iscsi_login *login,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
int ret;
return ret;
}
-void iscsi_target_nego_release(struct iscsi_conn *conn)
+void iscsi_target_nego_release(struct iscsit_conn *conn)
{
struct iscsi_login *login = conn->conn_login;
#define DECIMAL 0
#define HEX 1
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_login;
struct iscsi_np;
extern void convert_null_to_semi(char *, int);
extern int extract_param(const char *, const char *, unsigned int, char *,
unsigned char *);
-extern int iscsi_target_check_login_request(struct iscsi_conn *,
+extern int iscsi_target_check_login_request(struct iscsit_conn *,
struct iscsi_login *);
-extern int iscsi_target_get_initial_payload(struct iscsi_conn *,
+extern int iscsi_target_get_initial_payload(struct iscsit_conn *,
struct iscsi_login *);
-extern int iscsi_target_locate_portal(struct iscsi_np *, struct iscsi_conn *,
+extern int iscsi_target_locate_portal(struct iscsi_np *, struct iscsit_conn *,
struct iscsi_login *);
extern int iscsi_target_start_negotiation(
- struct iscsi_login *, struct iscsi_conn *);
-extern void iscsi_target_nego_release(struct iscsi_conn *);
+ struct iscsi_login *, struct iscsit_conn *);
+extern void iscsi_target_nego_release(struct iscsit_conn *);
#endif /* ISCSI_TARGET_NEGO_H */
{
struct iscsi_node_attrib *a = &acl->node_attrib;
struct iscsi_session *sess;
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
struct se_node_acl *se_nacl = &a->nacl->se_node_acl;
struct se_session *se_sess;
u32 orig_nopin_timeout = a->nopin_timeout;
#include "iscsi_target_parameters.h"
int iscsi_login_rx_data(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
char *buf,
int length)
{
}
int iscsi_login_tx_data(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
char *pdu_buf,
char *text_buf,
int text_length)
}
static int iscsi_check_acceptor_state(struct iscsi_param *param, char *value,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
u8 acceptor_boolean_value = 0, proposer_boolean_value = 0;
char *negotiated_value = NULL;
u8 sender,
char *textbuf,
u32 length,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_param_list *param_list = conn->param_list;
char *tmpbuf, *start = NULL, *end = NULL;
struct list_head p_list;
} ____cacheline_aligned;
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_conn_ops;
struct iscsi_param_list;
struct iscsi_sess_ops;
-extern int iscsi_login_rx_data(struct iscsi_conn *, char *, int);
-extern int iscsi_login_tx_data(struct iscsi_conn *, char *, char *, int);
+extern int iscsi_login_rx_data(struct iscsit_conn *, char *, int);
+extern int iscsi_login_tx_data(struct iscsit_conn *, char *, char *, int);
extern void iscsi_dump_conn_ops(struct iscsi_conn_ops *);
extern void iscsi_dump_sess_ops(struct iscsi_sess_ops *);
extern void iscsi_print_params(struct iscsi_param_list *);
extern struct iscsi_param *iscsi_find_param_from_key(char *, struct iscsi_param_list *);
extern int iscsi_extract_key_value(char *, char **, char **);
extern int iscsi_update_param_value(struct iscsi_param *, char *);
-extern int iscsi_decode_text_input(u8, u8, char *, u32, struct iscsi_conn *);
+extern int iscsi_decode_text_input(u8, u8, char *, u32, struct iscsit_conn *);
extern int iscsi_encode_text_output(u8, u8, char *, u32 *,
struct iscsi_param_list *, bool);
extern int iscsi_check_negotiated_keys(struct iscsi_param_list *);
u32 burstlength = 0, offset = 0;
u32 unsolicited_data_length = 0;
u32 mdsl;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
if (cmd->se_cmd.data_direction == DMA_TO_DEVICE)
mdsl = cmd->conn->conn_ops->MaxXmitDataSegmentLength;
int check_immediate = 0, datapduinorder, datasequenceinorder;
u32 burstlength = 0, offset = 0, i = 0, mdsl;
u32 pdu_count = 0, seq_no = 0, unsolicited_data_length = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_pdu *pdu = cmd->pdu_list;
struct iscsi_seq *seq = cmd->seq_list;
{
struct iscsi_build_list bl;
u32 pdu_count = 0, seq_count = 1;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_pdu *pdu = NULL;
struct iscsi_seq *seq = NULL;
struct iscsi_seq *seq)
{
u32 i;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_pdu *pdu = NULL;
if (!cmd->pdu_list) {
unsigned char *buf)
{
struct iscsit_cmd *ref_cmd;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
* Called from iscsit_handle_task_mgt_cmd().
*/
int iscsit_tmr_task_warm_reset(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_tmr_req *tmr_req,
unsigned char *buf)
{
}
int iscsit_tmr_task_cold_reset(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct iscsi_tmr_req *tmr_req,
unsigned char *buf)
{
unsigned char *buf)
{
struct iscsit_cmd *ref_cmd = NULL;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_conn_recovery *cr = NULL;
struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
static int iscsit_task_reassign_complete_nop_out(
struct iscsi_tmr_req *tmr_req,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsit_cmd *cmd = tmr_req->ref_cmd;
struct iscsi_conn_recovery *cr;
{
int no_build_r2ts = 0;
u32 length = 0, offset = 0;
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct se_cmd *se_cmd = &cmd->se_cmd;
/*
* The Initiator must not send a R2T SNACK with a Begrun less than
struct iscsit_cmd *cmd,
struct iscsi_tmr_req *tmr_req)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct iscsi_datain_req *dr;
struct se_cmd *se_cmd = &cmd->se_cmd;
/*
struct iscsit_cmd *cmd,
struct iscsi_tmr_req *tmr_req)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
cmd->i_state = ISTATE_SEND_STATUS;
iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
static int iscsit_task_reassign_complete_scsi_cmnd(
struct iscsi_tmr_req *tmr_req,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsit_cmd *cmd = tmr_req->ref_cmd;
struct iscsi_conn_recovery *cr;
static int iscsit_task_reassign_complete(
struct iscsi_tmr_req *tmr_req,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsit_cmd *cmd;
int ret = 0;
* Right now the only one that its really needed for is
* connection recovery releated TASK_REASSIGN.
*/
-int iscsit_tmr_post_handler(struct iscsit_cmd *cmd, struct iscsi_conn *conn)
+int iscsit_tmr_post_handler(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
{
struct iscsi_tmr_req *tmr_req = cmd->tmr_req;
struct se_tmr_req *se_tmr = cmd->se_cmd.se_tmr_req;
*/
static int iscsit_task_reassign_prepare_read(
struct iscsi_tmr_req *tmr_req,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
return 0;
}
static void iscsit_task_reassign_prepare_unsolicited_dataout(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
int i, j;
struct iscsi_pdu *pdu = NULL;
static int iscsit_task_reassign_prepare_write(
struct iscsi_tmr_req *tmr_req,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsit_cmd *cmd = tmr_req->ref_cmd;
struct iscsi_pdu *pdu = NULL;
*/
int iscsit_check_task_reassign_expdatasn(
struct iscsi_tmr_req *tmr_req,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsit_cmd *ref_cmd = tmr_req->ref_cmd;
#include <linux/types.h>
struct iscsit_cmd;
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_tmr_req;
extern u8 iscsit_tmr_abort_task(struct iscsit_cmd *, unsigned char *);
-extern int iscsit_tmr_task_warm_reset(struct iscsi_conn *, struct iscsi_tmr_req *,
+extern int iscsit_tmr_task_warm_reset(struct iscsit_conn *, struct iscsi_tmr_req *,
unsigned char *);
-extern int iscsit_tmr_task_cold_reset(struct iscsi_conn *, struct iscsi_tmr_req *,
+extern int iscsit_tmr_task_cold_reset(struct iscsit_conn *, struct iscsi_tmr_req *,
unsigned char *);
extern u8 iscsit_tmr_task_reassign(struct iscsit_cmd *, unsigned char *);
-extern int iscsit_tmr_post_handler(struct iscsit_cmd *, struct iscsi_conn *);
+extern int iscsit_tmr_post_handler(struct iscsit_cmd *, struct iscsit_conn *);
extern int iscsit_check_task_reassign_expdatasn(struct iscsi_tmr_req *,
- struct iscsi_conn *);
+ struct iscsit_conn *);
#endif /* ISCSI_TARGET_TMR_H */
* May be called from software interrupt (timer) context for allocating
* iSCSI NopINs.
*/
-struct iscsit_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, int state)
+struct iscsit_cmd *iscsit_allocate_cmd(struct iscsit_conn *conn, int state)
{
struct iscsit_cmd *cmd;
struct se_session *se_sess = conn->sess->se_sess;
* Commands may be received out of order if MC/S is in use.
* Ensure they are executed in CmdSN order.
*/
-int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+int iscsit_sequence_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char *buf, __be32 cmdsn)
{
int ret, cmdsn_ret;
int iscsit_check_unsolicited_dataout(struct iscsit_cmd *cmd, unsigned char *buf)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
struct se_cmd *se_cmd = &cmd->se_cmd;
struct iscsi_data *hdr = (struct iscsi_data *) buf;
u32 payload_length = ntoh24(hdr->dlength);
}
struct iscsit_cmd *iscsit_find_cmd_from_itt(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
itt_t init_task_tag)
{
struct iscsit_cmd *cmd;
EXPORT_SYMBOL(iscsit_find_cmd_from_itt);
struct iscsit_cmd *iscsit_find_cmd_from_itt_or_dump(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
itt_t init_task_tag,
u32 length)
{
EXPORT_SYMBOL(iscsit_find_cmd_from_itt_or_dump);
struct iscsit_cmd *iscsit_find_cmd_from_ttt(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u32 targ_xfer_tag)
{
struct iscsit_cmd *cmd = NULL;
void iscsit_add_cmd_to_immediate_queue(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u8 state)
{
struct iscsi_queue_req *qr;
}
EXPORT_SYMBOL(iscsit_add_cmd_to_immediate_queue);
-struct iscsi_queue_req *iscsit_get_cmd_from_immediate_queue(struct iscsi_conn *conn)
+struct iscsi_queue_req *iscsit_get_cmd_from_immediate_queue(struct iscsit_conn *conn)
{
struct iscsi_queue_req *qr;
static void iscsit_remove_cmd_from_immediate_queue(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_queue_req *qr, *qr_tmp;
int iscsit_add_cmd_to_response_queue(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u8 state)
{
struct iscsi_queue_req *qr;
return 0;
}
-struct iscsi_queue_req *iscsit_get_cmd_from_response_queue(struct iscsi_conn *conn)
+struct iscsi_queue_req *iscsit_get_cmd_from_response_queue(struct iscsit_conn *conn)
{
struct iscsi_queue_req *qr;
static void iscsit_remove_cmd_from_response_queue(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct iscsi_queue_req *qr, *qr_tmp;
}
}
-bool iscsit_conn_all_queues_empty(struct iscsi_conn *conn)
+bool iscsit_conn_all_queues_empty(struct iscsit_conn *conn)
{
bool empty;
return empty;
}
-void iscsit_free_queue_reqs_for_conn(struct iscsi_conn *conn)
+void iscsit_free_queue_reqs_for_conn(struct iscsit_conn *conn)
{
struct iscsi_queue_req *qr, *qr_tmp;
void __iscsit_free_cmd(struct iscsit_cmd *cmd, bool check_queues)
{
- struct iscsi_conn *conn = cmd->conn;
+ struct iscsit_conn *conn = cmd->conn;
WARN_ON(!list_empty(&cmd->i_conn_node));
spin_unlock_bh(&sess->session_usage_lock);
}
-struct iscsi_conn *iscsit_get_conn_from_cid(struct iscsi_session *sess, u16 cid)
+struct iscsit_conn *iscsit_get_conn_from_cid(struct iscsi_session *sess, u16 cid)
{
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
spin_lock_bh(&sess->conn_lock);
list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
return NULL;
}
-struct iscsi_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *sess, u16 cid)
+struct iscsit_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *sess, u16 cid)
{
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
spin_lock_bh(&sess->conn_lock);
list_for_each_entry(conn, &sess->sess_conn_list, conn_list) {
return NULL;
}
-void iscsit_check_conn_usage_count(struct iscsi_conn *conn)
+void iscsit_check_conn_usage_count(struct iscsit_conn *conn)
{
spin_lock_bh(&conn->conn_usage_lock);
if (conn->conn_usage_count != 0) {
spin_unlock_bh(&conn->conn_usage_lock);
}
-void iscsit_dec_conn_usage_count(struct iscsi_conn *conn)
+void iscsit_dec_conn_usage_count(struct iscsit_conn *conn)
{
spin_lock_bh(&conn->conn_usage_lock);
conn->conn_usage_count--;
spin_unlock_bh(&conn->conn_usage_lock);
}
-void iscsit_inc_conn_usage_count(struct iscsi_conn *conn)
+void iscsit_inc_conn_usage_count(struct iscsit_conn *conn)
{
spin_lock_bh(&conn->conn_usage_lock);
conn->conn_usage_count++;
spin_unlock_bh(&conn->conn_usage_lock);
}
-static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response)
+static int iscsit_add_nopin(struct iscsit_conn *conn, int want_response)
{
u8 state;
struct iscsit_cmd *cmd;
void iscsit_handle_nopin_response_timeout(struct timer_list *t)
{
- struct iscsi_conn *conn = from_timer(conn, t, nopin_response_timer);
+ struct iscsit_conn *conn = from_timer(conn, t, nopin_response_timer);
struct iscsi_session *sess = conn->sess;
iscsit_inc_conn_usage_count(conn);
iscsit_dec_conn_usage_count(conn);
}
-void iscsit_mod_nopin_response_timer(struct iscsi_conn *conn)
+void iscsit_mod_nopin_response_timer(struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
spin_unlock_bh(&conn->nopin_timer_lock);
}
-void iscsit_start_nopin_response_timer(struct iscsi_conn *conn)
+void iscsit_start_nopin_response_timer(struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
spin_unlock_bh(&conn->nopin_timer_lock);
}
-void iscsit_stop_nopin_response_timer(struct iscsi_conn *conn)
+void iscsit_stop_nopin_response_timer(struct iscsit_conn *conn)
{
spin_lock_bh(&conn->nopin_timer_lock);
if (!(conn->nopin_response_timer_flags & ISCSI_TF_RUNNING)) {
void iscsit_handle_nopin_timeout(struct timer_list *t)
{
- struct iscsi_conn *conn = from_timer(conn, t, nopin_timer);
+ struct iscsit_conn *conn = from_timer(conn, t, nopin_timer);
iscsit_inc_conn_usage_count(conn);
iscsit_dec_conn_usage_count(conn);
}
-void __iscsit_start_nopin_timer(struct iscsi_conn *conn)
+void __iscsit_start_nopin_timer(struct iscsit_conn *conn)
{
struct iscsi_session *sess = conn->sess;
struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
" interval\n", conn->cid, na->nopin_timeout);
}
-void iscsit_start_nopin_timer(struct iscsi_conn *conn)
+void iscsit_start_nopin_timer(struct iscsit_conn *conn)
{
spin_lock_bh(&conn->nopin_timer_lock);
__iscsit_start_nopin_timer(conn);
spin_unlock_bh(&conn->nopin_timer_lock);
}
-void iscsit_stop_nopin_timer(struct iscsi_conn *conn)
+void iscsit_stop_nopin_timer(struct iscsit_conn *conn)
{
spin_lock_bh(&conn->nopin_timer_lock);
if (!(conn->nopin_timer_flags & ISCSI_TF_RUNNING)) {
int iscsit_send_tx_data(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
int use_misc)
{
int tx_sent, tx_size;
int iscsit_fe_sendpage_sg(
struct iscsit_cmd *cmd,
- struct iscsi_conn *conn)
+ struct iscsit_conn *conn)
{
struct scatterlist *sg = cmd->first_data_sg;
struct kvec iov;
* Parameters: iSCSI Connection, Status Class, Status Detail.
* Returns: 0 on success, -1 on error.
*/
-int iscsit_tx_login_rsp(struct iscsi_conn *conn, u8 status_class, u8 status_detail)
+int iscsit_tx_login_rsp(struct iscsit_conn *conn, u8 status_class, u8 status_detail)
{
struct iscsi_login_rsp *hdr;
struct iscsi_login *login = conn->conn_login;
void iscsit_print_session_params(struct iscsi_session *sess)
{
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
pr_debug("-----------------------------[Session Params for"
" SID: %u]-----------------------------\n", sess->sid);
}
int rx_data(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct kvec *iov,
int iov_count,
int data)
}
int tx_data(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
struct kvec *iov,
int iov_count,
int data)
}
void iscsit_collect_login_stats(
- struct iscsi_conn *conn,
+ struct iscsit_conn *conn,
u8 status_class,
u8 status_detail)
{
spin_unlock(&ls->lock);
}
-struct iscsi_tiqn *iscsit_snmp_get_tiqn(struct iscsi_conn *conn)
+struct iscsi_tiqn *iscsit_snmp_get_tiqn(struct iscsit_conn *conn)
{
struct iscsi_portal_group *tpg;
#define MARKER_SIZE 8
struct iscsit_cmd;
-struct iscsi_conn;
+struct iscsit_conn;
struct iscsi_conn_recovery;
struct iscsi_session;
extern struct iscsi_r2t *iscsit_get_r2t_from_list(struct iscsit_cmd *);
extern void iscsit_free_r2t(struct iscsi_r2t *, struct iscsit_cmd *);
extern void iscsit_free_r2ts_from_list(struct iscsit_cmd *);
-extern struct iscsit_cmd *iscsit_alloc_cmd(struct iscsi_conn *, gfp_t);
-extern struct iscsit_cmd *iscsit_allocate_cmd(struct iscsi_conn *, int);
+extern struct iscsit_cmd *iscsit_alloc_cmd(struct iscsit_conn *, gfp_t);
+extern struct iscsit_cmd *iscsit_allocate_cmd(struct iscsit_conn *, int);
extern struct iscsi_seq *iscsit_get_seq_holder_for_datain(struct iscsit_cmd *, u32);
extern struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsit_cmd *);
extern struct iscsi_r2t *iscsit_get_holder_for_r2tsn(struct iscsit_cmd *, u32);
-extern int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsit_cmd *cmd,
+extern int iscsit_sequence_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
unsigned char * ,__be32 cmdsn);
extern int iscsit_check_unsolicited_dataout(struct iscsit_cmd *, unsigned char *);
-extern struct iscsit_cmd *iscsit_find_cmd_from_itt_or_dump(struct iscsi_conn *,
+extern struct iscsit_cmd *iscsit_find_cmd_from_itt_or_dump(struct iscsit_conn *,
itt_t, u32);
-extern struct iscsit_cmd *iscsit_find_cmd_from_ttt(struct iscsi_conn *, u32);
+extern struct iscsit_cmd *iscsit_find_cmd_from_ttt(struct iscsit_conn *, u32);
extern int iscsit_find_cmd_for_recovery(struct iscsi_session *, struct iscsit_cmd **,
struct iscsi_conn_recovery **, itt_t);
-extern void iscsit_add_cmd_to_immediate_queue(struct iscsit_cmd *, struct iscsi_conn *, u8);
-extern struct iscsi_queue_req *iscsit_get_cmd_from_immediate_queue(struct iscsi_conn *);
-extern int iscsit_add_cmd_to_response_queue(struct iscsit_cmd *, struct iscsi_conn *, u8);
-extern struct iscsi_queue_req *iscsit_get_cmd_from_response_queue(struct iscsi_conn *);
-extern void iscsit_remove_cmd_from_tx_queues(struct iscsit_cmd *, struct iscsi_conn *);
-extern bool iscsit_conn_all_queues_empty(struct iscsi_conn *);
-extern void iscsit_free_queue_reqs_for_conn(struct iscsi_conn *);
+extern void iscsit_add_cmd_to_immediate_queue(struct iscsit_cmd *, struct iscsit_conn *, u8);
+extern struct iscsi_queue_req *iscsit_get_cmd_from_immediate_queue(struct iscsit_conn *);
+extern int iscsit_add_cmd_to_response_queue(struct iscsit_cmd *, struct iscsit_conn *, u8);
+extern struct iscsi_queue_req *iscsit_get_cmd_from_response_queue(struct iscsit_conn *);
+extern void iscsit_remove_cmd_from_tx_queues(struct iscsit_cmd *, struct iscsit_conn *);
+extern bool iscsit_conn_all_queues_empty(struct iscsit_conn *);
+extern void iscsit_free_queue_reqs_for_conn(struct iscsit_conn *);
extern void iscsit_release_cmd(struct iscsit_cmd *);
extern void __iscsit_free_cmd(struct iscsit_cmd *, bool);
extern void iscsit_free_cmd(struct iscsit_cmd *, bool);
extern bool iscsit_check_session_usage_count(struct iscsi_session *sess, bool can_sleep);
extern void iscsit_dec_session_usage_count(struct iscsi_session *);
extern void iscsit_inc_session_usage_count(struct iscsi_session *);
-extern struct iscsi_conn *iscsit_get_conn_from_cid(struct iscsi_session *, u16);
-extern struct iscsi_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *, u16);
-extern void iscsit_check_conn_usage_count(struct iscsi_conn *);
-extern void iscsit_dec_conn_usage_count(struct iscsi_conn *);
-extern void iscsit_inc_conn_usage_count(struct iscsi_conn *);
+extern struct iscsit_conn *iscsit_get_conn_from_cid(struct iscsi_session *, u16);
+extern struct iscsit_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *, u16);
+extern void iscsit_check_conn_usage_count(struct iscsit_conn *);
+extern void iscsit_dec_conn_usage_count(struct iscsit_conn *);
+extern void iscsit_inc_conn_usage_count(struct iscsit_conn *);
extern void iscsit_handle_nopin_response_timeout(struct timer_list *t);
-extern void iscsit_mod_nopin_response_timer(struct iscsi_conn *);
-extern void iscsit_start_nopin_response_timer(struct iscsi_conn *);
-extern void iscsit_stop_nopin_response_timer(struct iscsi_conn *);
+extern void iscsit_mod_nopin_response_timer(struct iscsit_conn *);
+extern void iscsit_start_nopin_response_timer(struct iscsit_conn *);
+extern void iscsit_stop_nopin_response_timer(struct iscsit_conn *);
extern void iscsit_handle_nopin_timeout(struct timer_list *t);
-extern void __iscsit_start_nopin_timer(struct iscsi_conn *);
-extern void iscsit_start_nopin_timer(struct iscsi_conn *);
-extern void iscsit_stop_nopin_timer(struct iscsi_conn *);
-extern int iscsit_send_tx_data(struct iscsit_cmd *, struct iscsi_conn *, int);
-extern int iscsit_fe_sendpage_sg(struct iscsit_cmd *, struct iscsi_conn *);
-extern int iscsit_tx_login_rsp(struct iscsi_conn *, u8, u8);
+extern void __iscsit_start_nopin_timer(struct iscsit_conn *);
+extern void iscsit_start_nopin_timer(struct iscsit_conn *);
+extern void iscsit_stop_nopin_timer(struct iscsit_conn *);
+extern int iscsit_send_tx_data(struct iscsit_cmd *, struct iscsit_conn *, int);
+extern int iscsit_fe_sendpage_sg(struct iscsit_cmd *, struct iscsit_conn *);
+extern int iscsit_tx_login_rsp(struct iscsit_conn *, u8, u8);
extern void iscsit_print_session_params(struct iscsi_session *);
extern int iscsit_print_dev_to_proc(char *, char **, off_t, int);
extern int iscsit_print_sessions_to_proc(char *, char **, off_t, int);
extern int iscsit_print_tpg_to_proc(char *, char **, off_t, int);
-extern int rx_data(struct iscsi_conn *, struct kvec *, int, int);
-extern int tx_data(struct iscsi_conn *, struct kvec *, int, int);
-extern void iscsit_collect_login_stats(struct iscsi_conn *, u8, u8);
-extern struct iscsi_tiqn *iscsit_snmp_get_tiqn(struct iscsi_conn *);
+extern int rx_data(struct iscsit_conn *, struct kvec *, int, int);
+extern int tx_data(struct iscsit_conn *, struct kvec *, int, int);
+extern void iscsit_collect_login_stats(struct iscsit_conn *, u8, u8);
+extern struct iscsi_tiqn *iscsit_snmp_get_tiqn(struct iscsit_conn *);
extern void iscsit_fill_cxn_timeout_err_stats(struct iscsi_session *);
#endif /*** ISCSI_TARGET_UTIL_H ***/
/* TMR Request when iscsi_opcode == ISCSI_OP_SCSI_TMFUNC */
struct iscsi_tmr_req *tmr_req;
/* Connection this command is alligient to */
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
/* Pointer to connection recovery entry */
struct iscsi_conn_recovery *cr;
/* Session the command is part of, used for connection recovery */
struct se_tmr_req *se_tmr_req;
};
-struct iscsi_conn {
+struct iscsit_conn {
wait_queue_head_t queues_wq;
/* Authentication Successful for this connection */
u8 auth_complete;
char rsp[ISCSI_HDR_LEN];
char *req_buf;
char *rsp_buf;
- struct iscsi_conn *conn;
+ struct iscsit_conn *conn;
struct iscsi_np *np;
} ____cacheline_aligned;
return ttt;
}
-extern struct iscsit_cmd *iscsit_find_cmd_from_itt(struct iscsi_conn *, itt_t);
+extern struct iscsit_cmd *iscsit_find_cmd_from_itt(struct iscsit_conn *, itt_t);
-extern void iscsit_thread_check_cpumask(struct iscsi_conn *conn,
+extern void iscsit_thread_check_cpumask(struct iscsit_conn *conn,
struct task_struct *p,
int mode);
struct module *owner;
struct list_head t_node;
int (*iscsit_setup_np)(struct iscsi_np *, struct sockaddr_storage *);
- int (*iscsit_accept_np)(struct iscsi_np *, struct iscsi_conn *);
+ int (*iscsit_accept_np)(struct iscsi_np *, struct iscsit_conn *);
void (*iscsit_free_np)(struct iscsi_np *);
- void (*iscsit_wait_conn)(struct iscsi_conn *);
- void (*iscsit_free_conn)(struct iscsi_conn *);
- int (*iscsit_get_login_rx)(struct iscsi_conn *, struct iscsi_login *);
- int (*iscsit_put_login_tx)(struct iscsi_conn *, struct iscsi_login *, u32);
- int (*iscsit_immediate_queue)(struct iscsi_conn *, struct iscsit_cmd *, int);
- int (*iscsit_response_queue)(struct iscsi_conn *, struct iscsit_cmd *, int);
- int (*iscsit_get_dataout)(struct iscsi_conn *, struct iscsit_cmd *, bool);
- int (*iscsit_queue_data_in)(struct iscsi_conn *, struct iscsit_cmd *);
- int (*iscsit_queue_status)(struct iscsi_conn *, struct iscsit_cmd *);
- void (*iscsit_aborted_task)(struct iscsi_conn *, struct iscsit_cmd *);
- int (*iscsit_xmit_pdu)(struct iscsi_conn *, struct iscsit_cmd *,
+ void (*iscsit_wait_conn)(struct iscsit_conn *);
+ void (*iscsit_free_conn)(struct iscsit_conn *);
+ int (*iscsit_get_login_rx)(struct iscsit_conn *, struct iscsi_login *);
+ int (*iscsit_put_login_tx)(struct iscsit_conn *, struct iscsi_login *, u32);
+ int (*iscsit_immediate_queue)(struct iscsit_conn *, struct iscsit_cmd *, int);
+ int (*iscsit_response_queue)(struct iscsit_conn *, struct iscsit_cmd *, int);
+ int (*iscsit_get_dataout)(struct iscsit_conn *, struct iscsit_cmd *, bool);
+ int (*iscsit_queue_data_in)(struct iscsit_conn *, struct iscsit_cmd *);
+ int (*iscsit_queue_status)(struct iscsit_conn *, struct iscsit_cmd *);
+ void (*iscsit_aborted_task)(struct iscsit_conn *, struct iscsit_cmd *);
+ int (*iscsit_xmit_pdu)(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_datain_req *, const void *, u32);
- void (*iscsit_unmap_cmd)(struct iscsi_conn *, struct iscsit_cmd *);
- void (*iscsit_get_rx_pdu)(struct iscsi_conn *);
- int (*iscsit_validate_params)(struct iscsi_conn *);
- void (*iscsit_get_r2t_ttt)(struct iscsi_conn *, struct iscsit_cmd *,
+ void (*iscsit_unmap_cmd)(struct iscsit_conn *, struct iscsit_cmd *);
+ void (*iscsit_get_rx_pdu)(struct iscsit_conn *);
+ int (*iscsit_validate_params)(struct iscsit_conn *);
+ void (*iscsit_get_r2t_ttt)(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_r2t *);
- enum target_prot_op (*iscsit_get_sup_prot_ops)(struct iscsi_conn *);
+ enum target_prot_op (*iscsit_get_sup_prot_ops)(struct iscsit_conn *);
};
static inline void *iscsit_priv_cmd(struct iscsit_cmd *cmd)
/*
* From iscsi_target.c
*/
-extern int iscsit_setup_scsi_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_setup_scsi_cmd(struct iscsit_conn *, struct iscsit_cmd *,
unsigned char *);
extern void iscsit_set_unsolicited_dataout(struct iscsit_cmd *);
-extern int iscsit_process_scsi_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_process_scsi_cmd(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_scsi_req *);
extern int
-__iscsit_check_dataout_hdr(struct iscsi_conn *, void *,
+__iscsit_check_dataout_hdr(struct iscsit_conn *, void *,
struct iscsit_cmd *, u32, bool *);
extern int
-iscsit_check_dataout_hdr(struct iscsi_conn *conn, void *buf,
+iscsit_check_dataout_hdr(struct iscsit_conn *conn, void *buf,
struct iscsit_cmd **out_cmd);
extern int iscsit_check_dataout_payload(struct iscsit_cmd *, struct iscsi_data *,
bool);
-extern int iscsit_setup_nop_out(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_setup_nop_out(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_nopout *);
-extern int iscsit_process_nop_out(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_process_nop_out(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_nopout *);
-extern int iscsit_handle_logout_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_handle_logout_cmd(struct iscsit_conn *, struct iscsit_cmd *,
unsigned char *);
-extern int iscsit_handle_task_mgt_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_handle_task_mgt_cmd(struct iscsit_conn *, struct iscsit_cmd *,
unsigned char *);
-extern int iscsit_setup_text_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_setup_text_cmd(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_text *);
-extern int iscsit_process_text_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_process_text_cmd(struct iscsit_conn *, struct iscsit_cmd *,
struct iscsi_text *);
-extern void iscsit_build_rsp_pdu(struct iscsit_cmd *, struct iscsi_conn *,
+extern void iscsit_build_rsp_pdu(struct iscsit_cmd *, struct iscsit_conn *,
bool, struct iscsi_scsi_rsp *);
-extern void iscsit_build_nopin_rsp(struct iscsit_cmd *, struct iscsi_conn *,
+extern void iscsit_build_nopin_rsp(struct iscsit_cmd *, struct iscsit_conn *,
struct iscsi_nopin *, bool);
-extern void iscsit_build_task_mgt_rsp(struct iscsit_cmd *, struct iscsi_conn *,
+extern void iscsit_build_task_mgt_rsp(struct iscsit_cmd *, struct iscsit_conn *,
struct iscsi_tm_rsp *);
-extern int iscsit_build_text_rsp(struct iscsit_cmd *, struct iscsi_conn *,
+extern int iscsit_build_text_rsp(struct iscsit_cmd *, struct iscsit_conn *,
struct iscsi_text_rsp *,
enum iscsit_transport_type);
-extern void iscsit_build_reject(struct iscsit_cmd *, struct iscsi_conn *,
+extern void iscsit_build_reject(struct iscsit_cmd *, struct iscsit_conn *,
struct iscsi_reject *);
-extern int iscsit_build_logout_rsp(struct iscsit_cmd *, struct iscsi_conn *,
+extern int iscsit_build_logout_rsp(struct iscsit_cmd *, struct iscsit_conn *,
struct iscsi_logout_rsp *);
-extern int iscsit_logout_post_handler(struct iscsit_cmd *, struct iscsi_conn *);
-extern int iscsit_queue_rsp(struct iscsi_conn *, struct iscsit_cmd *);
-extern void iscsit_aborted_task(struct iscsi_conn *, struct iscsit_cmd *);
-extern int iscsit_add_reject(struct iscsi_conn *, u8, unsigned char *);
+extern int iscsit_logout_post_handler(struct iscsit_cmd *, struct iscsit_conn *);
+extern int iscsit_queue_rsp(struct iscsit_conn *, struct iscsit_cmd *);
+extern void iscsit_aborted_task(struct iscsit_conn *, struct iscsit_cmd *);
+extern int iscsit_add_reject(struct iscsit_conn *, u8, unsigned char *);
extern int iscsit_reject_cmd(struct iscsit_cmd *, u8, unsigned char *);
-extern int iscsit_handle_snack(struct iscsi_conn *, unsigned char *);
-extern void iscsit_build_datain_pdu(struct iscsit_cmd *, struct iscsi_conn *,
+extern int iscsit_handle_snack(struct iscsit_conn *, unsigned char *);
+extern void iscsit_build_datain_pdu(struct iscsit_cmd *, struct iscsit_conn *,
struct iscsi_datain *,
struct iscsi_data_rsp *, bool);
-extern int iscsit_build_r2ts_for_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern int iscsit_build_r2ts_for_cmd(struct iscsit_conn *, struct iscsit_cmd *,
bool);
-extern int iscsit_immediate_queue(struct iscsi_conn *, struct iscsit_cmd *, int);
-extern int iscsit_response_queue(struct iscsi_conn *, struct iscsit_cmd *, int);
+extern int iscsit_immediate_queue(struct iscsit_conn *, struct iscsit_cmd *, int);
+extern int iscsit_response_queue(struct iscsit_conn *, struct iscsit_cmd *, int);
/*
* From iscsi_target_device.c
*/
/*
* From iscsi_target_erl0.c
*/
-extern void iscsit_cause_connection_reinstatement(struct iscsi_conn *, int);
+extern void iscsit_cause_connection_reinstatement(struct iscsit_conn *, int);
/*
* From iscsi_target_erl1.c
*/
/*
* From iscsi_target_tmr.c
*/
-extern int iscsit_tmr_post_handler(struct iscsit_cmd *, struct iscsi_conn *);
+extern int iscsit_tmr_post_handler(struct iscsit_cmd *, struct iscsit_conn *);
/*
* From iscsi_target_util.c
*/
-extern struct iscsit_cmd *iscsit_allocate_cmd(struct iscsi_conn *, int);
-extern int iscsit_sequence_cmd(struct iscsi_conn *, struct iscsit_cmd *,
+extern struct iscsit_cmd *iscsit_allocate_cmd(struct iscsit_conn *, int);
+extern int iscsit_sequence_cmd(struct iscsit_conn *, struct iscsit_cmd *,
unsigned char *, __be32);
extern void iscsit_release_cmd(struct iscsit_cmd *);
extern void iscsit_free_cmd(struct iscsit_cmd *, bool);
extern void iscsit_add_cmd_to_immediate_queue(struct iscsit_cmd *,
- struct iscsi_conn *, u8);
+ struct iscsit_conn *, u8);
extern struct iscsit_cmd *
-iscsit_find_cmd_from_itt_or_dump(struct iscsi_conn *conn,
+iscsit_find_cmd_from_itt_or_dump(struct iscsit_conn *conn,
itt_t init_task_tag, u32 length);
/*
* From iscsi_target_nego.c
*/
-extern int iscsi_target_check_login_request(struct iscsi_conn *,
+extern int iscsi_target_check_login_request(struct iscsit_conn *,
struct iscsi_login *);
/*
* From iscsi_target_login.c
*/
extern __printf(2, 3) int iscsi_change_param_sprintf(
- struct iscsi_conn *, const char *, ...);
+ struct iscsit_conn *, const char *, ...);
/*
* From iscsi_target_parameters.c
projects / linux-2.6-block.git / commitdiff