1 files changed, 47 insertions, 22 deletions

diff --git a/drivers/s390/block/scm_blk_cluster.c b/drivers/s390/block/scm_blk_cluster.c
index 9aae909d47a5..09db45296eed 100644
--- a/drivers/s390/block/scm_blk_cluster.c
+++ b/drivers/s390/block/scm_blk_cluster.c
@@ -57,39 +57,52 @@ void scm_request_cluster_init(struct scm_request *scmrq)
         scmrq->cluster.state = CLUSTER_NONE;
 }
 
-static bool clusters_intersect(struct scm_request *A, struct scm_request *B)
+static bool clusters_intersect(struct request *A, struct request *B)
 {
         unsigned long firstA, lastA, firstB, lastB;
 
-        firstA = ((u64) blk_rq_pos(A->request) << 9) / CLUSTER_SIZE;
-        lastA = (((u64) blk_rq_pos(A->request) << 9) +
-                    blk_rq_bytes(A->request) - 1) / CLUSTER_SIZE;
+        firstA = ((u64) blk_rq_pos(A) << 9) / CLUSTER_SIZE;
+        lastA = (((u64) blk_rq_pos(A) << 9) +
+                    blk_rq_bytes(A) - 1) / CLUSTER_SIZE;
 
-        firstB = ((u64) blk_rq_pos(B->request) << 9) / CLUSTER_SIZE;
-        lastB = (((u64) blk_rq_pos(B->request) << 9) +
-                    blk_rq_bytes(B->request) - 1) / CLUSTER_SIZE;
+        firstB = ((u64) blk_rq_pos(B) << 9) / CLUSTER_SIZE;
+        lastB = (((u64) blk_rq_pos(B) << 9) +
+                    blk_rq_bytes(B) - 1) / CLUSTER_SIZE;
 
         return (firstB <= lastA && firstA <= lastB);
 }
 
 bool scm_reserve_cluster(struct scm_request *scmrq)
 {
+        struct request *req = scmrq->request[scmrq->aob->request.msb_count];
         struct scm_blk_dev *bdev = scmrq->bdev;
         struct scm_request *iter;
+        int pos, add = 1;
 
         if (write_cluster_size == 0)
                 return true;
 
         spin_lock(&bdev->lock);
         list_for_each_entry(iter, &bdev->cluster_list, cluster.list) {
-                if (clusters_intersect(scmrq, iter) &&
-                    (rq_data_dir(scmrq->request) == WRITE ||
-                     rq_data_dir(iter->request) == WRITE)) {
-                        spin_unlock(&bdev->lock);
-                        return false;
+                if (iter == scmrq) {
+                        /*
+                         * We don't have to use clusters_intersect here, since
+                         * cluster requests are always started separately.
+                         */
+                        add = 0;
+                        continue;
+                }
+                for (pos = 0; pos <= iter->aob->request.msb_count; pos++) {
+                        if (clusters_intersect(req, iter->request[pos]) &&
+                            (rq_data_dir(req) == WRITE ||
+                             rq_data_dir(iter->request[pos]) == WRITE)) {
+                                spin_unlock(&bdev->lock);
+                                return false;
+                        }
                 }
         }
-        list_add(&scmrq->cluster.list, &bdev->cluster_list);
+        if (add)
+                list_add(&scmrq->cluster.list, &bdev->cluster_list);
         spin_unlock(&bdev->lock);
 
         return true;
@@ -114,14 +127,14 @@ void scm_blk_dev_cluster_setup(struct scm_blk_dev *bdev)
         blk_queue_io_opt(bdev->rq, CLUSTER_SIZE);
 }
 
-static void scm_prepare_cluster_request(struct scm_request *scmrq)
+static int scm_prepare_cluster_request(struct scm_request *scmrq)
 {
         struct scm_blk_dev *bdev = scmrq->bdev;
         struct scm_device *scmdev = bdev->gendisk->private_data;
-        struct request *req = scmrq->request;
-        struct aidaw *aidaw = scmrq->aidaw;
+        struct request *req = scmrq->request[0];
         struct msb *msb = &scmrq->aob->msb[0];
         struct req_iterator iter;
+        struct aidaw *aidaw;
         struct bio_vec bv;
         int i = 0;
         u64 addr;
@@ -131,11 +144,9 @@ static void scm_prepare_cluster_request(struct scm_request *scmrq)
                 scmrq->cluster.state = CLUSTER_READ;
                 /* fall through */
         case CLUSTER_READ:
-                scmrq->aob->request.msb_count = 1;
                 msb->bs = MSB_BS_4K;
                 msb->oc = MSB_OC_READ;
                 msb->flags = MSB_FLAG_IDA;
-                msb->data_addr = (u64) aidaw;
                 msb->blk_count = write_cluster_size;
 
                 addr = scmdev->address + ((u64) blk_rq_pos(req) << 9);
@@ -146,6 +157,12 @@ static void scm_prepare_cluster_request(struct scm_request *scmrq)
                                CLUSTER_SIZE))
                         msb->blk_count = 2 * write_cluster_size;
 
+                aidaw = scm_aidaw_fetch(scmrq, msb->blk_count * PAGE_SIZE);
+                if (!aidaw)
+                        return -ENOMEM;
+
+                scmrq->aob->request.msb_count = 1;
+                msb->data_addr = (u64) aidaw;
                 for (i = 0; i < msb->blk_count; i++) {
                         aidaw->data_addr = (u64) scmrq->cluster.buf[i];
                         aidaw++;
@@ -153,6 +170,7 @@ static void scm_prepare_cluster_request(struct scm_request *scmrq)
 
                 break;
         case CLUSTER_WRITE:
+                aidaw = (void *) msb->data_addr;
                 msb->oc = MSB_OC_WRITE;
 
                 for (addr = msb->scm_addr;
@@ -173,22 +191,29 @@ static void scm_prepare_cluster_request(struct scm_request *scmrq)
                 }
                 break;
         }
+        return 0;
 }
 
 bool scm_need_cluster_request(struct scm_request *scmrq)
 {
-        if (rq_data_dir(scmrq->request) == READ)
+        int pos = scmrq->aob->request.msb_count;
+
+        if (rq_data_dir(scmrq->request[pos]) == READ)
                 return false;
 
-        return blk_rq_bytes(scmrq->request) < CLUSTER_SIZE;
+        return blk_rq_bytes(scmrq->request[pos]) < CLUSTER_SIZE;
 }
 
 /* Called with queue lock held. */
 void scm_initiate_cluster_request(struct scm_request *scmrq)
 {
-        scm_prepare_cluster_request(scmrq);
+        if (scm_prepare_cluster_request(scmrq))
+                goto requeue;
         if (eadm_start_aob(scmrq->aob))
-                scm_request_requeue(scmrq);
+                goto requeue;
+        return;
+requeue:
+        scm_request_requeue(scmrq);
 }
 
 bool scm_test_cluster_request(struct scm_request *scmrq)