1 files changed, 148 insertions, 39 deletions

diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 451c3bb176d..bc04518e9d8 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -17,7 +17,7 @@
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
 #include <linux/delay.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define DM_MSG_PREFIX "table"
 
@@ -54,7 +54,6 @@ struct dm_table {
         sector_t *highs;
         struct dm_target *targets;
 
-        unsigned discards_supported:1;
         unsigned integrity_supported:1;
 
         /*
@@ -154,12 +153,11 @@ void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size)
                 return NULL;
 
         size = nmemb * elem_size;
-        addr = vmalloc(size);
-        if (addr)
-                memset(addr, 0, size);
+        addr = vzalloc(size);
 
         return addr;
 }
+EXPORT_SYMBOL(dm_vcalloc);
 
 /*
  * highs, and targets are managed as dynamic arrays during a
@@ -209,7 +207,6 @@ int dm_table_create(struct dm_table **result, fmode_t mode,
         INIT_LIST_HEAD(&t->devices);
         INIT_LIST_HEAD(&t->target_callbacks);
         atomic_set(&t->holders, 0);
-        t->discards_supported = 1;
 
         if (!num_targets)
                 num_targets = KEYS_PER_NODE;
@@ -281,6 +278,7 @@ void dm_table_get(struct dm_table *t)
 {
         atomic_inc(&t->holders);
 }
+EXPORT_SYMBOL(dm_table_get);
 
 void dm_table_put(struct dm_table *t)
 {
@@ -290,6 +288,7 @@ void dm_table_put(struct dm_table *t)
         smp_mb__before_atomic_dec();
         atomic_dec(&t->holders);
 }
+EXPORT_SYMBOL(dm_table_put);
 
 /*
  * Checks to see if we need to extend highs or targets.
@@ -455,13 +454,14 @@ static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode,
  * Add a device to the list, or just increment the usage count if
  * it's already present.
  */
-static int __table_get_device(struct dm_table *t, struct dm_target *ti,
-                      const char *path, fmode_t mode, struct dm_dev **result)
+int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
+                  struct dm_dev **result)
 {
         int r;
         dev_t uninitialized_var(dev);
         struct dm_dev_internal *dd;
         unsigned int major, minor;
+        struct dm_table *t = ti->table;
 
         BUG_ON(!t);
 
@@ -509,6 +509,7 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
         *result = &dd->dm_dev;
         return 0;
 }
+EXPORT_SYMBOL(dm_get_device);
 
 int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
                          sector_t start, sector_t len, void *data)
@@ -539,23 +540,15 @@ int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
          * If not we'll force DM to use PAGE_SIZE or
          * smaller I/O, just to be safe.
          */
-
-        if (q->merge_bvec_fn && !ti->type->merge)
+        if (dm_queue_merge_is_compulsory(q) && !ti->type->merge)
                 blk_limits_max_hw_sectors(limits,
                                           (unsigned int) (PAGE_SIZE >> 9));
         return 0;
 }
 EXPORT_SYMBOL_GPL(dm_set_device_limits);
 
-int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode,
-                  struct dm_dev **result)
-{
-        return __table_get_device(ti->table, ti, path, mode, result);
-}
-
-
 /*
- * Decrement a devices use count and remove it if necessary.
+ * Decrement a device's use count and remove it if necessary.
  */
 void dm_put_device(struct dm_target *ti, struct dm_dev *d)
 {
@@ -568,6 +561,7 @@ void dm_put_device(struct dm_target *ti, struct dm_dev *d)
                 kfree(dd);
         }
 }
+EXPORT_SYMBOL(dm_put_device);
 
 /*
  * Checks to see if the target joins onto the end of the table.
@@ -791,8 +785,9 @@ int dm_table_add_target(struct dm_table *t, const char *type,
 
         t->highs[t->num_targets++] = tgt->begin + tgt->len - 1;
 
-        if (!tgt->num_discard_requests)
-                t->discards_supported = 0;
+        if (!tgt->num_discard_requests && tgt->discards_supported)
+                DMWARN("%s: %s: ignoring discards_supported because num_discard_requests is zero.",
+                       dm_device_name(t->md), type);
 
         return 0;
 
@@ -802,6 +797,63 @@ int dm_table_add_target(struct dm_table *t, const char *type,
         return r;
 }
 
+/*
+ * Target argument parsing helpers.
+ */
+static int validate_next_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                             unsigned *value, char **error, unsigned grouped)
+{
+        const char *arg_str = dm_shift_arg(arg_set);
+
+        if (!arg_str ||
+            (sscanf(arg_str, "%u", value) != 1) ||
+            (*value < arg->min) ||
+            (*value > arg->max) ||
+            (grouped && arg_set->argc < *value)) {
+                *error = arg->error;
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                unsigned *value, char **error)
+{
+        return validate_next_arg(arg, arg_set, value, error, 0);
+}
+EXPORT_SYMBOL(dm_read_arg);
+
+int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                      unsigned *value, char **error)
+{
+        return validate_next_arg(arg, arg_set, value, error, 1);
+}
+EXPORT_SYMBOL(dm_read_arg_group);
+
+const char *dm_shift_arg(struct dm_arg_set *as)
+{
+        char *r;
+
+        if (as->argc) {
+                as->argc--;
+                r = *as->argv;
+                as->argv++;
+                return r;
+        }
+
+        return NULL;
+}
+EXPORT_SYMBOL(dm_shift_arg);
+
+void dm_consume_args(struct dm_arg_set *as, unsigned num_args)
+{
+        BUG_ON(as->argc < num_args);
+        as->argc -= num_args;
+        as->argv += num_args;
+}
+EXPORT_SYMBOL(dm_consume_args);
+
 static int dm_table_set_type(struct dm_table *t)
 {
         unsigned i;
@@ -1077,11 +1129,13 @@ void dm_table_event(struct dm_table *t)
                 t->event_fn(t->event_context);
         mutex_unlock(&_event_lock);
 }
