block: make queue flags non-atomic

We can save some atomic ops in the IO path, if we clearly define
the rules of how to modify the queue flags.

Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

7 files changed, 29 insertions, 21 deletions

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index f7f163557aa0..d3a25b027ff9 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -546,7 +546,7 @@ static void loop_unplug(struct request_queue *q)
 {
         struct loop_device *lo = q->queuedata;
 
-        clear_bit(QUEUE_FLAG_PLUGGED, &q->queue_flags);
+        queue_flag_clear_unlocked(QUEUE_FLAG_PLUGGED, q);
         blk_run_address_space(lo->lo_backing_file->f_mapping);
 }
 
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 27bfe72aab59..e322cce8c12d 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -2399,7 +2399,7 @@ static void ub_disconnect(struct usb_interface *intf)
                 del_gendisk(lun->disk);
                 /*
                  * I wish I could do:
-                 *    set_bit(QUEUE_FLAG_DEAD, &q->queue_flags);
+                 *    queue_flag_set(QUEUE_FLAG_DEAD, q);
                  * As it is, we rely on our internal poisoning and let
                  * the upper levels to spin furiously failing all the I/O.
                  */
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 51be53344214..73326e7c54bf 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -873,10 +873,13 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q)
         q->max_hw_sectors = t->limits.max_hw_sectors;
         q->seg_boundary_mask = t->limits.seg_boundary_mask;
         q->bounce_pfn = t->limits.bounce_pfn;
+        /* XXX: the below will probably go bug. must ensure there can be no
+         * concurrency on queue_flags, and use the unlocked versions...
+         */
         if (t->limits.no_cluster)
-                q->queue_flags &= ~(1 << QUEUE_FLAG_CLUSTER);
+                queue_flag_clear(QUEUE_FLAG_CLUSTER, q);
         else
-                q->queue_flags |= (1 << QUEUE_FLAG_CLUSTER);
+                queue_flag_set(QUEUE_FLAG_CLUSTER, q);
 
 }
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 87620b705bee..acd716b657b8 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -282,7 +282,8 @@ static mddev_t * mddev_find(dev_t unit)
                 kfree(new);
                 return NULL;
         }
-        set_bit(QUEUE_FLAG_CLUSTER, &new->queue->queue_flags);
+        /* Can be unlocked because the queue is new: no concurrency */
+        queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, new->queue);
 
         blk_queue_make_request(new->queue, md_fail_request);
 
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 07103c399fe0..f6600bfb5bde 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -1773,7 +1773,7 @@ static int scsi_debug_slave_alloc(struct scsi_device *sdp)
         if (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts)
                 printk(KERN_INFO "scsi_debug: slave_alloc <%u %u %u %u>\n",
                        sdp->host->host_no, sdp->channel, sdp->id, sdp->lun);
-        set_bit(QUEUE_FLAG_BIDI, &sdp->request_queue->queue_flags);
+        queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->request_queue);
         return 0;
 }
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 67f412bb4974..d545ad1cf47a 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -536,6 +536,9 @@ static void scsi_run_queue(struct request_queue *q)
                !shost->host_blocked && !shost->host_self_blocked &&
                 !((shost->can_queue > 0) &&
                   (shost->host_busy >= shost->can_queue))) {
+
+                int flagset;
+
                 /*
                  * As long as shost is accepting commands and we have
                  * starved queues, call blk_run_queue. scsi_request_fn
@@ -549,19 +552,20 @@ static void scsi_run_queue(struct request_queue *q)
                 sdev = list_entry(shost->starved_list.next,
                                           struct scsi_device, starved_entry);
                 list_del_init(&sdev->starved_entry);
-                spin_unlock_irqrestore(shost->host_lock, flags);
-
+                spin_unlock(shost->host_lock);
+
+                spin_lock(sdev->request_queue->queue_lock);
+                flagset = test_bit(QUEUE_FLAG_REENTER, &q->queue_flags) &&
+                                !test_bit(QUEUE_FLAG_REENTER,
+                                        &sdev->request_queue->queue_flags);
+                if (flagset)
+                        queue_flag_set(QUEUE_FLAG_REENTER, sdev->request_queue);
+                __blk_run_queue(sdev->request_queue);
+                if (flagset)
+                        queue_flag_clear(QUEUE_FLAG_REENTER, sdev->request_queue);
+                spin_unlock(sdev->request_queue->queue_lock);
 
-                if (test_bit(QUEUE_FLAG_REENTER, &q->queue_flags) &&
-                    !test_and_set_bit(QUEUE_FLAG_REENTER,
-                                      &sdev->request_queue->queue_flags)) {
-                        blk_run_queue(sdev->request_queue);
-                        clear_bit(QUEUE_FLAG_REENTER,
-                                  &sdev->request_queue->queue_flags);
-                } else
-                        blk_run_queue(sdev->request_queue);
-
-                spin_lock_irqsave(shost->host_lock, flags);
+                spin_lock(shost->host_lock);
                 if (unlikely(!list_empty(&sdev->starved_entry)))
                         /*
                          * sdev lost a race, and was put back on the
@@ -1585,8 +1589,9 @@ struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
 
         blk_queue_max_segment_size(q, dma_get_max_seg_size(dev));
 
+        /* New queue, no concurrency on queue_flags */
         if (!shost->use_clustering)
-                clear_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
+                queue_flag_clear_unlocked(QUEUE_FLAG_CLUSTER, q);
 
         /*
          * set a reasonable default alignment on word boundaries: the
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 7899e3dda9bf..f4461d35ffb9 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -248,8 +248,7 @@ static int sas_bsg_initialize(struct Scsi_Host *shost, struct sas_rphy *rphy)
         else
                 q->queuedata = shost;
 
-        set_bit(QUEUE_FLAG_BIDI, &q->queue_flags);
-
+        queue_flag_set_unlocked(QUEUE_FLAG_BIDI, q);
         return 0;
 }