[SCSI] libiscsi: Reduce locking contention in fast path

Replace the session lock with two locks, a forward lock and
a backwards lock named frwd_lock and back_lock respectively.

The forward lock protects resources that change while sending a
request to the target, such as cmdsn, queued_cmdsn, and allocating
task from the commands' pool with kfifo_out.

The backward lock protects resources that change while processing
a response or in error path, such as cmdsn_exp, cmdsn_max, and
returning tasks to the commands' pool with kfifo_in.

Under a steady state fast-path situation, that is when one
or more processes/threads submit IO to an iscsi device and
a single kernel upcall (e.g softirq) is dealing with processing
of responses without errors, this patch eliminates the contention
between the queuecommand()/request response/scsi_done() flows
associated with iscsi sessions.

Between the forward and the backward locks exists a strict locking
hierarchy. The mutual exclusion zone protected by the forward lock can
enclose the mutual exclusion zone protected by the backward lock but not
vice versa.

For example, in iscsi_conn_teardown or in iscsi_xmit_data when there is
a failure and __iscsi_put_task is called, the backward lock is taken while
the forward lock is still taken. On the other hand, if in the RX path a nop
is to be sent, for example in iscsi_handle_reject or __iscsi_complete_pdu
than the forward lock is released and the backward lock is taken for the
duration of iscsi_send_nopout, later the backward lock is released and the
forward lock is retaken.

libiscsi_tcp uses two kernel fifos the r2t pool and the r2t queue.

The insertion and deletion from these queues didn't corespond to the
assumption taken by the new forward/backwards session locking paradigm.

That is, in iscsi_tcp_clenup_task which belongs to the RX (backwards)
path, r2t is taken out from r2t queue and inserted to the r2t pool.
In iscsi_tcp_get_curr_r2t which belong to the TX (forward) path, r2t
is also inserted to the r2t pool and another r2t is pulled from r2t
queue.

Only in iscsi_tcp_r2t_rsp which is called in the RX path but can requeue
to the TX path, r2t is taken from the r2t pool and inserted to the r2t
queue.

In order to cope with this situation, two spin locks were added,
pool2queue and queue2pool. The former protects extracting from the
r2t pool and inserting to the r2t queue, and the later protects the
extracing from the r2t queue and inserting to the r2t pool.

Signed-off-by: Shlomo Pongratz <shlomop@mellanox.com>
Signed-off-by: Or Gerlitz <ogerlitz@mellanox.com>
[minor fix up to apply cleanly and compile fix]
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

1 files changed, 18 insertions, 10 deletions

diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
index 2f738dddd078..60cb6dc3c6f0 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 lock
+ * must be called with session back_lock
  */
 void iscsi_tcp_cleanup_task(struct iscsi_task *task)
 {
@@ -457,6 +457,7 @@ 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,
@@ -470,6 +471,7 @@ 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);
 
@@ -577,11 +579,13 @@ 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;
         }
 
@@ -596,6 +600,7 @@ 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;
@@ -668,14 +673,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->lock);
+                spin_lock(&conn->session->back_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->lock);
+                        spin_unlock(&conn->session->back_lock);
                         break;
                 }
 
@@ -708,11 +713,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->lock);
+                        spin_unlock(&conn->session->back_lock);
                         return rc;
                 }
                 rc = __iscsi_complete_pdu(conn, hdr, NULL, 0);
-                spin_unlock(&conn->session->lock);
+                spin_unlock(&conn->session->back_lock);
                 break;
         case ISCSI_OP_SCSI_CMD_RSP:
                 if (tcp_conn->in.datalen) {
@@ -722,18 +727,20 @@ 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->lock);
+                spin_lock(&conn->session->back_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:
@@ -981,14 +988,13 @@ 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(&session->lock);
+                spin_lock_bh(&tcp_task->queue2pool);
                 if (tcp_task->r2t) {
                         r2t = tcp_task->r2t;
                         /* Continue with this R2T? */
@@ -1010,7 +1016,7 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
                         else
                                 r2t = tcp_task->r2t;
                 }
-                spin_unlock_bh(&session->lock);
+                spin_unlock_bh(&tcp_task->queue2pool);
         }
 
         return r2t;
@@ -1140,6 +1146,8 @@ 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;