Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

[platform/kernel/linux-starfive.git] / drivers / md / dm-table.c

diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index e43096c..03541cf 100644 (file)
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -230,15 +230,14 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
        sector_t dev_size = bdev_nr_sectors(bdev);
        unsigned short logical_block_size_sectors =
                limits->logical_block_size >> SECTOR_SHIFT;
-       char b[BDEVNAME_SIZE];
 
        if (!dev_size)
                return 0;
 
        if ((start >= dev_size) || (start + len > dev_size)) {
-               DMWARN("%s: %s too small for target: "
+               DMWARN("%s: %pg too small for target: "
                       "start=%llu, len=%llu, dev_size=%llu",
-                      dm_device_name(ti->table->md), bdevname(bdev, b),
+                      dm_device_name(ti->table->md), bdev,
                       (unsigned long long)start,
                       (unsigned long long)len,
                       (unsigned long long)dev_size);
@@ -253,10 +252,10 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
                unsigned int zone_sectors = bdev_zone_sectors(bdev);
 
                if (start & (zone_sectors - 1)) {
-                       DMWARN("%s: start=%llu not aligned to h/w zone size %u of %s",
+                       DMWARN("%s: start=%llu not aligned to h/w zone size %u of %pg",
                               dm_device_name(ti->table->md),
                               (unsigned long long)start,
-                              zone_sectors, bdevname(bdev, b));
+                              zone_sectors, bdev);
                        return 1;
                }
 
@@ -270,10 +269,10 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
                 * the sector range.
                 */
                if (len & (zone_sectors - 1)) {
-                       DMWARN("%s: len=%llu not aligned to h/w zone size %u of %s",
+                       DMWARN("%s: len=%llu not aligned to h/w zone size %u of %pg",
                               dm_device_name(ti->table->md),
                               (unsigned long long)len,
-                              zone_sectors, bdevname(bdev, b));
+                              zone_sectors, bdev);
                        return 1;
                }
        }
@@ -283,19 +282,19 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
 
        if (start & (logical_block_size_sectors - 1)) {
                DMWARN("%s: start=%llu not aligned to h/w "
-                      "logical block size %u of %s",
+                      "logical block size %u of %pg",
                       dm_device_name(ti->table->md),
                       (unsigned long long)start,
-                      limits->logical_block_size, bdevname(bdev, b));
+                      limits->logical_block_size, bdev);
                return 1;
        }
 
        if (len & (logical_block_size_sectors - 1)) {
                DMWARN("%s: len=%llu not aligned to h/w "
-                      "logical block size %u of %s",
+                      "logical block size %u of %pg",
                       dm_device_name(ti->table->md),
                       (unsigned long long)len,
-                      limits->logical_block_size, bdevname(bdev, b));
+                      limits->logical_block_size, bdev);
                return 1;
        }
 
@@ -400,20 +399,19 @@ static int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
        struct queue_limits *limits = data;
        struct block_device *bdev = dev->bdev;
        struct request_queue *q = bdev_get_queue(bdev);
-       char b[BDEVNAME_SIZE];
 
        if (unlikely(!q)) {
-               DMWARN("%s: Cannot set limits for nonexistent device %s",
-                      dm_device_name(ti->table->md), bdevname(bdev, b));
+               DMWARN("%s: Cannot set limits for nonexistent device %pg",
+                      dm_device_name(ti->table->md), bdev);
                return 0;
        }
 
        if (blk_stack_limits(limits, &q->limits,
                        get_start_sect(bdev) + start) < 0)
-               DMWARN("%s: adding target device %s caused an alignment inconsistency: "
+               DMWARN("%s: adding target device %pg caused an alignment inconsistency: "
                       "physical_block_size=%u, logical_block_size=%u, "
                       "alignment_offset=%u, start=%llu",
-                      dm_device_name(ti->table->md), bdevname(bdev, b),
+                      dm_device_name(ti->table->md), bdev,
                       q->limits.physical_block_size,
                       q->limits.logical_block_size,
                       q->limits.alignment_offset,
@@ -1483,6 +1481,14 @@ struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector)
        return &t->targets[(KEYS_PER_NODE * n) + k];
 }
 
+static int device_not_poll_capable(struct dm_target *ti, struct dm_dev *dev,
+                                  sector_t start, sector_t len, void *data)
+{
+       struct request_queue *q = bdev_get_queue(dev->bdev);
+
+       return !test_bit(QUEUE_FLAG_POLL, &q->queue_flags);
+}
+
 /*
  * type->iterate_devices() should be called when the sanity check needs to
  * iterate and check all underlying data devices. iterate_devices() will
@@ -1533,6 +1539,11 @@ static int count_device(struct dm_target *ti, struct dm_dev *dev,
        return 0;
 }
 
+static int dm_table_supports_poll(struct dm_table *t)
+{
+       return !dm_table_any_dev_attr(t, device_not_poll_capable, NULL);
+}
+
 /*
  * Check whether a table has no data devices attached using each
  * target's iterate_devices method.
@@ -1822,33 +1833,6 @@ static int device_is_not_random(struct dm_target *ti, struct dm_dev *dev,
        return !blk_queue_add_random(q);
 }
 
-static int device_not_write_same_capable(struct dm_target *ti, struct dm_dev *dev,
-                                        sector_t start, sector_t len, void *data)
-{
-       struct request_queue *q = bdev_get_queue(dev->bdev);
-
-       return !q->limits.max_write_same_sectors;
-}
-
-static bool dm_table_supports_write_same(struct dm_table *t)
-{
-       struct dm_target *ti;
-       unsigned i;
-
-       for (i = 0; i < dm_table_get_num_targets(t); i++) {
-               ti = dm_table_get_target(t, i);
-
-               if (!ti->num_write_same_bios)
-                       return false;
-
-               if (!ti->type->iterate_devices ||
-                   ti->type->iterate_devices(ti, device_not_write_same_capable, NULL))
-                       return false;
-       }
-
-       return true;
-}
-
 static int device_not_write_zeroes_capable(struct dm_target *ti, struct dm_dev *dev,
                                           sector_t start, sector_t len, void *data)
 {
@@ -2027,8 +2011,6 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
        else
                blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
 
-       if (!dm_table_supports_write_same(t))
-               q->limits.max_write_same_sectors = 0;
        if (!dm_table_supports_write_zeroes(t))
                q->limits.max_write_zeroes_sectors = 0;
 
@@ -2069,6 +2051,20 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
        dm_update_crypto_profile(q, t);
        disk_update_readahead(t->md->disk);
 
+       /*
+        * Check for request-based device is left to
+        * dm_mq_init_request_queue()->blk_mq_init_allocated_queue().
+        *
+        * For bio-based device, only set QUEUE_FLAG_POLL when all
+        * underlying devices supporting polling.
+        */
+       if (__table_type_bio_based(t->type)) {
+               if (dm_table_supports_poll(t))
+                       blk_queue_flag_set(QUEUE_FLAG_POLL, q);
+               else
+                       blk_queue_flag_clear(QUEUE_FLAG_POLL, q);
+       }
+
        return 0;
 }