+EXPORT_SYMBOL(dm_table_event);
 
 sector_t dm_table_get_size(struct dm_table *t)
 {
         return t->num_targets ? (t->highs[t->num_targets - 1] + 1) : 0;
 }
+EXPORT_SYMBOL(dm_table_get_size);
 
 struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index)
 {
@@ -1184,19 +1238,72 @@ static void dm_table_set_integrity(struct dm_table *t)
                 return;
 
         template_disk = dm_table_get_integrity_disk(t, true);
-        if (!template_disk &&
-            blk_integrity_is_initialized(dm_disk(t->md))) {
+        if (template_disk)
+                blk_integrity_register(dm_disk(t->md),
+                                       blk_get_integrity(template_disk));
+        else if (blk_integrity_is_initialized(dm_disk(t->md)))
                 DMWARN("%s: device no longer has a valid integrity profile",
                        dm_device_name(t->md));
-                return;
+        else
+                DMWARN("%s: unable to establish an integrity profile",
+                       dm_device_name(t->md));
+}
+
+static int device_flush_capable(struct dm_target *ti, struct dm_dev *dev,
+                                sector_t start, sector_t len, void *data)
+{
+        unsigned flush = (*(unsigned *)data);
+        struct request_queue *q = bdev_get_queue(dev->bdev);
+
+        return q && (q->flush_flags & flush);
+}
+
+static bool dm_table_supports_flush(struct dm_table *t, unsigned flush)
+{
+        struct dm_target *ti;
+        unsigned i = 0;
+
+        /*
+         * Require at least one underlying device to support flushes.
+         * t->devices includes internal dm devices such as mirror logs
+         * so we need to use iterate_devices here, which targets
+         * supporting flushes must provide.
+         */
+        while (i < dm_table_get_num_targets(t)) {
+                ti = dm_table_get_target(t, i++);
+
+                if (!ti->num_flush_requests)
+                        continue;
+
+                if (ti->type->iterate_devices &&
+                    ti->type->iterate_devices(ti, device_flush_capable, &flush))
+                        return 1;
+        }
+
+        return 0;
+}
+
+static bool dm_table_discard_zeroes_data(struct dm_table *t)
+{
+        struct dm_target *ti;
+        unsigned i = 0;
+
+        /* Ensure that all targets supports discard_zeroes_data. */
+        while (i < dm_table_get_num_targets(t)) {
+                ti = dm_table_get_target(t, i++);
+
+                if (ti->discard_zeroes_data_unsupported)
+                        return 0;
         }
-        blk_integrity_register(dm_disk(t->md),
-                               blk_get_integrity(template_disk));
+
+        return 1;
 }
 
 void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
                                struct queue_limits *limits)
 {
+        unsigned flush = 0;
+
         /*
          * Copy table's limits to the DM device's request_queue
          */
@@ -1207,6 +1314,16 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
         else
                 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
 
+        if (dm_table_supports_flush(t, REQ_FLUSH)) {
+                flush |= REQ_FLUSH;
+                if (dm_table_supports_flush(t, REQ_FUA))
+                        flush |= REQ_FUA;
+        }
+        blk_queue_flush(q, flush);
+
+        if (!dm_table_discard_zeroes_data(t))
+                q->limits.discard_zeroes_data = 0;
+
         dm_table_set_integrity(t);
 
         /*
@@ -1237,6 +1354,7 @@ fmode_t dm_table_get_mode(struct dm_table *t)
 {
         return t->mode;
 }
+EXPORT_SYMBOL(dm_table_get_mode);
 
 static void suspend_targets(struct dm_table *t, unsigned postsuspend)
 {
@@ -1345,6 +1463,7 @@ struct mapped_device *dm_table_get_md(struct dm_table *t)
 {
         return t->md;
 }
+EXPORT_SYMBOL(dm_table_get_md);
 
 static int device_discard_capable(struct dm_target *ti, struct dm_dev *dev,
                                   sector_t start, sector_t len, void *data)
@@ -1359,19 +1478,19 @@ bool dm_table_supports_discards(struct dm_table *t)
         struct dm_target *ti;
         unsigned i = 0;
 
-        if (!t->discards_supported)
-                return 0;
-
         /*
          * Unless any target used by the table set discards_supported,
          * require at least one underlying device to support discards.
          * t->devices includes internal dm devices such as mirror logs
          * so we need to use iterate_devices here, which targets
-         * supporting discard must provide.
+         * supporting discard selectively must provide.
          */
         while (i < dm_table_get_num_targets(t)) {
                 ti = dm_table_get_target(t, i++);
 
+                if (!ti->num_discard_requests)
+                        continue;
+
                 if (ti->discards_supported)
                         return 1;
 
@@ -1382,13 +1501,3 @@ bool dm_table_supports_discards(struct dm_table *t)
 
         return 0;
 }
-
-EXPORT_SYMBOL(dm_vcalloc);
-EXPORT_SYMBOL(dm_get_device);
-EXPORT_SYMBOL(dm_put_device);
-EXPORT_SYMBOL(dm_table_event);
-EXPORT_SYMBOL(dm_table_get_size);
-EXPORT_SYMBOL(dm_table_get_mode);
-EXPORT_SYMBOL(dm_table_get_md);
-EXPORT_SYMBOL(dm_table_put);
-EXPORT_SYMBOL(dm_table_get);