ACK: [PATCH Wily SRU] Revert "[SCSI] libiscsi: Reduce locking contention in fast path"
Brad Figg
brad.figg at canonical.com
Wed Jan 20 18:14:44 UTC 2016
On Wed, Jan 20, 2016 at 08:41:21AM -0700, tim.gardner at canonical.com wrote:
> From: Tim Gardner <tim.gardner at canonical.com>
>
> BugLink: http://bugs.launchpad.net/bugs/1517142
>
> This reverts commit 659743b02c411075b26601725947b21df0bb29c8.
>
> Signed-off-by: Tim Gardner <tim.gardner at canonical.com>
>
> Conflicts:
> drivers/scsi/bnx2i/bnx2i_iscsi.c
> drivers/scsi/iscsi_tcp.c
> drivers/scsi/libiscsi.c
> ---
> drivers/scsi/be2iscsi/be_main.c | 26 ++---
> drivers/scsi/bnx2i/bnx2i_hwi.c | 46 ++++-----
> drivers/scsi/bnx2i/bnx2i_iscsi.c | 10 +-
> drivers/scsi/iscsi_tcp.c | 22 ++--
> drivers/scsi/libiscsi.c | 214 +++++++++++++++++----------------------
> drivers/scsi/libiscsi_tcp.c | 28 ++---
> drivers/scsi/qla4xxx/ql4_isr.c | 4 +-
> include/scsi/libiscsi.h | 17 +---
> include/scsi/libiscsi_tcp.h | 2 -
> 9 files changed, 161 insertions(+), 208 deletions(-)
>
> diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
> index 7a6dbfb..98d281a 100644
> --- a/drivers/scsi/be2iscsi/be_main.c
> +++ b/drivers/scsi/be2iscsi/be_main.c
> @@ -232,20 +232,20 @@ static int beiscsi_eh_abort(struct scsi_cmnd *sc)
> cls_session = starget_to_session(scsi_target(sc->device));
> session = cls_session->dd_data;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (!aborted_task || !aborted_task->sc) {
> /* we raced */
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return SUCCESS;
> }
>
> aborted_io_task = aborted_task->dd_data;
> if (!aborted_io_task->scsi_cmnd) {
> /* raced or invalid command */
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return SUCCESS;
> }
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> /* Invalidate WRB Posted for this Task */
> AMAP_SET_BITS(struct amap_iscsi_wrb, invld,
> aborted_io_task->pwrb_handle->pwrb,
> @@ -310,9 +310,9 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
> /* invalidate iocbs */
> cls_session = starget_to_session(scsi_target(sc->device));
> session = cls_session->dd_data;
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return FAILED;
> }
> conn = session->leadconn;
> @@ -341,7 +341,7 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
> num_invalidate++;
> inv_tbl++;
> }
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> inv_tbl = phba->inv_tbl;
>
> nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
> @@ -1137,9 +1137,9 @@ beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
> return 1;
> }
>
> - spin_lock_bh(&session->back_lock);
> + spin_lock_bh(&session->lock);
> __iscsi_complete_pdu(conn, (struct iscsi_hdr *)ppdu, pbuffer, buf_len);
> - spin_unlock_bh(&session->back_lock);
> + spin_unlock_bh(&session->lock);
> return 0;
> }
>
> @@ -1560,7 +1560,7 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
> pwrb = pwrb_handle->pwrb;
> type = ((struct beiscsi_io_task *)task->dd_data)->wrb_type;
>
> - spin_lock_bh(&session->back_lock);
> + spin_lock_bh(&session->lock);
> switch (type) {
> case HWH_TYPE_IO:
> case HWH_TYPE_IO_RD:
> @@ -1599,7 +1599,7 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
> break;
> }
>
> - spin_unlock_bh(&session->back_lock);
> + spin_unlock_bh(&session->lock);
> }
>
> static struct list_head *hwi_get_async_busy_list(struct hwi_async_pdu_context
> @@ -4688,9 +4688,9 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
> * login/startup related tasks.
> */
> beiscsi_conn->login_in_progress = 0;
> - spin_lock_bh(&session->back_lock);
> + spin_lock_bh(&session->lock);
> beiscsi_cleanup_task(task);
> - spin_unlock_bh(&session->back_lock);
> + spin_unlock_bh(&session->lock);
>
> pwrb_handle = alloc_wrb_handle(phba, beiscsi_conn->beiscsi_conn_cid);
>
> diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
> index fb072cc..9bfc3d6 100644
> --- a/drivers/scsi/bnx2i/bnx2i_hwi.c
> +++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
> @@ -1363,7 +1363,7 @@ int bnx2i_process_scsi_cmd_resp(struct iscsi_session *session,
> u32 datalen = 0;
>
> resp_cqe = (struct bnx2i_cmd_response *)cqe;
> - spin_lock_bh(&session->back_lock);
> + spin_lock_bh(&session->lock);
> task = iscsi_itt_to_task(conn,
> resp_cqe->itt & ISCSI_CMD_RESPONSE_INDEX);
> if (!task)
> @@ -1434,7 +1434,7 @@ done:
> __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr,
> conn->data, datalen);
> fail:
> - spin_unlock_bh(&session->back_lock);
> + spin_unlock_bh(&session->lock);
> return 0;
> }
>
> @@ -1459,7 +1459,7 @@ static int bnx2i_process_login_resp(struct iscsi_session *session,
> int pad_len;
>
> login = (struct bnx2i_login_response *) cqe;
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> task = iscsi_itt_to_task(conn,
> login->itt & ISCSI_LOGIN_RESPONSE_INDEX);
> if (!task)
> @@ -1502,7 +1502,7 @@ static int bnx2i_process_login_resp(struct iscsi_session *session,
> bnx2i_conn->gen_pdu.resp_buf,
> bnx2i_conn->gen_pdu.resp_wr_ptr - bnx2i_conn->gen_pdu.resp_buf);
> done:
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> return 0;
> }
>
> @@ -1527,7 +1527,7 @@ static int bnx2i_process_text_resp(struct iscsi_session *session,
> int pad_len;
>
> text = (struct bnx2i_text_response *) cqe;
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> task = iscsi_itt_to_task(conn, text->itt & ISCSI_LOGIN_RESPONSE_INDEX);
> if (!task)
> goto done;
> @@ -1563,7 +1563,7 @@ static int bnx2i_process_text_resp(struct iscsi_session *session,
> bnx2i_conn->gen_pdu.resp_wr_ptr -
> bnx2i_conn->gen_pdu.resp_buf);
> done:
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> return 0;
> }
>
> @@ -1586,7 +1586,7 @@ static int bnx2i_process_tmf_resp(struct iscsi_session *session,
> struct iscsi_tm_rsp *resp_hdr;
>
> tmf_cqe = (struct bnx2i_tmf_response *)cqe;
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> task = iscsi_itt_to_task(conn,
> tmf_cqe->itt & ISCSI_TMF_RESPONSE_INDEX);
> if (!task)
> @@ -1602,7 +1602,7 @@ static int bnx2i_process_tmf_resp(struct iscsi_session *session,
>
> __iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr, NULL, 0);
> done:
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> return 0;
> }
>
> @@ -1625,7 +1625,7 @@ static int bnx2i_process_logout_resp(struct iscsi_session *session,
> struct iscsi_logout_rsp *resp_hdr;
>
> logout = (struct bnx2i_logout_response *) cqe;
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> task = iscsi_itt_to_task(conn,
> logout->itt & ISCSI_LOGOUT_RESPONSE_INDEX);
> if (!task)
> @@ -1649,7 +1649,7 @@ static int bnx2i_process_logout_resp(struct iscsi_session *session,
>
> bnx2i_conn->ep->state = EP_STATE_LOGOUT_RESP_RCVD;
> done:
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> return 0;
> }
>
> @@ -1670,12 +1670,12 @@ static void bnx2i_process_nopin_local_cmpl(struct iscsi_session *session,
> struct iscsi_task *task;
>
> nop_in = (struct bnx2i_nop_in_msg *)cqe;
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> task = iscsi_itt_to_task(conn,
> nop_in->itt & ISCSI_NOP_IN_MSG_INDEX);
> if (task)
> __iscsi_put_task(task);
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> }
>
> /**
> @@ -1714,7 +1714,7 @@ static int bnx2i_process_nopin_mesg(struct iscsi_session *session,
>
> nop_in = (struct bnx2i_nop_in_msg *)cqe;
>
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> hdr = (struct iscsi_nopin *)&bnx2i_conn->gen_pdu.resp_hdr;
> memset(hdr, 0, sizeof(struct iscsi_hdr));
> hdr->opcode = nop_in->op_code;
> @@ -1740,7 +1740,7 @@ static int bnx2i_process_nopin_mesg(struct iscsi_session *session,
> }
> done:
> __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
>
> return tgt_async_nop;
> }
> @@ -1773,7 +1773,7 @@ static void bnx2i_process_async_mesg(struct iscsi_session *session,
> return;
> }
>
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> resp_hdr = (struct iscsi_async *) &bnx2i_conn->gen_pdu.resp_hdr;
> memset(resp_hdr, 0, sizeof(struct iscsi_hdr));
> resp_hdr->opcode = async_cqe->op_code;
> @@ -1792,7 +1792,7 @@ static void bnx2i_process_async_mesg(struct iscsi_session *session,
>
> __iscsi_complete_pdu(bnx2i_conn->cls_conn->dd_data,
> (struct iscsi_hdr *)resp_hdr, NULL, 0);
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> }
>
>
> @@ -1819,7 +1819,7 @@ static void bnx2i_process_reject_mesg(struct iscsi_session *session,
> } else
> bnx2i_unsol_pdu_adjust_rq(bnx2i_conn);
>
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> hdr = (struct iscsi_reject *) &bnx2i_conn->gen_pdu.resp_hdr;
> memset(hdr, 0, sizeof(struct iscsi_hdr));
> hdr->opcode = reject->op_code;
> @@ -1830,7 +1830,7 @@ static void bnx2i_process_reject_mesg(struct iscsi_session *session,
> hdr->ffffffff = cpu_to_be32(RESERVED_ITT);
> __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, conn->data,
> reject->data_length);
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> }
>
> /**
> @@ -1850,13 +1850,13 @@ static void bnx2i_process_cmd_cleanup_resp(struct iscsi_session *session,
> struct iscsi_task *task;
>
> cmd_clean_rsp = (struct bnx2i_cleanup_response *)cqe;
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> task = iscsi_itt_to_task(conn,
> cmd_clean_rsp->itt & ISCSI_CLEANUP_RESPONSE_INDEX);
> if (!task)
> printk(KERN_ALERT "bnx2i: cmd clean ITT %x not active\n",
> cmd_clean_rsp->itt & ISCSI_CLEANUP_RESPONSE_INDEX);
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> complete(&bnx2i_conn->cmd_cleanup_cmpl);
> }
>
> @@ -1923,11 +1923,11 @@ static int bnx2i_queue_scsi_cmd_resp(struct iscsi_session *session,
> int rc = 0;
> int cpu;
>
> - spin_lock(&session->back_lock);
> + spin_lock(&session->lock);
> task = iscsi_itt_to_task(bnx2i_conn->cls_conn->dd_data,
> cqe->itt & ISCSI_CMD_RESPONSE_INDEX);
> if (!task || !task->sc) {
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
> return -EINVAL;
> }
> sc = task->sc;
> @@ -1937,7 +1937,7 @@ static int bnx2i_queue_scsi_cmd_resp(struct iscsi_session *session,
> else
> cpu = sc->request->cpu;
>
> - spin_unlock(&session->back_lock);
> + spin_unlock(&session->lock);
>
> p = &per_cpu(bnx2i_percpu, cpu);
> spin_lock(&p->p_work_lock);
> diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
> index 7289437..1ef5bbb 100644
> --- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
> +++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
> @@ -1172,12 +1172,10 @@ static void bnx2i_cleanup_task(struct iscsi_task *task)
> if (task->state == ISCSI_TASK_ABRT_TMF) {
> bnx2i_send_cmd_cleanup_req(hba, task->dd_data);
>
> - spin_unlock_bh(&conn->session->back_lock);
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> wait_for_completion_timeout(&bnx2i_conn->cmd_cleanup_cmpl,
> msecs_to_jiffies(ISCSI_CMD_CLEANUP_TIMEOUT));
> - spin_lock_bh(&conn->session->frwd_lock);
> - spin_lock_bh(&conn->session->back_lock);
> + spin_lock_bh(&conn->session->lock);
> }
> bnx2i_iscsi_unmap_sg_list(task->dd_data);
> }
> @@ -2063,7 +2061,7 @@ int bnx2i_hw_ep_disconnect(struct bnx2i_endpoint *bnx2i_ep)
> goto out;
>
> if (session) {
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (bnx2i_ep->state != EP_STATE_TCP_FIN_RCVD) {
> if (session->state == ISCSI_STATE_LOGGING_OUT) {
> if (bnx2i_ep->state == EP_STATE_LOGOUT_SENT) {
> @@ -2079,7 +2077,7 @@ int bnx2i_hw_ep_disconnect(struct bnx2i_endpoint *bnx2i_ep)
> } else
> close = 1;
>
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> }
>
> bnx2i_ep->state = EP_STATE_DISCONN_START;
> diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
> index 0b8af18..19be12f 100644
> --- a/drivers/scsi/iscsi_tcp.c
> +++ b/drivers/scsi/iscsi_tcp.c
> @@ -593,9 +593,9 @@ static void iscsi_sw_tcp_release_conn(struct iscsi_conn *conn)
> iscsi_sw_tcp_conn_restore_callbacks(conn);
> sock_put(sock->sk);
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> tcp_sw_conn->sock = NULL;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> sockfd_put(sock);
> }
>
> @@ -663,10 +663,10 @@ iscsi_sw_tcp_conn_bind(struct iscsi_cls_session *cls_session,
> if (err)
> goto free_socket;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> /* bind iSCSI connection and socket */
> tcp_sw_conn->sock = sock;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> /* setup Socket parameters */
> sk = sock->sk;
> @@ -727,9 +727,9 @@ static int iscsi_sw_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
> case ISCSI_PARAM_CONN_PORT:
> case ISCSI_PARAM_CONN_ADDRESS:
> case ISCSI_PARAM_LOCAL_PORT:
> - spin_lock_bh(&conn->session->frwd_lock);
> + spin_lock_bh(&conn->session->lock);
> if (!tcp_sw_conn || !tcp_sw_conn->sock) {
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> return -ENOTCONN;
> }
> if (param == ISCSI_PARAM_LOCAL_PORT)
> @@ -738,7 +738,7 @@ static int iscsi_sw_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
> else
> rc = kernel_getpeername(tcp_sw_conn->sock,
> (struct sockaddr *)&addr, &len);
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> if (rc)
> return rc;
>
> @@ -767,23 +767,23 @@ static int iscsi_sw_tcp_host_get_param(struct Scsi_Host *shost,
> if (!session)
> return -ENOTCONN;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> conn = session->leadconn;
> if (!conn) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return -ENOTCONN;
> }
> tcp_conn = conn->dd_data;
>
> tcp_sw_conn = tcp_conn->dd_data;
> if (!tcp_sw_conn->sock) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return -ENOTCONN;
> }
>
> rc = kernel_getsockname(tcp_sw_conn->sock,
> (struct sockaddr *)&addr, &len);
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> if (rc)
> return rc;
>
> diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
> index 98d9bb6..e519c2f 100644
> --- a/drivers/scsi/libiscsi.c
> +++ b/drivers/scsi/libiscsi.c
> @@ -477,7 +477,7 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
> * iscsi_free_task - free a task
> * @task: iscsi cmd task
> *
> - * Must be called with session back_lock.
> + * Must be called with session lock.
> * This function returns the scsi command to scsi-ml or cleans
> * up mgmt tasks then returns the task to the pool.
> */
> @@ -531,10 +531,9 @@ void iscsi_put_task(struct iscsi_task *task)
> {
> struct iscsi_session *session = task->conn->session;
>
> - /* regular RX path uses back_lock */
> - spin_lock_bh(&session->back_lock);
> + spin_lock_bh(&session->lock);
> __iscsi_put_task(task);
> - spin_unlock_bh(&session->back_lock);
> + spin_unlock_bh(&session->lock);
> }
> EXPORT_SYMBOL_GPL(iscsi_put_task);
>
> @@ -543,7 +542,7 @@ EXPORT_SYMBOL_GPL(iscsi_put_task);
> * @task: iscsi cmd task
> * @state: state to complete task with
> *
> - * Must be called with session back_lock.
> + * Must be called with session lock.
> */
> static void iscsi_complete_task(struct iscsi_task *task, int state)
> {
> @@ -582,7 +581,7 @@ static void iscsi_complete_task(struct iscsi_task *task, int state)
> * This is used when drivers do not need or cannot perform
> * lower level pdu processing.
> *
> - * Called with session back_lock
> + * Called with session lock
> */
> void iscsi_complete_scsi_task(struct iscsi_task *task,
> uint32_t exp_cmdsn, uint32_t max_cmdsn)
> @@ -599,7 +598,7 @@ EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task);
>
>
> /*
> - * session back_lock must be held and if not called for a task that is
> + * session lock must be held and if not called for a task that is
> * still pending or from the xmit thread, then xmit thread must
> * be suspended.
> */
> @@ -639,10 +638,7 @@ static void fail_scsi_task(struct iscsi_task *task, int err)
> scsi_in(sc)->resid = scsi_in(sc)->length;
> }
>
> - /* regular RX path uses back_lock */
> - spin_lock_bh(&conn->session->back_lock);
> iscsi_complete_task(task, state);
> - spin_unlock_bh(&conn->session->back_lock);
> }
>
> static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
> @@ -790,10 +786,7 @@ __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
> return task;
>
> free_task:
> - /* regular RX path uses back_lock */
> - spin_lock_bh(&session->back_lock);
> __iscsi_put_task(task);
> - spin_unlock_bh(&session->back_lock);
> return NULL;
> }
>
> @@ -804,10 +797,10 @@ int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr,
> struct iscsi_session *session = conn->session;
> int err = 0;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size))
> err = -EPERM;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return err;
> }
> EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu);
> @@ -1071,19 +1064,14 @@ static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
> if (opcode != ISCSI_OP_NOOP_OUT)
> return 0;
>
> - if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) {
> + if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG))
> /*
> * nop-out in response to target's nop-out rejected.
> * Just resend.
> */
> - /* In RX path we are under back lock */
> - spin_unlock(&conn->session->back_lock);
> - spin_lock(&conn->session->frwd_lock);
> iscsi_send_nopout(conn,
> (struct iscsi_nopin*)&rejected_pdu);
> - spin_unlock(&conn->session->frwd_lock);
> - spin_lock(&conn->session->back_lock);
> - } else {
> + else {
> struct iscsi_task *task;
> /*
> * Our nop as ping got dropped. We know the target
> @@ -1119,7 +1107,7 @@ static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
> * This should be used for mgmt tasks like login and nops, or if
> * the LDD's itt space does not include the session age.
> *
> - * The session back_lock must be held.
> + * The session lock must be held.
> */
> struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt)
> {
> @@ -1148,7 +1136,7 @@ EXPORT_SYMBOL_GPL(iscsi_itt_to_task);
> * @datalen: len of data buffer
> *
> * Completes pdu processing by freeing any resources allocated at
> - * queuecommand or send generic. session back_lock must be held and verify
> + * queuecommand or send generic. session lock must be held and verify
> * itt must have been called.
> */
> int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
> @@ -1185,12 +1173,7 @@ int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
> if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
> break;
>
> - /* In RX path we are under back lock */
> - spin_unlock(&session->back_lock);
> - spin_lock(&session->frwd_lock);
> iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr);
> - spin_unlock(&session->frwd_lock);
> - spin_lock(&session->back_lock);
> break;
> case ISCSI_OP_REJECT:
> rc = iscsi_handle_reject(conn, hdr, data, datalen);
> @@ -1297,9 +1280,9 @@ int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
> {
> int rc;
>
> - spin_lock(&conn->session->back_lock);
> + spin_lock(&conn->session->lock);
> rc = __iscsi_complete_pdu(conn, hdr, data, datalen);
> - spin_unlock(&conn->session->back_lock);
> + spin_unlock(&conn->session->lock);
> return rc;
> }
> EXPORT_SYMBOL_GPL(iscsi_complete_pdu);
> @@ -1343,7 +1326,7 @@ EXPORT_SYMBOL_GPL(iscsi_verify_itt);
> *
> * This should be used for cmd tasks.
> *
> - * The session back_lock must be held.
> + * The session lock must be held.
> */
> struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt)
> {
> @@ -1373,15 +1356,15 @@ void iscsi_session_failure(struct iscsi_session *session,
> struct iscsi_conn *conn;
> struct device *dev;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> conn = session->leadconn;
> if (session->state == ISCSI_STATE_TERMINATE || !conn) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return;
> }
>
> dev = get_device(&conn->cls_conn->dev);
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> if (!dev)
> return;
> /*
> @@ -1401,15 +1384,15 @@ void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
> {
> struct iscsi_session *session = conn->session;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (session->state == ISCSI_STATE_FAILED) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return;
> }
>
> if (conn->stop_stage == 0)
> session->state = ISCSI_STATE_FAILED;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
> set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
> @@ -1443,18 +1426,15 @@ static int iscsi_xmit_task(struct iscsi_conn *conn)
> return -ENODATA;
>
> __iscsi_get_task(task);
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> rc = conn->session->tt->xmit_task(task);
> - spin_lock_bh(&conn->session->frwd_lock);
> + spin_lock_bh(&conn->session->lock);
> if (!rc) {
> /* done with this task */
> task->last_xfer = jiffies;
> conn->task = NULL;
> }
> - /* regular RX path uses back_lock */
> - spin_lock(&conn->session->back_lock);
> __iscsi_put_task(task);
> - spin_unlock(&conn->session->back_lock);
> return rc;
> }
>
> @@ -1463,7 +1443,7 @@ static int iscsi_xmit_task(struct iscsi_conn *conn)
> * @task: task to requeue
> *
> * LLDs that need to run a task from the session workqueue should call
> - * this. The session frwd_lock must be held. This should only be called
> + * this. The session lock must be held. This should only be called
> * by software drivers.
> */
> void iscsi_requeue_task(struct iscsi_task *task)
> @@ -1494,10 +1474,10 @@ static int iscsi_data_xmit(struct iscsi_conn *conn)
> struct iscsi_task *task;
> int rc = 0;
>
> - spin_lock_bh(&conn->session->frwd_lock);
> + spin_lock_bh(&conn->session->lock);
> if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
> ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n");
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> return -ENODATA;
> }
>
> @@ -1518,10 +1498,7 @@ check_mgmt:
> struct iscsi_task, running);
> list_del_init(&conn->task->running);
> if (iscsi_prep_mgmt_task(conn, conn->task)) {
> - /* regular RX path uses back_lock */
> - spin_lock_bh(&conn->session->back_lock);
> __iscsi_put_task(conn->task);
> - spin_unlock_bh(&conn->session->back_lock);
> conn->task = NULL;
> continue;
> }
> @@ -1583,11 +1560,11 @@ check_mgmt:
> if (!list_empty(&conn->mgmtqueue))
> goto check_mgmt;
> }
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> return -ENODATA;
>
> done:
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> return rc;
> }
>
> @@ -1657,7 +1634,7 @@ int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
>
> cls_session = starget_to_session(scsi_target(sc->device));
> session = cls_session->dd_data;
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
>
> reason = iscsi_session_chkready(cls_session);
> if (reason) {
> @@ -1743,13 +1720,13 @@ int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
> }
>
> session->queued_cmdsn++;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> return 0;
>
> prepd_reject:
> iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
> reject:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
> sc->cmnd[0], reason);
> return SCSI_MLQUEUE_TARGET_BUSY;
> @@ -1757,7 +1734,7 @@ reject:
> prepd_fault:
> iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
> fault:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
> sc->cmnd[0], reason);
> if (!scsi_bidi_cmnd(sc))
> @@ -1786,14 +1763,14 @@ static void iscsi_tmf_timedout(unsigned long data)
> struct iscsi_conn *conn = (struct iscsi_conn *)data;
> struct iscsi_session *session = conn->session;
>
> - spin_lock(&session->frwd_lock);
> + spin_lock(&session->lock);
> if (conn->tmf_state == TMF_QUEUED) {
> conn->tmf_state = TMF_TIMEDOUT;
> ISCSI_DBG_EH(session, "tmf timedout\n");
> /* unblock eh_abort() */
> wake_up(&conn->ehwait);
> }
> - spin_unlock(&session->frwd_lock);
> + spin_unlock(&session->lock);
> }
>
> static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
> @@ -1806,10 +1783,10 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
> task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr,
> NULL, 0);
> if (!task) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n");
> iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> return -EPERM;
> }
> conn->tmfcmd_pdus_cnt++;
> @@ -1819,7 +1796,7 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
> add_timer(&conn->tmf_timer);
> ISCSI_DBG_EH(session, "tmf set timeout\n");
>
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
>
> /*
> @@ -1838,7 +1815,7 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
> del_timer_sync(&conn->tmf_timer);
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> /* if the session drops it will clean up the task */
> if (age != session->age ||
> session->state != ISCSI_STATE_LOGGED_IN)
> @@ -1874,7 +1851,7 @@ static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error)
> * iscsi_suspend_queue - suspend iscsi_queuecommand
> * @conn: iscsi conn to stop queueing IO on
> *
> - * This grabs the session frwd_lock to make sure no one is in
> + * This grabs the session lock to make sure no one is in
> * xmit_task/queuecommand, and then sets suspend to prevent
> * new commands from being queued. This only needs to be called
> * by offload drivers that need to sync a path like ep disconnect
> @@ -1883,9 +1860,9 @@ static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error)
> */
> void iscsi_suspend_queue(struct iscsi_conn *conn)
> {
> - spin_lock_bh(&conn->session->frwd_lock);
> + spin_lock_bh(&conn->session->lock);
> set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
> - spin_unlock_bh(&conn->session->frwd_lock);
> + spin_unlock_bh(&conn->session->lock);
> }
> EXPORT_SYMBOL_GPL(iscsi_suspend_queue);
>
> @@ -1944,7 +1921,7 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
>
> ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc);
>
> - spin_lock(&session->frwd_lock);
> + spin_lock(&session->lock);
> task = (struct iscsi_task *)sc->SCp.ptr;
> if (!task) {
> /*
> @@ -2058,7 +2035,7 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
> done:
> if (task)
> task->last_timeout = jiffies;
> - spin_unlock(&session->frwd_lock);
> + spin_unlock(&session->lock);
> ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
> "timer reset" : "nh");
> return rc;
> @@ -2070,7 +2047,7 @@ static void iscsi_check_transport_timeouts(unsigned long data)
> struct iscsi_session *session = conn->session;
> unsigned long recv_timeout, next_timeout = 0, last_recv;
>
> - spin_lock(&session->frwd_lock);
> + spin_lock(&session->lock);
> if (session->state != ISCSI_STATE_LOGGED_IN)
> goto done;
>
> @@ -2087,7 +2064,7 @@ static void iscsi_check_transport_timeouts(unsigned long data)
> "last ping %lu, now %lu\n",
> conn->ping_timeout, conn->recv_timeout,
> last_recv, conn->last_ping, jiffies);
> - spin_unlock(&session->frwd_lock);
> + spin_unlock(&session->lock);
> iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT);
> return;
> }
> @@ -2103,7 +2080,7 @@ static void iscsi_check_transport_timeouts(unsigned long data)
> ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout);
> mod_timer(&conn->transport_timer, next_timeout);
> done:
> - spin_unlock(&session->frwd_lock);
> + spin_unlock(&session->lock);
> }
>
> static void iscsi_prep_abort_task_pdu(struct iscsi_task *task,
> @@ -2133,7 +2110,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
> ISCSI_DBG_EH(session, "aborting sc %p\n", sc);
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> /*
> * if session was ISCSI_STATE_IN_RECOVERY then we may not have
> * got the command.
> @@ -2141,7 +2118,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
> if (!sc->SCp.ptr) {
> ISCSI_DBG_EH(session, "sc never reached iscsi layer or "
> "it completed.\n");
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
> return SUCCESS;
> }
> @@ -2152,7 +2129,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
> */
> if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN ||
> sc->SCp.phase != session->age) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
> ISCSI_DBG_EH(session, "failing abort due to dropped "
> "session.\n");
> @@ -2193,7 +2170,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
>
> switch (conn->tmf_state) {
> case TMF_SUCCESS:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> /*
> * stop tx side incase the target had sent a abort rsp but
> * the initiator was still writing out data.
> @@ -2204,15 +2181,15 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
> * good and have never sent us a successful tmf response
> * then sent more data for the cmd.
> */
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> fail_scsi_task(task, DID_ABORT);
> conn->tmf_state = TMF_INITIAL;
> memset(hdr, 0, sizeof(*hdr));
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> iscsi_start_tx(conn);
> goto success_unlocked;
> case TMF_TIMEDOUT:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
> goto failed_unlocked;
> case TMF_NOT_FOUND:
> @@ -2231,7 +2208,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
> }
>
> success:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> success_unlocked:
> ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n",
> sc, task->itt);
> @@ -2239,7 +2216,7 @@ success_unlocked:
> return SUCCESS;
>
> failed:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> failed_unlocked:
> ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc,
> task ? task->itt : 0);
> @@ -2273,7 +2250,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc)
> sc->device->lun);
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> /*
> * Just check if we are not logged in. We cannot check for
> * the phase because the reset could come from a ioctl.
> @@ -2300,7 +2277,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc)
> case TMF_SUCCESS:
> break;
> case TMF_TIMEDOUT:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
> goto done;
> default:
> @@ -2309,21 +2286,21 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc)
> }
>
> rc = SUCCESS;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> iscsi_suspend_tx(conn);
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> memset(hdr, 0, sizeof(*hdr));
> fail_scsi_tasks(conn, sc->device->lun, DID_ERROR);
> conn->tmf_state = TMF_INITIAL;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> iscsi_start_tx(conn);
> goto done;
>
> unlock:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> done:
> ISCSI_DBG_EH(session, "dev reset result = %s\n",
> rc == SUCCESS ? "SUCCESS" : "FAILED");
> @@ -2336,13 +2313,13 @@ void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
> {
> struct iscsi_session *session = cls_session->dd_data;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (session->state != ISCSI_STATE_LOGGED_IN) {
> session->state = ISCSI_STATE_RECOVERY_FAILED;
> if (session->leadconn)
> wake_up(&session->leadconn->ehwait);
> }
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> }
> EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);
>
> @@ -2364,19 +2341,19 @@ int iscsi_eh_session_reset(struct scsi_cmnd *sc)
> conn = session->leadconn;
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (session->state == ISCSI_STATE_TERMINATE) {
> failed:
> ISCSI_DBG_EH(session,
> "failing session reset: Could not log back into "
> "%s, %s [age %d]\n", session->targetname,
> conn->persistent_address, session->age);
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
> return FAILED;
> }
>
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
> /*
> * we drop the lock here but the leadconn cannot be destoyed while
> @@ -2393,14 +2370,14 @@ failed:
> flush_signals(current);
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (session->state == ISCSI_STATE_LOGGED_IN) {
> ISCSI_DBG_EH(session,
> "session reset succeeded for %s,%s\n",
> session->targetname, conn->persistent_address);
> } else
> goto failed;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
> return SUCCESS;
> }
> @@ -2436,7 +2413,7 @@ int iscsi_eh_target_reset(struct scsi_cmnd *sc)
> session->targetname);
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> /*
> * Just check if we are not logged in. We cannot check for
> * the phase because the reset could come from a ioctl.
> @@ -2463,7 +2440,7 @@ int iscsi_eh_target_reset(struct scsi_cmnd *sc)
> case TMF_SUCCESS:
> break;
> case TMF_TIMEDOUT:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
> goto done;
> default:
> @@ -2472,21 +2449,21 @@ int iscsi_eh_target_reset(struct scsi_cmnd *sc)
> }
>
> rc = SUCCESS;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> iscsi_suspend_tx(conn);
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> memset(hdr, 0, sizeof(*hdr));
> fail_scsi_tasks(conn, -1, DID_ERROR);
> conn->tmf_state = TMF_INITIAL;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> iscsi_start_tx(conn);
> goto done;
>
> unlock:
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> done:
> ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname,
> rc == SUCCESS ? "SUCCESS" : "FAILED");
> @@ -2784,10 +2761,8 @@ iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
> session->max_r2t = 1;
> session->tt = iscsit;
> session->dd_data = cls_session->dd_data + sizeof(*session);
> -
> mutex_init(&session->eh_mutex);
> - spin_lock_init(&session->frwd_lock);
> - spin_lock_init(&session->back_lock);
> + spin_lock_init(&session->lock);
>
> /* initialize SCSI PDU commands pool */
> if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
> @@ -2901,14 +2876,14 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
> INIT_WORK(&conn->xmitwork, iscsi_xmitworker);
>
> /* allocate login_task used for the login/text sequences */
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (!kfifo_out(&session->cmdpool.queue,
> (void*)&conn->login_task,
> sizeof(void*))) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> goto login_task_alloc_fail;
> }
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> data = (char *) __get_free_pages(GFP_KERNEL,
> get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
> @@ -2945,7 +2920,7 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
> del_timer_sync(&conn->transport_timer);
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> conn->c_stage = ISCSI_CONN_CLEANUP_WAIT;
> if (session->leadconn == conn) {
> /*
> @@ -2954,24 +2929,21 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
> session->state = ISCSI_STATE_TERMINATE;
> wake_up(&conn->ehwait);
> }
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> /* flush queued up work because we free the connection below */
> iscsi_suspend_tx(conn);
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> free_pages((unsigned long) conn->data,
> get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
> kfree(conn->persistent_address);
> kfree(conn->local_ipaddr);
> - /* regular RX path uses back_lock */
> - spin_lock_bh(&session->back_lock);
> kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
> sizeof(void*));
> - spin_unlock_bh(&session->back_lock);
> if (session->leadconn == conn)
> session->leadconn = NULL;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
>
> iscsi_destroy_conn(cls_conn);
> @@ -3009,7 +2981,7 @@ int iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
> conn->ping_timeout = 5;
> }
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> conn->c_stage = ISCSI_CONN_STARTED;
> session->state = ISCSI_STATE_LOGGED_IN;
> session->queued_cmdsn = session->cmdsn;
> @@ -3038,7 +3010,7 @@ int iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
> default:
> break;
> }
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> iscsi_unblock_session(session->cls_session);
> wake_up(&conn->ehwait);
> @@ -3077,9 +3049,9 @@ static void iscsi_start_session_recovery(struct iscsi_session *session,
> int old_stop_stage;
>
> mutex_lock(&session->eh_mutex);
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (conn->stop_stage == STOP_CONN_TERM) {
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
> return;
> }
> @@ -3096,14 +3068,14 @@ static void iscsi_start_session_recovery(struct iscsi_session *session,
>
> old_stop_stage = conn->stop_stage;
> conn->stop_stage = flag;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> del_timer_sync(&conn->transport_timer);
> iscsi_suspend_tx(conn);
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> conn->c_stage = ISCSI_CONN_STOPPED;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> /*
> * for connection level recovery we should not calculate
> @@ -3124,11 +3096,11 @@ static void iscsi_start_session_recovery(struct iscsi_session *session,
> /*
> * flush queues.
> */
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED);
> fail_mgmt_tasks(session, conn);
> memset(&conn->tmhdr, 0, sizeof(conn->tmhdr));
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
> mutex_unlock(&session->eh_mutex);
> }
>
> @@ -3155,10 +3127,10 @@ int iscsi_conn_bind(struct iscsi_cls_session *cls_session,
> struct iscsi_session *session = cls_session->dd_data;
> struct iscsi_conn *conn = cls_conn->dd_data;
>
> - spin_lock_bh(&session->frwd_lock);
> + spin_lock_bh(&session->lock);
> if (is_leading)
> session->leadconn = conn;
> - spin_unlock_bh(&session->frwd_lock);
> + spin_unlock_bh(&session->lock);
>
> /*
> * Unblock xmitworker(), Login Phase will pass through.
> diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
> index 60cb6dc..2f738dd 100644
> --- a/drivers/scsi/libiscsi_tcp.c
> +++ b/drivers/scsi/libiscsi_tcp.c
> @@ -446,7 +446,7 @@ iscsi_tcp_data_recv_prep(struct iscsi_tcp_conn *tcp_conn)
> * iscsi_tcp_cleanup_task - free tcp_task resources
> * @task: iscsi task
> *
> - * must be called with session back_lock
> + * must be called with session lock
> */
> void iscsi_tcp_cleanup_task(struct iscsi_task *task)
> {
> @@ -457,7 +457,6 @@ void iscsi_tcp_cleanup_task(struct iscsi_task *task)
> if (!task->sc)
> return;
>
> - spin_lock_bh(&tcp_task->queue2pool);
> /* flush task's r2t queues */
> while (kfifo_out(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
> kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
> @@ -471,7 +470,6 @@ void iscsi_tcp_cleanup_task(struct iscsi_task *task)
> sizeof(void*));
> tcp_task->r2t = NULL;
> }
> - spin_unlock_bh(&tcp_task->queue2pool);
> }
> EXPORT_SYMBOL_GPL(iscsi_tcp_cleanup_task);
>
> @@ -579,13 +577,11 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
> return ISCSI_ERR_DATALEN;
> }
>
> - spin_lock(&tcp_task->pool2queue);
> rc = kfifo_out(&tcp_task->r2tpool.queue, (void *)&r2t, sizeof(void *));
> if (!rc) {
> iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
> "Target has sent more R2Ts than it "
> "negotiated for or driver has leaked.\n");
> - spin_unlock(&tcp_task->pool2queue);
> return ISCSI_ERR_PROTO;
> }
>
> @@ -600,7 +596,6 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
> tcp_task->exp_datasn = r2tsn + 1;
> kfifo_in(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
> conn->r2t_pdus_cnt++;
> - spin_unlock(&tcp_task->pool2queue);
>
> iscsi_requeue_task(task);
> return 0;
> @@ -673,14 +668,14 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
>
> switch(opcode) {
> case ISCSI_OP_SCSI_DATA_IN:
> - spin_lock(&conn->session->back_lock);
> + spin_lock(&conn->session->lock);
> task = iscsi_itt_to_ctask(conn, hdr->itt);
> if (!task)
> rc = ISCSI_ERR_BAD_ITT;
> else
> rc = iscsi_tcp_data_in(conn, task);
> if (rc) {
> - spin_unlock(&conn->session->back_lock);
> + spin_unlock(&conn->session->lock);
> break;
> }
>
> @@ -713,11 +708,11 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
> tcp_conn->in.datalen,
> iscsi_tcp_process_data_in,
> rx_hash);
> - spin_unlock(&conn->session->back_lock);
> + spin_unlock(&conn->session->lock);
> return rc;
> }
> rc = __iscsi_complete_pdu(conn, hdr, NULL, 0);
> - spin_unlock(&conn->session->back_lock);
> + spin_unlock(&conn->session->lock);
> break;
> case ISCSI_OP_SCSI_CMD_RSP:
> if (tcp_conn->in.datalen) {
> @@ -727,20 +722,18 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
> rc = iscsi_complete_pdu(conn, hdr, NULL, 0);
> break;
> case ISCSI_OP_R2T:
> - spin_lock(&conn->session->back_lock);
> + spin_lock(&conn->session->lock);
> task = iscsi_itt_to_ctask(conn, hdr->itt);
> - spin_unlock(&conn->session->back_lock);
> if (!task)
> rc = ISCSI_ERR_BAD_ITT;
> else if (ahslen)
> rc = ISCSI_ERR_AHSLEN;
> else if (task->sc->sc_data_direction == DMA_TO_DEVICE) {
> task->last_xfer = jiffies;
> - spin_lock(&conn->session->frwd_lock);
> rc = iscsi_tcp_r2t_rsp(conn, task);
> - spin_unlock(&conn->session->frwd_lock);
> } else
> rc = ISCSI_ERR_PROTO;
> + spin_unlock(&conn->session->lock);
> break;
> case ISCSI_OP_LOGIN_RSP:
> case ISCSI_OP_TEXT_RSP:
> @@ -988,13 +981,14 @@ EXPORT_SYMBOL_GPL(iscsi_tcp_task_init);
>
> static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
> {
> + struct iscsi_session *session = task->conn->session;
> struct iscsi_tcp_task *tcp_task = task->dd_data;
> struct iscsi_r2t_info *r2t = NULL;
>
> if (iscsi_task_has_unsol_data(task))
> r2t = &task->unsol_r2t;
> else {
> - spin_lock_bh(&tcp_task->queue2pool);
> + spin_lock_bh(&session->lock);
> if (tcp_task->r2t) {
> r2t = tcp_task->r2t;
> /* Continue with this R2T? */
> @@ -1016,7 +1010,7 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
> else
> r2t = tcp_task->r2t;
> }
> - spin_unlock_bh(&tcp_task->queue2pool);
> + spin_unlock_bh(&session->lock);
> }
>
> return r2t;
> @@ -1146,8 +1140,6 @@ int iscsi_tcp_r2tpool_alloc(struct iscsi_session *session)
> iscsi_pool_free(&tcp_task->r2tpool);
> goto r2t_alloc_fail;
> }
> - spin_lock_init(&tcp_task->pool2queue);
> - spin_lock_init(&tcp_task->queue2pool);
> }
>
> return 0;
> diff --git a/drivers/scsi/qla4xxx/ql4_isr.c b/drivers/scsi/qla4xxx/ql4_isr.c
> index 4f9c0f2..79b278b 100644
> --- a/drivers/scsi/qla4xxx/ql4_isr.c
> +++ b/drivers/scsi/qla4xxx/ql4_isr.c
> @@ -385,9 +385,9 @@ static void qla4xxx_passthru_status_entry(struct scsi_qla_host *ha,
>
> cls_conn = ddb_entry->conn;
> conn = cls_conn->dd_data;
> - spin_lock(&conn->session->back_lock);
> + spin_lock(&conn->session->lock);
> task = iscsi_itt_to_task(conn, itt);
> - spin_unlock(&conn->session->back_lock);
> + spin_unlock(&conn->session->lock);
>
> if (task == NULL) {
> ql4_printk(KERN_ERR, ha, "%s: Task is NULL\n", __func__);
> diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h
> index 4d1c46a..52d858c 100644
> --- a/include/scsi/libiscsi.h
> +++ b/include/scsi/libiscsi.h
> @@ -331,19 +331,12 @@ struct iscsi_session {
> struct iscsi_transport *tt;
> struct Scsi_Host *host;
> struct iscsi_conn *leadconn; /* leading connection */
> - /* Between the forward and the backward locks exists a strict locking
> - * hierarchy. The mutual exclusion zone protected by the forward lock
> - * can enclose the mutual exclusion zone protected by the backward lock
> - * but not vice versa.
> - */
> - spinlock_t frwd_lock; /* protects session state, *
> - * cmdsn, queued_cmdsn *
> + spinlock_t lock; /* protects session state, *
> + * sequence numbers, *
> * session resources: *
> - * - cmdpool kfifo_out , *
> - * - mgmtpool, */
> - spinlock_t back_lock; /* protects cmdsn_exp *
> - * cmdsn_max, *
> - * cmdpool kfifo_in */
> + * - cmdpool, *
> + * - mgmtpool, *
> + * - r2tpool */
> int state; /* session state */
> int age; /* counts session re-opens */
>
> diff --git a/include/scsi/libiscsi_tcp.h b/include/scsi/libiscsi_tcp.h
> index 2a7aa75..215469a 100644
> --- a/include/scsi/libiscsi_tcp.h
> +++ b/include/scsi/libiscsi_tcp.h
> @@ -83,8 +83,6 @@ struct iscsi_tcp_task {
> struct iscsi_pool r2tpool;
> struct kfifo r2tqueue;
> void *dd_data;
> - spinlock_t pool2queue;
> - spinlock_t queue2pool;
> };
>
> enum {
> --
> 1.9.1
>
>
> --
> kernel-team mailing list
> kernel-team at lists.ubuntu.com
> https://lists.ubuntu.com/mailman/listinfo/kernel-team
Ack
--
Brad Figg brad.figg at canonical.com http://www.canonical.com
More information about the kernel-team
mailing list