Merge branch 'for-3.15/core' of git://git.kernel.dk/linux-block

Pull core block layer updates from Jens Axboe:
 "This is the pull request for the core block IO bits for the 3.15
  kernel.  It's a smaller round this time, it contains:

   - Various little blk-mq fixes and additions from Christoph and
     myself.

   - Cleanup of the IPI usage from the block layer, and associated
     helper code.  From Frederic Weisbecker and Jan Kara.

   - Duplicate code cleanup in bio-integrity from Gu Zheng.  This will
     give you a merge conflict, but that should be easy to resolve.

   - blk-mq notify spinlock fix for RT from Mike Galbraith.

   - A blktrace partial accounting bug fix from Roman Pen.

   - Missing REQ_SYNC detection fix for blk-mq from Shaohua Li"

* 'for-3.15/core' of git://git.kernel.dk/linux-block: (25 commits)
  blk-mq: add REQ_SYNC early
  rt,blk,mq: Make blk_mq_cpu_notify_lock a raw spinlock
  blk-mq: support partial I/O completions
  blk-mq: merge blk_mq_insert_request and blk_mq_run_request
  blk-mq: remove blk_mq_alloc_rq
  blk-mq: don't dump CPU -> hw queue map on driver load
  blk-mq: fix wrong usage of hctx->state vs hctx->flags
  blk-mq: allow blk_mq_init_commands() to return failure
  block: remove old blk_iopoll_enabled variable
  blktrace: fix accounting of partially completed requests
  smp: Rename __smp_call_function_single() to smp_call_function_single_async()
  smp: Remove wait argument from __smp_call_function_single()
  watchdog: Simplify a little the IPI call
  smp: Move __smp_call_function_single() below its safe version
  smp: Consolidate the various smp_call_function_single() declensions
  smp: Teach __smp_call_function_single() to check for offline cpus
  smp: Remove unused list_head from csd
  smp: Iterate functions through llist_for_each_entry_safe()
  block: Stop abusing rq->csd.list in blk-softirq
  block: Remove useless IPI struct initialization
  ...

1 files changed, 63 insertions, 143 deletions

diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 9be818f7b26d..0d822297aa80 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -898,7 +898,6 @@ static irqreturn_t be_isr_msix(int irq, void *dev_id)
         struct be_queue_info *cq;
         unsigned int num_eq_processed;
         struct be_eq_obj *pbe_eq;
-        unsigned long flags;
 
         pbe_eq = dev_id;
         eq = &pbe_eq->q;
@@ -907,31 +906,15 @@ static irqreturn_t be_isr_msix(int irq, void *dev_id)
 
         phba = pbe_eq->phba;
         num_eq_processed = 0;
-        if (blk_iopoll_enabled) {
-                while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
-                                        & EQE_VALID_MASK) {
-                        if (!blk_iopoll_sched_prep(&pbe_eq->iopoll))
-                                blk_iopoll_sched(&pbe_eq->iopoll);
-
-                        AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
-                        queue_tail_inc(eq);
-                        eqe = queue_tail_node(eq);
-                        num_eq_processed++;
-                }
-        } else {
-                while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
-                                                & EQE_VALID_MASK) {
-                        spin_lock_irqsave(&phba->isr_lock, flags);
-                        pbe_eq->todo_cq = true;
-                        spin_unlock_irqrestore(&phba->isr_lock, flags);
-                        AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
-                        queue_tail_inc(eq);
-                        eqe = queue_tail_node(eq);
-                        num_eq_processed++;
-                }
+        while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
+                                & EQE_VALID_MASK) {
+                if (!blk_iopoll_sched_prep(&pbe_eq->iopoll))
+                        blk_iopoll_sched(&pbe_eq->iopoll);
 
-                if (pbe_eq->todo_cq)
-                        queue_work(phba->wq, &pbe_eq->work_cqs);
+                AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
+                queue_tail_inc(eq);
+                eqe = queue_tail_node(eq);
+                num_eq_processed++;
         }
 
         if (num_eq_processed)
@@ -952,7 +935,6 @@ static irqreturn_t be_isr(int irq, void *dev_id)
         struct hwi_context_memory *phwi_context;
         struct be_eq_entry *eqe = NULL;
         struct be_queue_info *eq;
-        struct be_queue_info *cq;
         struct be_queue_info *mcc;
         unsigned long flags, index;
         unsigned int num_mcceq_processed, num_ioeq_processed;
@@ -978,72 +960,40 @@ static irqreturn_t be_isr(int irq, void *dev_id)
 
         num_ioeq_processed = 0;
         num_mcceq_processed = 0;
