lvconvert: reusing old cache pool metadata needs -Zn

When cache pool is reused for a new cached volume, there is
normally no need to 'keep' old cache-pool metadata as this
could cause major data lose.

Unlike with 'lvcreate -H -LX --cachepool' conversion, this lvconvert
path left the metadata unzeroed - partly for making easier some
debugging, but this was rather a bug.

So to keep possible reattach of 'unzeroed' metadata, user
now has to use 'lvconvert -Zn' for such conversion. In this case
the prompt will appear about possibe data loss and to proceed,
user has to confirm such operation. Without -Zn metadata are wiped.

diff --git a/WHATS_NEW b/WHATS_NEW
index 79c4317ff2e79bf0c7f3c352e01c9fa23550bf24..0d6d01062bd2dac9fe3f9f6c52cf8f78a49d6ed3 100644 (file)
--- a/WHATS_NEW
+++ b/WHATS_NEW
@@ -1,5 +1,6 @@
 Version 2.02.162 - 
 =================================
+  lvconvert reuse cachepool metadade now ONLY with -Zn and clear otherwise.
   Enabled lvconvert --uncache to work with partial VG.
 
 Version 2.02.161 - 15th July 2016

diff --git a/tools/lvconvert.c b/tools/lvconvert.c
index 2fd6094ba614aa533fa1775ce562dee418b19368..9dd72542d479a9831eb1e22cd415960239a626c2 100644 (file)
--- a/tools/lvconvert.c
+++ b/tools/lvconvert.c
@@ -372,7 +372,7 @@ static int _read_pool_params(struct cmd_context *cmd, int *pargc, char ***pargv,
        } else {
                if (arg_from_list_is_set(cmd, "is valid only with thin pools",
                                         discards_ARG, originname_ARG, thinpool_ARG,
-                                        zero_ARG, -1))
+                                        -1))
                        return_0;
                if (lp->thin) {
                        log_error("--thin requires --thinpool.");
@@ -420,6 +420,7 @@ static int _read_pool_params(struct cmd_context *cmd, int *pargc, char ***pargv,
 
        } else if (arg_from_list_is_set(cmd, "is valid only with pools",
                                        poolmetadatasize_ARG, poolmetadataspare_ARG,
+                                       zero_ARG,
                                        -1))
                return_0;
 
@@ -2970,9 +2971,35 @@ static int _lvconvert_pool(struct cmd_context *cmd,
                if (!metadata_lv) {
                        if (arg_from_list_is_set(cmd, "is invalid with existing pool",
                                                 chunksize_ARG, discards_ARG,
-                                                zero_ARG, poolmetadatasize_ARG, -1))
+                                                poolmetadatasize_ARG, -1))
+                               return_0;
+
+                       if (lp->thin &&
+                           arg_from_list_is_set(cmd, "is invalid with existing thin pool",
+                                                zero_ARG, -1))
                                return_0;
 
+                       if (lp->cache) {
+                               /* Check is user has not requested -Zn */
+                               if (!arg_int_value(cmd, zero_ARG, 1)) {
+                                       /* Note: requires rather deep know-how to skip zeroing
+                                        * so show major warnings */
+                                       log_warn("WARNING: Reusing old cache pool metadata %s to "
+                                                "for volume caching.",
+                                                display_lvname(pool_lv));
+                                       log_warn("THIS MAY DESTROY YOUR DATA (filesystem etc.)");
+
+                                       if (!lp->yes &&
+                                           yes_no_prompt("Do you really want to keep old metadata for "
+                                                         "cache pool volume %s? [y/n]: ",
+                                                         display_lvname(pool_lv)) == 'n') {
+                                               log_error("Conversion aborted.");
+                                               return 0;
+                                       }
+                               } else if (!wipe_cache_pool(pool_lv))
+                                       return_0;
+                       }
+
                        if (lp->thin || lp->cache)
                                /* already pool, can continue converting volume */
                                return 1;