block: Use blk_queue_flag_*() in drivers instead of queue_flag_*()

This patch has been generated as follows:

for verb in set_unlocked clear_unlocked set clear; do
  replace-in-files queue_flag_${verb} blk_queue_flag_${verb%_unlocked} \
    $(git grep -lw queue_flag_${verb} drivers block/bsg*)
done

Except for protecting all queue flag changes with the queue lock
this patch does not change any functionality.

Cc: Mike Snitzer <snitzer@redhat.com>
Cc: Shaohua Li <shli@fb.com>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Hannes Reinecke <hare@suse.de>
Cc: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Bart Van Assche <bart.vanassche@wdc.com>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de>
Acked-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

7 files changed, 22 insertions, 22 deletions

diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 5fe7ec356c33..54c39ad4ef01 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1861,7 +1861,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
         q->limits = *limits;
 
         if (!dm_table_supports_discards(t)) {
-                queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
+                blk_queue_flag_clear(QUEUE_FLAG_DISCARD, q);
                 /* Must also clear discard limits... */
                 q->limits.max_discard_sectors = 0;
                 q->limits.max_hw_discard_sectors = 0;
@@ -1869,7 +1869,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
                 q->limits.discard_alignment = 0;
                 q->limits.discard_misaligned = 0;
         } else
-                queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
+                blk_queue_flag_set(QUEUE_FLAG_DISCARD, q);
 
         if (dm_table_supports_flush(t, (1UL << QUEUE_FLAG_WC))) {
                 wc = true;
@@ -1879,15 +1879,15 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
         blk_queue_write_cache(q, wc, fua);
 
         if (dm_table_supports_dax(t))
-                queue_flag_set_unlocked(QUEUE_FLAG_DAX, q);
+                blk_queue_flag_set(QUEUE_FLAG_DAX, q);
         if (dm_table_supports_dax_write_cache(t))
                 dax_write_cache(t->md->dax_dev, true);
 
         /* Ensure that all underlying devices are non-rotational. */
         if (dm_table_all_devices_attribute(t, device_is_nonrot))
-                queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q);
+                blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
         else
-                queue_flag_clear_unlocked(QUEUE_FLAG_NONROT, q);
+                blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
 
         if (!dm_table_supports_write_same(t))
                 q->limits.max_write_same_sectors = 0;
@@ -1895,9 +1895,9 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
                 q->limits.max_write_zeroes_sectors = 0;
 
         if (dm_table_all_devices_attribute(t, queue_supports_sg_merge))
-                queue_flag_clear_unlocked(QUEUE_FLAG_NO_SG_MERGE, q);
+                blk_queue_flag_clear(QUEUE_FLAG_NO_SG_MERGE, q);
         else
-                queue_flag_set_unlocked(QUEUE_FLAG_NO_SG_MERGE, q);
+                blk_queue_flag_set(QUEUE_FLAG_NO_SG_MERGE, q);
 
         dm_table_verify_integrity(t);
 
@@ -1908,7 +1908,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
          * have it set.
          */
         if (blk_queue_add_random(q) && dm_table_all_devices_attribute(t, device_is_not_random))
-                queue_flag_clear_unlocked(QUEUE_FLAG_ADD_RANDOM, q);
+                blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, q);
 }
 
 unsigned int dm_table_get_num_targets(struct dm_table *t)
diff --git a/drivers/md/md-linear.c b/drivers/md/md-linear.c
index 773fc70dced7..4964323d936b 100644
--- a/drivers/md/md-linear.c
+++ b/drivers/md/md-linear.c
@@ -138,9 +138,9 @@ static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)
         }
 
         if (!discard_supported)
-                queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
+                blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue);
         else
-                queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
+                blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
 
         /*
          * Here we calculate the device offsets.
diff --git a/drivers/md/md.c b/drivers/md/md.c
index eba7fa2f0abb..de2b26fba5d8 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -5608,9 +5608,9 @@ int md_run(struct mddev *mddev)
                 if (mddev->degraded)
                         nonrot = false;
                 if (nonrot)
-                        queue_flag_set_unlocked(QUEUE_FLAG_NONROT, mddev->queue);
+                        blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
                 else
-                        queue_flag_clear_unlocked(QUEUE_FLAG_NONROT, mddev->queue);
+                        blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
                 mddev->queue->backing_dev_info->congested_data = mddev;
                 mddev->queue->backing_dev_info->congested_fn = md_congested;
         }
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 5ecba9eef441..584c10347267 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -399,9 +399,9 @@ static int raid0_run(struct mddev *mddev)
                                 discard_supported = true;
                 }
                 if (!discard_supported)
-                        queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
+                        blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue);
                 else
-                        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
+                        blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
         }
 
         /* calculate array device size */
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index b2eae332e1a2..f1635eb9e95a 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1760,7 +1760,7 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
                 }
         }
         if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev)))
-                queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
+                blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
         print_conf(conf);
         return err;
 }
@@ -3099,10 +3099,10 @@ static int raid1_run(struct mddev *mddev)
 
         if (mddev->queue) {
                 if (discard_supported)
-                        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
+                        blk_queue_flag_set(QUEUE_FLAG_DISCARD,
                                                 mddev->queue);
                 else
-                        queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD,
+                        blk_queue_flag_clear(QUEUE_FLAG_DISCARD,
                                                   mddev->queue);
         }
 
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 99c9207899a7..e9c409c5f344 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1845,7 +1845,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
                 break;
         }
         if (mddev->queue && blk_queue_discard(bdev_get_queue(rdev->bdev)))
-                queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
+                blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
 
         print_conf(conf);
         return err;
@@ -3844,10 +3844,10 @@ static int raid10_run(struct mddev *mddev)
 
         if (mddev->queue) {
                 if (discard_supported)
-                        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
+                        blk_queue_flag_set(QUEUE_FLAG_DISCARD,
                                                 mddev->queue);
                 else
-                        queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD,
+                        blk_queue_flag_clear(QUEUE_FLAG_DISCARD,
                                                   mddev->queue);
         }
         /* need to check that every block has at least one working mirror */
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 50d01144b805..14714b23a2fa 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -7444,10 +7444,10 @@ static int raid5_run(struct mddev *mddev)
                 if (devices_handle_discard_safely &&
                     mddev->queue->limits.max_discard_sectors >= (stripe >> 9) &&
                     mddev->queue->limits.discard_granularity >= stripe)
-                        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD,
+                        blk_queue_flag_set(QUEUE_FLAG_DISCARD,
                                                 mddev->queue);
                 else
-                        queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD,
+                        blk_queue_flag_clear(QUEUE_FLAG_DISCARD,
                                                 mddev->queue);
 
                 blk_queue_max_hw_sectors(mddev->queue, UINT_MAX);