-        if (blk_iopoll_enabled) {
-                while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
-                                        & EQE_VALID_MASK) {
-                        if (((eqe->dw[offsetof(struct amap_eq_entry,
-                             resource_id) / 32] &
-                             EQE_RESID_MASK) >> 16) == mcc->id) {
-                                spin_lock_irqsave(&phba->isr_lock, flags);
-                                pbe_eq->todo_mcc_cq = true;
-                                spin_unlock_irqrestore(&phba->isr_lock, flags);
-                                num_mcceq_processed++;
-                        } else {
-                                if (!blk_iopoll_sched_prep(&pbe_eq->iopoll))
-                                        blk_iopoll_sched(&pbe_eq->iopoll);
-                                num_ioeq_processed++;
-                        }
-                        AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
-                        queue_tail_inc(eq);
-                        eqe = queue_tail_node(eq);
-                }
-                if (num_ioeq_processed || num_mcceq_processed) {
-                        if (pbe_eq->todo_mcc_cq)
-                                queue_work(phba->wq, &pbe_eq->work_cqs);
-
-                        if ((num_mcceq_processed) && (!num_ioeq_processed))
-                                hwi_ring_eq_db(phba, eq->id, 0,
-                                              (num_ioeq_processed +
-                                               num_mcceq_processed) , 1, 1);
-                        else
-                                hwi_ring_eq_db(phba, eq->id, 0,
-                                               (num_ioeq_processed +
-                                                num_mcceq_processed), 0, 1);
-
-                        return IRQ_HANDLED;
-                } else
-                        return IRQ_NONE;
-        } else {
-                cq = &phwi_context->be_cq[0];
-                while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
-                                                & EQE_VALID_MASK) {
-
-                        if (((eqe->dw[offsetof(struct amap_eq_entry,
-                             resource_id) / 32] &
-                             EQE_RESID_MASK) >> 16) != cq->id) {
-                                spin_lock_irqsave(&phba->isr_lock, flags);
-                                pbe_eq->todo_mcc_cq = true;
-                                spin_unlock_irqrestore(&phba->isr_lock, flags);
-                        } else {
-                                spin_lock_irqsave(&phba->isr_lock, flags);
-                                pbe_eq->todo_cq = true;
-                                spin_unlock_irqrestore(&phba->isr_lock, flags);
-                        }
-                        AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
-                        queue_tail_inc(eq);
-                        eqe = queue_tail_node(eq);
+        while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
+                                & EQE_VALID_MASK) {
+                if (((eqe->dw[offsetof(struct amap_eq_entry,
+                     resource_id) / 32] &
+                     EQE_RESID_MASK) >> 16) == mcc->id) {
+                        spin_lock_irqsave(&phba->isr_lock, flags);
+                        pbe_eq->todo_mcc_cq = true;
+                        spin_unlock_irqrestore(&phba->isr_lock, flags);
+                        num_mcceq_processed++;
+                } else {
+                        if (!blk_iopoll_sched_prep(&pbe_eq->iopoll))
+                                blk_iopoll_sched(&pbe_eq->iopoll);
                         num_ioeq_processed++;
                 }
-                if (pbe_eq->todo_cq || pbe_eq->todo_mcc_cq)
+                AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
+                queue_tail_inc(eq);
+                eqe = queue_tail_node(eq);
+        }
+        if (num_ioeq_processed || num_mcceq_processed) {
+                if (pbe_eq->todo_mcc_cq)
                         queue_work(phba->wq, &pbe_eq->work_cqs);
 
-                if (num_ioeq_processed) {
+                if ((num_mcceq_processed) && (!num_ioeq_processed))
                         hwi_ring_eq_db(phba, eq->id, 0,
-                                       num_ioeq_processed, 1, 1);
-                        return IRQ_HANDLED;
-                } else
-                        return IRQ_NONE;
-        }
+                                      (num_ioeq_processed +
+                                       num_mcceq_processed) , 1, 1);
+                else
+                        hwi_ring_eq_db(phba, eq->id, 0,
+                                       (num_ioeq_processed +
+                                        num_mcceq_processed), 0, 1);
+
+                return IRQ_HANDLED;
+        } else
+                return IRQ_NONE;
 }
 
 static int beiscsi_init_irqs(struct beiscsi_hba *phba)
@@ -5263,11 +5213,10 @@ static void beiscsi_quiesce(struct beiscsi_hba *phba,
                 }
         pci_disable_msix(phba->pcidev);
 
