2 files changed, 84 insertions, 52 deletions

diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
index 77ba96553b27..80dfe173deac 100644
--- a/drivers/infiniband/ulp/srp/ib_srp.c
+++ b/drivers/infiniband/ulp/srp/ib_srp.c
@@ -293,12 +293,31 @@ static int srp_new_cm_id(struct srp_target_port *target)
         return 0;
 }
 
+static struct ib_fmr_pool *srp_alloc_fmr_pool(struct srp_target_port *target)
+{
+        struct srp_device *dev = target->srp_host->srp_dev;
+        struct ib_fmr_pool_param fmr_param;
+
+        memset(&fmr_param, 0, sizeof(fmr_param));
+        fmr_param.pool_size         = target->scsi_host->can_queue;
+        fmr_param.dirty_watermark   = fmr_param.pool_size / 4;
+        fmr_param.cache             = 1;
+        fmr_param.max_pages_per_fmr = dev->max_pages_per_fmr;
+        fmr_param.page_shift        = ilog2(dev->fmr_page_size);
+        fmr_param.access            = (IB_ACCESS_LOCAL_WRITE |
+                                       IB_ACCESS_REMOTE_WRITE |
+                                       IB_ACCESS_REMOTE_READ);
+
+        return ib_create_fmr_pool(dev->pd, &fmr_param);
+}
+
 static int srp_create_target_ib(struct srp_target_port *target)
 {
         struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_qp_init_attr *init_attr;
         struct ib_cq *recv_cq, *send_cq;
         struct ib_qp *qp;
+        struct ib_fmr_pool *fmr_pool = NULL;
         int ret;
 
         init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL);
@@ -341,6 +360,19 @@ static int srp_create_target_ib(struct srp_target_port *target)
         if (ret)
                 goto err_qp;
 
+        if (dev->has_fmr) {
+                fmr_pool = srp_alloc_fmr_pool(target);
+                if (IS_ERR(fmr_pool)) {
+                        ret = PTR_ERR(fmr_pool);
+                        shost_printk(KERN_WARNING, target->scsi_host, PFX
+                                     "FMR pool allocation failed (%d)\n", ret);
+                        goto err_qp;
+                }
+                if (target->fmr_pool)
+                        ib_destroy_fmr_pool(target->fmr_pool);
+                target->fmr_pool = fmr_pool;
+        }
+
         if (target->qp)
                 ib_destroy_qp(target->qp);
         if (target->recv_cq)
@@ -377,6 +409,8 @@ static void srp_free_target_ib(struct srp_target_port *target)
 {
         int i;
 
+        if (target->fmr_pool)
+                ib_destroy_fmr_pool(target->fmr_pool);
         ib_destroy_qp(target->qp);
         ib_destroy_cq(target->send_cq);
         ib_destroy_cq(target->recv_cq);
@@ -623,8 +657,8 @@ static int srp_alloc_req_data(struct srp_target_port *target)
                 req = &target->req_ring[i];
                 req->fmr_list = kmalloc(target->cmd_sg_cnt * sizeof(void *),
                                         GFP_KERNEL);
-                req->map_page = kmalloc(SRP_FMR_SIZE * sizeof(void *),
-                                        GFP_KERNEL);
+                req->map_page = kmalloc(srp_dev->max_pages_per_fmr *
+                                        sizeof(void *), GFP_KERNEL);
                 req->indirect_desc = kmalloc(target->indirect_size, GFP_KERNEL);
                 if (!req->fmr_list || !req->map_page || !req->indirect_desc)
                         goto out;
@@ -936,11 +970,10 @@ static void srp_map_desc(struct srp_map_state *state, dma_addr_t dma_addr,
 static int srp_map_finish_fmr(struct srp_map_state *state,
                               struct srp_target_port *target)
 {
-        struct srp_device *dev = target->srp_host->srp_dev;
         struct ib_pool_fmr *fmr;
         u64 io_addr = 0;
 
-        fmr = ib_fmr_pool_map_phys(dev->fmr_pool, state->pages,
+        fmr = ib_fmr_pool_map_phys(target->fmr_pool, state->pages,
                                    state->npages, io_addr);
         if (IS_ERR(fmr))
                 return PTR_ERR(fmr);
@@ -1033,7 +1066,7 @@ static int srp_map_sg_entry(struct srp_map_state *state,
                 srp_map_update_start(state, sg, sg_index, dma_addr);
 
         while (dma_len) {
-                if (state->npages == SRP_FMR_SIZE) {
+                if (state->npages == dev->max_pages_per_fmr) {
                         ret = srp_finish_mapping(state, target);
                         if (ret)
                                 return ret;
@@ -1077,7 +1110,7 @@ static void srp_map_fmr(struct srp_map_state *state,
         state->pages    = req->map_page;
         state->next_fmr = req->fmr_list;
 
-        use_fmr = dev->fmr_pool ? SRP_MAP_ALLOW_FMR : SRP_MAP_NO_FMR;
+        use_fmr = target->fmr_pool ? SRP_MAP_ALLOW_FMR : SRP_MAP_NO_FMR;
 
         for_each_sg(scat, sg, count, i) {
                 if (srp_map_sg_entry(state, target, sg, i, use_fmr)) {
@@ -1555,7 +1588,7 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         struct srp_cmd *cmd;
         struct ib_device *dev;
         unsigned long flags;
-        int len, result;
+        int len, ret;
         const bool in_scsi_eh = !in_interrupt() && current == shost->ehandler;
 
         /*
@@ -1567,12 +1600,9 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         if (in_scsi_eh)
                 mutex_lock(&rport->mutex);
 
-        result = srp_chkready(target->rport);
-        if (unlikely(result)) {
-                scmnd->result = result;
-                scmnd->scsi_done(scmnd);
-                goto unlock_rport;
-        }
+        scmnd->result = srp_chkready(target->rport);
+        if (unlikely(scmnd->result))
+                goto err;
 
         spin_lock_irqsave(&target->lock, flags);
         iu = __srp_get_tx_iu(target, SRP_IU_CMD);
@@ -1587,7 +1617,6 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_iu_len,
                                    DMA_TO_DEVICE);
 
-        scmnd->result        = 0;
         scmnd->host_scribble = (void *) req;
 
         cmd = iu->buf;
@@ -1604,7 +1633,15 @@ static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
         len = srp_map_data(scmnd, target, req);
         if (len < 0) {
                 shost_printk(KERN_ERR, target->scsi_host,
-                             PFX "Failed to map data\n");
+                             PFX "Failed to map data (%d)\n", len);
+                /*
+                 * If we ran out of memory descriptors (-ENOMEM) because an
+                 * application is queuing many requests with more than
+                 * max_pages_per_fmr sg-list elements, tell the SCSI mid-layer
+                 * to reduce queue depth temporarily.
+                 */
+                scmnd->result = len == -ENOMEM ?
+                        DID_OK << 16 | QUEUE_FULL << 1 : DID_ERROR << 16;
                 goto err_iu;
         }