Merge tag 'blackfin-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/realm...

[deliverable/linux.git] / drivers / md / dm-table.c

diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 6554d9148927771296e52cc2882f9e6f7fa68145..d9b00b8565c6dc1a36f5a3d863baa370126da593 100644 (file)
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -18,6 +18,8 @@
 #include <linux/mutex.h>
 #include <linux/delay.h>
 #include <linux/atomic.h>
+#include <linux/blk-mq.h>
+#include <linux/mount.h>
 
 #define DM_MSG_PREFIX "table"
 
@@ -372,23 +374,18 @@ int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
        int r;
        dev_t uninitialized_var(dev);
        struct dm_dev_internal *dd;
-       unsigned int major, minor;
        struct dm_table *t = ti->table;
-       char dummy;
+       struct block_device *bdev;
 
        BUG_ON(!t);
 
-       if (sscanf(path, "%u:%u%c", &major, &minor, &dummy) == 2) {
-               /* Extract the major/minor numbers */
-               dev = MKDEV(major, minor);
-               if (MAJOR(dev) != major || MINOR(dev) != minor)
-                       return -EOVERFLOW;
+       /* convert the path to a device */
+       bdev = lookup_bdev(path);
+       if (IS_ERR(bdev)) {
+               dev = name_to_dev_t(path);
+               if (!dev)
+                       return -ENODEV;
        } else {
-               /* convert the path to a device */
-               struct block_device *bdev = lookup_bdev(path);
-
-               if (IS_ERR(bdev))
-                       return PTR_ERR(bdev);
                dev = bdev->bd_dev;
                bdput(bdev);
        }
@@ -939,7 +936,7 @@ bool dm_table_mq_request_based(struct dm_table *t)
        return dm_table_get_type(t) == DM_TYPE_MQ_REQUEST_BASED;
 }
 
-static int dm_table_alloc_md_mempools(struct dm_table *t)
+static int dm_table_alloc_md_mempools(struct dm_table *t, struct mapped_device *md)
 {
        unsigned type = dm_table_get_type(t);
        unsigned per_bio_data_size = 0;
@@ -957,7 +954,7 @@ static int dm_table_alloc_md_mempools(struct dm_table *t)
                        per_bio_data_size = max(per_bio_data_size, tgt->per_bio_data_size);
                }
 
-       t->mempools = dm_alloc_md_mempools(type, t->integrity_supported, per_bio_data_size);
+       t->mempools = dm_alloc_md_mempools(md, type, t->integrity_supported, per_bio_data_size);
        if (!t->mempools)
                return -ENOMEM;
 
@@ -1127,7 +1124,7 @@ int dm_table_complete(struct dm_table *t)
                return r;
        }
 
-       r = dm_table_alloc_md_mempools(t);
+       r = dm_table_alloc_md_mempools(t, t->md);
        if (r)
                DMERR("unable to allocate mempools");
 
@@ -1339,14 +1336,14 @@ static bool dm_table_supports_flush(struct dm_table *t, unsigned flush)
                        continue;
 
                if (ti->flush_supported)
-                       return 1;
+                       return true;
 
                if (ti->type->iterate_devices &&
                    ti->type->iterate_devices(ti, device_flush_capable, &flush))
-                       return 1;
+                       return true;
        }
 
-       return 0;
+       return false;
 }
 
 static bool dm_table_discard_zeroes_data(struct dm_table *t)
@@ -1359,10 +1356,10 @@ static bool dm_table_discard_zeroes_data(struct dm_table *t)
                ti = dm_table_get_target(t, i++);
 
                if (ti->discard_zeroes_data_unsupported)
-                       return 0;
+                       return false;
        }
 
-       return 1;
+       return true;
 }
 
 static int device_is_nonrot(struct dm_target *ti, struct dm_dev *dev,
@@ -1408,10 +1405,10 @@ static bool dm_table_all_devices_attribute(struct dm_table *t,
 
                if (!ti->type->iterate_devices ||
                    !ti->type->iterate_devices(ti, func, NULL))
-                       return 0;
+                       return false;
        }
 
-       return 1;
+       return true;
 }
 
 static int device_not_write_same_capable(struct dm_target *ti, struct dm_dev *dev,
@@ -1468,14 +1465,14 @@ static bool dm_table_supports_discards(struct dm_table *t)
                        continue;
 
                if (ti->discards_supported)
-                       return 1;
+                       return true;
 
                if (ti->type->iterate_devices &&
                    ti->type->iterate_devices(ti, device_discard_capable, NULL))
-                       return 1;
+                       return true;
        }
 
-       return 0;
+       return false;
 }
 
 void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
@@ -1677,20 +1674,6 @@ int dm_table_any_congested(struct dm_table *t, int bdi_bits)
        return r;
 }
 
-int dm_table_any_busy_target(struct dm_table *t)
-{
-       unsigned i;
-       struct dm_target *ti;
-
-       for (i = 0; i < t->num_targets; i++) {
-               ti = t->targets + i;
-               if (ti->type->busy && ti->type->busy(ti))
-                       return 1;
-       }
-
-       return 0;
-}
-
 struct mapped_device *dm_table_get_md(struct dm_table *t)
 {
        return t->md;
@@ -1709,9 +1692,13 @@ void dm_table_run_md_queue_async(struct dm_table *t)
        md = dm_table_get_md(t);
        queue = dm_get_md_queue(md);
        if (queue) {
-               spin_lock_irqsave(queue->queue_lock, flags);
-               blk_run_queue_async(queue);
-               spin_unlock_irqrestore(queue->queue_lock, flags);
+               if (queue->mq_ops)
+                       blk_mq_run_hw_queues(queue, true);
+               else {
+                       spin_lock_irqsave(queue->queue_lock, flags);
+                       blk_run_queue_async(queue);
+                       spin_unlock_irqrestore(queue->queue_lock, flags);
+               }
        }
 }
 EXPORT_SYMBOL(dm_table_run_md_queue_async);