-        if (blk_iopoll_enabled)
-                for (i = 0; i < phba->num_cpus; i++) {
-                        pbe_eq = &phwi_context->be_eq[i];
-                        blk_iopoll_disable(&pbe_eq->iopoll);
-                }
+        for (i = 0; i < phba->num_cpus; i++) {
+                pbe_eq = &phwi_context->be_eq[i];
+                blk_iopoll_disable(&pbe_eq->iopoll);
+        }
 
         if (unload_state == BEISCSI_CLEAN_UNLOAD) {
                 destroy_workqueue(phba->wq);
@@ -5478,32 +5427,18 @@ static void beiscsi_eeh_resume(struct pci_dev *pdev)
         phwi_ctrlr = phba->phwi_ctrlr;
         phwi_context = phwi_ctrlr->phwi_ctxt;
 
-        if (blk_iopoll_enabled) {
-                for (i = 0; i < phba->num_cpus; i++) {
-                        pbe_eq = &phwi_context->be_eq[i];
-                        blk_iopoll_init(&pbe_eq->iopoll, be_iopoll_budget,
-                                        be_iopoll);
-                        blk_iopoll_enable(&pbe_eq->iopoll);
-                }
-
-                i = (phba->msix_enabled) ? i : 0;
-                /* Work item for MCC handling */
+        for (i = 0; i < phba->num_cpus; i++) {
                 pbe_eq = &phwi_context->be_eq[i];
-                INIT_WORK(&pbe_eq->work_cqs, beiscsi_process_all_cqs);
-        } else {
-                if (phba->msix_enabled) {
-                        for (i = 0; i <= phba->num_cpus; i++) {
-                                pbe_eq = &phwi_context->be_eq[i];
-                                INIT_WORK(&pbe_eq->work_cqs,
-                                          beiscsi_process_all_cqs);
-                        }
-                } else {
-                        pbe_eq = &phwi_context->be_eq[0];
-                        INIT_WORK(&pbe_eq->work_cqs,
-                                  beiscsi_process_all_cqs);
-                }
+                blk_iopoll_init(&pbe_eq->iopoll, be_iopoll_budget,
+                                be_iopoll);
+                blk_iopoll_enable(&pbe_eq->iopoll);
         }
 
+        i = (phba->msix_enabled) ? i : 0;
+        /* Work item for MCC handling */
+        pbe_eq = &phwi_context->be_eq[i];
+        INIT_WORK(&pbe_eq->work_cqs, beiscsi_process_all_cqs);
+
         ret = beiscsi_init_irqs(phba);
         if (ret < 0) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
@@ -5665,32 +5600,18 @@ static int beiscsi_dev_probe(struct pci_dev *pcidev,
         phwi_ctrlr = phba->phwi_ctrlr;
         phwi_context = phwi_ctrlr->phwi_ctxt;
 
-        if (blk_iopoll_enabled) {
-                for (i = 0; i < phba->num_cpus; i++) {
-                        pbe_eq = &phwi_context->be_eq[i];
-                        blk_iopoll_init(&pbe_eq->iopoll, be_iopoll_budget,
-                                        be_iopoll);
-                        blk_iopoll_enable(&pbe_eq->iopoll);
-                }
-
-                i = (phba->msix_enabled) ? i : 0;
-                /* Work item for MCC handling */
+        for (i = 0; i < phba->num_cpus; i++) {
                 pbe_eq = &phwi_context->be_eq[i];
-                INIT_WORK(&pbe_eq->work_cqs, beiscsi_process_all_cqs);
-        } else {
-                if (phba->msix_enabled) {
-                        for (i = 0; i <= phba->num_cpus; i++) {
-                                pbe_eq = &phwi_context->be_eq[i];
-                                INIT_WORK(&pbe_eq->work_cqs,
-                                          beiscsi_process_all_cqs);
-                        }
-                } else {
-                                pbe_eq = &phwi_context->be_eq[0];
-                                INIT_WORK(&pbe_eq->work_cqs,
-                                          beiscsi_process_all_cqs);
-                        }
+                blk_iopoll_init(&pbe_eq->iopoll, be_iopoll_budget,
+                                be_iopoll);
+                blk_iopoll_enable(&pbe_eq->iopoll);
         }
 
+        i = (phba->msix_enabled) ? i : 0;
+        /* Work item for MCC handling */
+        pbe_eq = &phwi_context->be_eq[i];
+        INIT_WORK(&pbe_eq->work_cqs, beiscsi_process_all_cqs);
+
         ret = beiscsi_init_irqs(phba);
         if (ret < 0) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
@@ -5719,11 +5640,10 @@ static int beiscsi_dev_probe(struct pci_dev *pcidev,
 
 free_blkenbld:
         destroy_workqueue(phba->wq);
-        if (blk_iopoll_enabled)
-                for (i = 0; i < phba->num_cpus; i++) {
-                        pbe_eq = &phwi_context->be_eq[i];
-                        blk_iopoll_disable(&pbe_eq->iopoll);
-                }
+        for (i = 0; i < phba->num_cpus; i++) {
+                pbe_eq = &phwi_context->be_eq[i];
+                blk_iopoll_disable(&pbe_eq->iopoll);
+        }
 free_twq:
         beiscsi_clean_port(phba);
         beiscsi_free_mem(phba);