[lvm-devel] master - lvconvert: remove unused code
David Teigland
teigland at fedoraproject.org
Mon Feb 13 18:10:22 UTC 2017
Gitweb: http://git.fedorahosted.org/git/?p=lvm2.git;a=commitdiff;h=041c2fef88ab2e546555625039a17ccbb7b1c9c5
Commit: 041c2fef88ab2e546555625039a17ccbb7b1c9c5
Parent: 46b2599d5c4e01eee66be7c45aa6cf36d7cbc50f
Author: David Teigland <teigland at redhat.com>
AuthorDate: Tue Dec 20 15:17:48 2016 -0600
Committer: David Teigland <teigland at redhat.com>
CommitterDate: Mon Feb 13 08:20:10 2017 -0600
lvconvert: remove unused code
---
tools/lvconvert.c | 3170 +++++++++++++++--------------------------------------
1 files changed, 882 insertions(+), 2288 deletions(-)
diff --git a/tools/lvconvert.c b/tools/lvconvert.c
index 642d6b7..757e8b4 100644
--- a/tools/lvconvert.c
+++ b/tools/lvconvert.c
@@ -19,25 +19,6 @@
#include "lvconvert_poll.h"
#include "command-lines-count.h"
-/*
- * Guidelines for mapping options to operations.
- *
- * There should be a clear and unique correspondence between an option
- * name and the operation to be performed.
- *
- * An option with a given name should always perform the same operation.
- * If the same operation applies to two types of LV, then the same option
- * name can be used with both LV types. But, a given option name should
- * not be used to perform different operations depending on the LV type it
- * is used with.
- *
- * --merge and --split are examples where a single option name has been
- * overloaded with different operations. The case of --split has been
- * corrected with the clear and unique variations --splitcache,
- * --splitsnapshot, --splitmirror, which should allow --split to be
- * deprecated. (The same is still needed for --merge.)
- */
-
typedef enum {
/* Split:
* For a mirrored or raid LV, split mirror into two mirrors, optionally tracking
@@ -52,23 +33,13 @@ typedef enum {
struct lvconvert_params {
/* Exactly one of these 12 command categories is determined */
- int merge; /* 1 */
- int split; /* 2 */
- int splitsnapshot; /* 3 */
- int splitcache; /* 4 */
- int keep_mimages; /* 5 */ /* --splitmirrors */
- int cache; /* 6 */
- int uncache; /* 7 */
- int snapshot; /* 8 */
- int thin; /* 11 */
- /* other */ /* 12 */
+ int split; /* 1 */
+ int keep_mimages; /* 2 */ /* --splitmirrors */
+ /* other */ /* 3 */
/* FIXME Eliminate all cases where more than one of the above are set then use conv_type instead */
conversion_type_t conv_type;
- int merge_snapshot; /* CONV_MERGE is set */
- int merge_mirror; /* CONV_MERGE is set */
-
int track_changes; /* CONV_SPLIT_MIRRORS is set */
int corelog; /* Equivalent to --mirrorlog core */
@@ -80,7 +51,6 @@ struct lvconvert_params {
const struct segment_type *segtype; /* Holds what segment type you will get */
- int poolmetadataspare;
int force;
int yes;
int zero;
@@ -92,8 +62,6 @@ struct lvconvert_params {
int wait_completion;
int need_polling;
- int thin_chunk_size_calc_policy;
- uint32_t chunk_size;
uint32_t region_size;
uint32_t mirrors;
@@ -103,9 +71,6 @@ struct lvconvert_params {
unsigned stripes_supplied;
unsigned stripe_size_supplied;
uint32_t read_ahead;
- cache_mode_t cache_mode; /* cache */
- const char *policy_name; /* cache */
- struct dm_config_tree *policy_settings; /* cache */
unsigned target_attr;
@@ -118,15 +83,7 @@ struct lvconvert_params {
struct logical_volume *lv_to_poll;
struct dm_list idls;
- uint32_t pool_metadata_extents;
- int passed_args;
- uint64_t pool_metadata_size;
const char *origin_name;
- const char *pool_data_name;
- struct logical_volume *pool_data_lv;
- const char *pool_metadata_name;
- struct logical_volume *pool_metadata_lv;
- thin_discards_t discards;
};
struct convert_poll_id_list {
@@ -145,12 +102,6 @@ static void _set_conv_type(struct lvconvert_params *lp, int conv_type)
lp->conv_type = conv_type;
}
-/* -s/--snapshot and --type snapshot are synonyms */
-static int _snapshot_type_requested(struct cmd_context *cmd, const char *type_str)
-{
- return (arg_is_set(cmd, snapshot_ARG) || !strcmp(type_str, SEG_TYPE_NAME_SNAPSHOT));
-}
-
static int _raid0_type_requested(const char *type_str)
{
return (!strcmp(type_str, SEG_TYPE_NAME_RAID0) || !strcmp(type_str, SEG_TYPE_NAME_RAID0_META));
@@ -1282,11 +1233,6 @@ static int _lvconvert_mirrors(struct cmd_context *cmd,
return 0;
}
- if (lp->merge_mirror) {
- log_error("Unable to merge mirror images of segment type 'mirror'.");
- return 0;
- }
-
if (!_lvconvert_validate_thin(lv, lp))
return_0;
@@ -1424,7 +1370,7 @@ static int _lvconvert_raid(struct logical_volume *lv, struct lvconvert_params *l
if (!_is_valid_raid_conversion(seg->segtype, lp->segtype))
goto try_new_takeover_or_reshape;
- if (seg_is_linear(seg) && !lp->merge_mirror && !lp->mirrors_supplied) {
+ if (seg_is_linear(seg) && !lp->mirrors_supplied) {
if (_raid0_type_requested(lp->type_str)) {
log_error("Linear LV %s cannot be converted to %s.",
display_lvname(lv), lp->type_str);
@@ -1466,9 +1412,6 @@ static int _lvconvert_raid(struct logical_volume *lv, struct lvconvert_params *l
return 0;
}
- if (lp->merge_mirror)
- return lv_raid_merge(lv);
-
if (lp->track_changes)
return lv_raid_split_and_track(lv, lp->pvh);
@@ -1563,97 +1506,413 @@ try_new_takeover_or_reshape:
return 0;
}
-static int _lvconvert_splitsnapshot(struct cmd_context *cmd, struct logical_volume *cow)
+/*
+ * Functions called to perform a specific operation on a specific LV type.
+ *
+ * _convert_<lvtype>_<operation>
+ *
+ * For cases where an operation does not apply to the LV itself, but
+ * is implicitly redirected to a sub-LV, these functions locate the
+ * correct sub-LV and call the operation on that sub-LV. If a sub-LV
+ * of the proper type is not found, these functions report the error.
+ *
+ * FIXME: the _lvconvert_foo() functions can be cleaned up since they
+ * are now only called for valid combinations of LV type and operation.
+ * After that happens, the code remaining in those functions can be
+ * moved into the _convert_lvtype_operation() functions below.
+ */
+
+/*
+ * Change the number of images in a mirror LV.
+ * lvconvert --mirrors Number LV
+ */
+static int _convert_mirror_number(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
{
- struct volume_group *vg = cow->vg;
- const char *cow_name = display_lvname(cow);
+ return _lvconvert_mirrors(cmd, lv, lp);
+}
- if (lv_is_virtual_origin(origin_from_cow(cow))) {
- log_error("Unable to split off snapshot %s with virtual origin.", cow_name);
- return 0;
- }
+/*
+ * Split images from a mirror LV and use them to create a new LV.
+ * lvconvert --splitmirrors Number LV
+ *
+ * Required options:
+ * --name Name
+ */
- if (!(vg->fid->fmt->features & FMT_MDAS)) {
- log_error("Unable to split off snapshot %s using old LVM1-style metadata.", cow_name);
- return 0;
- }
+static int _convert_mirror_splitmirrors(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_mirrors(cmd, lv, lp);
+}
- if (is_lockd_type(vg->lock_type)) {
- /* FIXME: we need to create a lock for the new LV. */
- log_error("Unable to split snapshots in VG with lock_type %s.", vg->lock_type);
- return 0;
- }
+/*
+ * Change the type of log used by a mirror LV.
+ * lvconvert --mirrorlog Type LV
+ */
+static int _convert_mirror_log(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_mirrors(cmd, lv, lp);
+}
- if (lv_is_active_locally(cow)) {
- if (!lv_check_not_in_use(cow, 1))
- return_0;
+/*
+ * Convert mirror LV to linear LV.
+ * lvconvert --type linear LV
+ *
+ * Alternate syntax:
+ * lvconvert --mirrors 0 LV
+ */
+static int _convert_mirror_linear(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_mirrors(cmd, lv, lp);
+}
- if ((arg_count(cmd, force_ARG) == PROMPT) &&
- !arg_count(cmd, yes_ARG) &&
- lv_is_visible(cow) &&
- lv_is_active(cow)) {
- if (yes_no_prompt("Do you really want to split off active "
- "logical volume %s? [y/n]: ", display_lvname(cow)) == 'n') {
- log_error("Logical volume %s not split.", display_lvname(cow));
- return 0;
- }
- }
- }
+/*
+ * Convert mirror LV to raid1 LV.
+ * lvconvert --type raid1 LV
+ */
+static int _convert_mirror_raid(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_raid(lv, lp);
+}
- if (!archive(vg))
- return_0;
+/*
+ * Change the number of images in a raid1 LV.
+ * lvconvert --mirrors Number LV
+ */
+static int _convert_raid_number(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_raid(lv, lp);
+}
- log_verbose("Splitting snapshot %s from its origin.", display_lvname(cow));
+/*
+ * Split images from a raid1 LV and use them to create a new LV.
+ * lvconvert --splitmirrors Number LV
+ *
+ * Required options:
+ * --trackchanges | --name Name
+ */
+static int _convert_raid_splitmirrors(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ /* FIXME: split the splitmirrors section out of _lvconvert_raid and call it here. */
+ return _lvconvert_raid(lv, lp);
+}
- if (!vg_remove_snapshot(cow))
- return_0;
+/*
+ * Convert a raid* LV to use a different raid level.
+ * lvconvert --type raid* LV
+ */
+static int _convert_raid_raid(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_raid(lv, lp);
+}
- backup(vg);
+/*
+ * Convert a raid* LV to a mirror LV.
+ * lvconvert --type mirror LV
+ */
+static int _convert_raid_mirror(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_raid(lv, lp);
+}
- log_print_unless_silent("Logical Volume %s split from its origin.", display_lvname(cow));
+/*
+ * Convert a raid* LV to a striped LV.
+ * lvconvert --type striped LV
+ */
+static int _convert_raid_striped(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_raid(lv, lp);
+}
- return 1;
+/*
+ * Convert a raid* LV to a linear LV.
+ * lvconvert --type linear LV
+ */
+static int _convert_raid_linear(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_raid(lv, lp);
}
-static int _lvconvert_split_and_keep_cachepool(struct cmd_context *cmd,
- struct logical_volume *lv,
- struct logical_volume *cachepool_lv)
+/*
+ * Convert a striped/linear LV to a mirror LV.
+ * lvconvert --type mirror LV
+ *
+ * Required options:
+ * --mirrors Number
+ *
+ * Alternate syntax:
+ * This is equivalent to above when global/mirror_segtype_default="mirror".
+ * lvconvert --mirrors Number LV
+ */
+static int _convert_striped_mirror(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
{
- log_debug("Detaching cache pool %s from cache LV %s.",
- display_lvname(cachepool_lv), display_lvname(lv));
+ return _lvconvert_mirrors(cmd, lv, lp);
+}
- if (!archive(lv->vg))
- return_0;
+/*
+ * Convert a striped/linear LV to a raid* LV.
+ * lvconvert --type raid* LV
+ *
+ * Required options:
+ * --mirrors Number
+ *
+ * Alternate syntax:
+ * This is equivalent to above when global/mirror_segtype_default="raid1".
+ * lvconvert --mirrors Number LV
+ */
+static int _convert_striped_raid(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ return _lvconvert_raid(lv, lp);
+}
- if (!lv_cache_remove(lv))
- return_0;
+static int _convert_mirror(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ if (arg_is_set(cmd, mirrors_ARG))
+ return _convert_mirror_number(cmd, lv, lp);
- if (!vg_write(lv->vg) || !vg_commit(lv->vg))
- return_0;
+ if (arg_is_set(cmd, splitmirrors_ARG))
+ return _convert_mirror_splitmirrors(cmd, lv, lp);
- backup(lv->vg);
+ if (arg_is_set(cmd, mirrorlog_ARG) || arg_is_set(cmd, corelog_ARG))
+ return _convert_mirror_log(cmd, lv, lp);
- log_print_unless_silent("Logical volume %s is not cached and cache pool %s is unused.",
- display_lvname(lv), display_lvname(cachepool_lv));
+ if (_linear_type_requested(lp->type_str))
+ return _convert_mirror_linear(cmd, lv, lp);
- return 1;
+ if (segtype_is_raid(lp->segtype))
+ return _convert_mirror_raid(cmd, lv, lp);
+
+ log_error("Unknown operation on mirror LV %s.", display_lvname(lv));
+ return 0;
}
-static int _lvconvert_split_and_remove_cachepool(struct cmd_context *cmd,
- struct logical_volume *lv,
- struct logical_volume *cachepool_lv)
+static int _convert_raid(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
{
- struct lv_segment *seg;
- struct logical_volume *remove_lv;
+ if (arg_is_set(cmd, mirrors_ARG))
+ return _convert_raid_number(cmd, lv, lp);
- seg = first_seg(lv);
+ if (arg_is_set(cmd, splitmirrors_ARG))
+ return _convert_raid_splitmirrors(cmd, lv, lp);
- if (lv_is_partial(seg_lv(seg, 0))) {
- log_warn("WARNING: Cache origin logical volume %s is missing.",
- display_lvname(seg_lv(seg, 0)));
- remove_lv = lv; /* When origin is missing, drop everything */
- } else
- remove_lv = seg->pool_lv;
+ if (segtype_is_raid(lp->segtype))
+ return _convert_raid_raid(cmd, lv, lp);
+
+ if (segtype_is_mirror(lp->segtype))
+ return _convert_raid_mirror(cmd, lv, lp);
+
+ if (!strcmp(lp->type_str, SEG_TYPE_NAME_STRIPED))
+ return _convert_raid_striped(cmd, lv, lp);
+
+ if (_linear_type_requested(lp->type_str))
+ return _convert_raid_linear(cmd, lv, lp);
+
+ log_error("Unknown operation on raid LV %s.", display_lvname(lv));
+ return 0;
+}
+
+static int _convert_striped(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ const char *mirrors_type = find_config_tree_str(cmd, global_mirror_segtype_default_CFG, NULL);
+
+ if (!strcmp(lp->type_str, SEG_TYPE_NAME_MIRROR))
+ return _convert_striped_mirror(cmd, lv, lp);
+
+ if (segtype_is_raid(lp->segtype))
+ return _convert_striped_raid(cmd, lv, lp);
+
+ /* --mirrors can mean --type mirror or --type raid1 depending on config setting. */
+
+ if (arg_is_set(cmd, mirrors_ARG) && mirrors_type && !strcmp(mirrors_type, SEG_TYPE_NAME_MIRROR))
+ return _convert_striped_mirror(cmd, lv, lp);
+
+ if (arg_is_set(cmd, mirrors_ARG) && mirrors_type && !strcmp(mirrors_type, SEG_TYPE_NAME_RAID1))
+ return _convert_striped_raid(cmd, lv, lp);
+
+ log_error("Unknown operation on striped or linear LV %s.", display_lvname(lv));
+ return 0;
+}
+
+static int _lvconvert_raid_types(struct cmd_context *cmd, struct logical_volume *lv,
+ struct lvconvert_params *lp)
+{
+ struct lv_segment *seg = first_seg(lv);
+ int ret = 0;
+
+ /* Set up segtype either from type_str or else to match the existing one. */
+ if (!*lp->type_str)
+ lp->segtype = seg->segtype;
+ else if (!(lp->segtype = get_segtype_from_string(cmd, lp->type_str)))
+ goto_out;
+
+ if (!strcmp(lp->type_str, SEG_TYPE_NAME_MIRROR)) {
+ if (!lp->mirrors_supplied && !seg_is_raid1(seg)) {
+ log_error("Conversions to --type mirror require -m/--mirrors");
+ goto out;
+ }
+ }
+
+ /* lv->segtype can't be NULL */
+ if (activation() && lp->segtype->ops->target_present &&
+ !lp->segtype->ops->target_present(cmd, NULL, &lp->target_attr)) {
+ log_error("%s: Required device-mapper target(s) not "
+ "detected in your kernel.", lp->segtype->name);
+ goto out;
+ }
+
+ /* Process striping parameters */
+ /* FIXME This is incomplete */
+ if (_mirror_or_raid_type_requested(cmd, lp->type_str) || _raid0_type_requested(lp->type_str) ||
+ _striped_type_requested(lp->type_str) || lp->mirrorlog || lp->corelog) {
+ /* FIXME Handle +/- adjustments too? */
+ if (!get_stripe_params(cmd, lp->segtype, &lp->stripes, &lp->stripe_size, &lp->stripes_supplied, &lp->stripe_size_supplied))
+ goto_out;
+
+ if (_raid0_type_requested(lp->type_str) || _striped_type_requested(lp->type_str))
+ /* FIXME Shouldn't need to override get_stripe_params which defaults to 1 stripe (i.e. linear)! */
+ /* The default keeps existing number of stripes, handled inside the library code */
+ if (!arg_is_set(cmd, stripes_long_ARG))
+ lp->stripes = 0;
+ }
+
+ if (lv_is_cache(lv))
+ lv = seg_lv(first_seg(lv), 0);
+
+ if (lv_is_mirror(lv)) {
+ ret = _convert_mirror(cmd, lv, lp);
+ goto out;
+ }
+
+ if (lv_is_raid(lv)) {
+ ret = _convert_raid(cmd, lv, lp);
+ goto out;
+ }
+
+ /*
+ * FIXME: add lv_is_striped() and lv_is_linear()?
+ * This does not include raid0 which is caught by the test above.
+ * If operations differ between striped and linear, split this case.
+ */
+ if (segtype_is_striped(seg->segtype) || segtype_is_linear(seg->segtype)) {
+ ret = _convert_striped(cmd, lv, lp);
+ goto out;
+ }
+
+ /*
+ * The intention is to explicitly check all cases above and never
+ * reach here, but this covers anything that was missed.
+ */
+ log_error("Cannot convert LV %s.", display_lvname(lv));
+
+out:
+ return ret ? ECMD_PROCESSED : ECMD_FAILED;
+}
+
+static int _lvconvert_splitsnapshot(struct cmd_context *cmd, struct logical_volume *cow)
+{
+ struct volume_group *vg = cow->vg;
+ const char *cow_name = display_lvname(cow);
+
+ if (lv_is_virtual_origin(origin_from_cow(cow))) {
+ log_error("Unable to split off snapshot %s with virtual origin.", cow_name);
+ return 0;
+ }
+
+ if (!(vg->fid->fmt->features & FMT_MDAS)) {
+ log_error("Unable to split off snapshot %s using old LVM1-style metadata.", cow_name);
+ return 0;
+ }
+
+ if (is_lockd_type(vg->lock_type)) {
+ /* FIXME: we need to create a lock for the new LV. */
+ log_error("Unable to split snapshots in VG with lock_type %s.", vg->lock_type);
+ return 0;
+ }
+
+ if (lv_is_active_locally(cow)) {
+ if (!lv_check_not_in_use(cow, 1))
+ return_0;
+
+ if ((arg_count(cmd, force_ARG) == PROMPT) &&
+ !arg_count(cmd, yes_ARG) &&
+ lv_is_visible(cow) &&
+ lv_is_active(cow)) {
+ if (yes_no_prompt("Do you really want to split off active "
+ "logical volume %s? [y/n]: ", display_lvname(cow)) == 'n') {
+ log_error("Logical volume %s not split.", display_lvname(cow));
+ return 0;
+ }
+ }
+ }
+
+ if (!archive(vg))
+ return_0;
+
+ log_verbose("Splitting snapshot %s from its origin.", display_lvname(cow));
+
+ if (!vg_remove_snapshot(cow))
+ return_0;
+
+ backup(vg);
+
+ log_print_unless_silent("Logical Volume %s split from its origin.", display_lvname(cow));
+
+ return 1;
+}
+
+static int _lvconvert_split_and_keep_cachepool(struct cmd_context *cmd,
+ struct logical_volume *lv,
+ struct logical_volume *cachepool_lv)
+{
+ log_debug("Detaching cache pool %s from cache LV %s.",
+ display_lvname(cachepool_lv), display_lvname(lv));
+
+ if (!archive(lv->vg))
+ return_0;
+
+ if (!lv_cache_remove(lv))
+ return_0;
+
+ if (!vg_write(lv->vg) || !vg_commit(lv->vg))
+ return_0;
+
+ backup(lv->vg);
+
+ log_print_unless_silent("Logical volume %s is not cached and cache pool %s is unused.",
+ display_lvname(lv), display_lvname(cachepool_lv));
+
+ return 1;
+}
+
+static int _lvconvert_split_and_remove_cachepool(struct cmd_context *cmd,
+ struct logical_volume *lv,
+ struct logical_volume *cachepool_lv)
+{
+ struct lv_segment *seg;
+ struct logical_volume *remove_lv;
+
+ seg = first_seg(lv);
+
+ if (lv_is_partial(seg_lv(seg, 0))) {
+ log_warn("WARNING: Cache origin logical volume %s is missing.",
+ display_lvname(seg_lv(seg, 0)));
+ remove_lv = lv; /* When origin is missing, drop everything */
+ } else
+ remove_lv = seg->pool_lv;
if (lv_is_partial(seg_lv(first_seg(seg->pool_lv), 0)))
log_warn("WARNING: Cache pool data logical volume %s is missing.",
@@ -2179,49 +2438,45 @@ deactivate_pmslv:
return 1;
}
-/* Currently converts only to thin volume with external origin */
-static int _lvconvert_thin(struct cmd_context *cmd,
+static int _lvconvert_to_thin_with_external(struct cmd_context *cmd,
struct logical_volume *lv,
- struct lvconvert_params *lp)
+ struct logical_volume *thinpool_lv)
{
- struct logical_volume *torigin_lv, *pool_lv = lp->pool_data_lv;
struct volume_group *vg = lv->vg;
+ struct logical_volume *thin_lv;
+ const char *origin_name;
+
struct lvcreate_params lvc = {
.activate = CHANGE_AEY,
.alloc = ALLOC_INHERIT,
- .lv_name = lp->origin_name,
.major = -1,
.minor = -1,
.suppress_zero_warn = 1, /* Suppress warning for this thin */
.permission = LVM_READ,
- .pool_name = pool_lv->name,
+ .pool_name = thinpool_lv->name,
.pvh = &vg->pvs,
.read_ahead = DM_READ_AHEAD_AUTO,
.stripes = 1,
.virtual_extents = lv->le_count,
};
- if (lv == pool_lv) {
+ if (lv == thinpool_lv) {
log_error("Can't use same LV %s for thin pool and thin volume.",
- display_lvname(pool_lv));
+ display_lvname(thinpool_lv));
return 0;
}
- if (lv_is_locked(lv) ||
- !lv_is_visible(lv) ||
- lv_is_cow(lv) ||
- lv_is_pool(lv) ||
- lv_is_pool_data(lv) ||
- lv_is_pool_metadata(lv)) {
- log_error("Can't use%s%s %s %s as external origin.",
- lv_is_locked(lv) ? " locked" : "",
- lv_is_visible(lv) ? "" : " hidden",
- lvseg_name(first_seg(lv)),
- display_lvname(lv));
- return 0;
- }
+ if ((origin_name = arg_str_value(cmd, originname_ARG, NULL)))
+ if (!validate_restricted_lvname_param(cmd, &vg->name, &origin_name))
+ return_0;
+
+ /*
+ * If NULL, an auto-generated 'lvol' name is used.
+ * If set, the lv create code checks the name isn't used.
+ */
+ lvc.lv_name = origin_name;
- if (is_lockd_type(lv->vg->lock_type)) {
+ if (is_lockd_type(vg->lock_type)) {
/*
* FIXME: external origins don't work in lockd VGs.
* Prior to the lvconvert, there's a lock associated with
@@ -2233,13 +2488,13 @@ static int _lvconvert_thin(struct cmd_context *cmd,
* lock for the new LV uuid used by the external LV.
*/
log_error("Can't use lock_type %s LV as external origin.",
- lv->vg->lock_type);
+ vg->lock_type);
return 0;
}
dm_list_init(&lvc.tags);
- if (!pool_supports_external_origin(first_seg(pool_lv), lv))
+ if (!pool_supports_external_origin(first_seg(thinpool_lv), lv))
return_0;
if (!(lvc.segtype = get_segtype_from_string(cmd, SEG_TYPE_NAME_THIN)))
@@ -2248,14 +2503,22 @@ static int _lvconvert_thin(struct cmd_context *cmd,
if (!archive(vg))
return_0;
- /* New thin LV needs to be created (all messages sent to pool)
- * In this case thin volume is created READ-ONLY and
- * also warn about not zeroing is suppressed. */
- if (!(torigin_lv = lv_create_single(vg, &lvc)))
+ /*
+ * New thin LV needs to be created (all messages sent to pool) In this
+ * case thin volume is created READ-ONLY and also warn about not
+ * zeroing is suppressed.
+ *
+ * The new thin LV is created with the origin_name, or an autogenerated
+ * 'lvol' name. Then the names and ids are swapped between the thin LV
+ * and the original/external LV. So, the thin LV gets the name and id
+ * of the original LV arg, and the original LV arg gets the origin_name
+ * or the autogenerated name.
+ */
+
+ if (!(thin_lv = lv_create_single(vg, &lvc)))
return_0;
- /* Deactivate prepared Thin LV */
- if (!deactivate_lv(cmd, torigin_lv)) {
+ if (!deactivate_lv(cmd, thin_lv)) {
log_error("Aborting. Unable to deactivate new LV. "
"Manual intervention required.");
return 0;
@@ -2266,47 +2529,45 @@ static int _lvconvert_thin(struct cmd_context *cmd,
* which could be easily removed by the user after i.e. power-off
*/
- if (!swap_lv_identifiers(cmd, torigin_lv, lv)) {
+ if (!swap_lv_identifiers(cmd, thin_lv, lv)) {
stack;
goto revert_new_lv;
}
/* Preserve read-write status of original LV here */
- torigin_lv->status |= (lv->status & LVM_WRITE);
+ thin_lv->status |= (lv->status & LVM_WRITE);
- if (!attach_thin_external_origin(first_seg(torigin_lv), lv)) {
+ if (!attach_thin_external_origin(first_seg(thin_lv), lv)) {
stack;
goto revert_new_lv;
}
- if (!lv_update_and_reload(torigin_lv)) {
+ if (!lv_update_and_reload(thin_lv)) {
stack;
goto deactivate_and_revert_new_lv;
}
- log_print_unless_silent("Converted %s to thin volume with "
- "external origin %s.",
- display_lvname(torigin_lv),
- display_lvname(lv));
+ log_print_unless_silent("Converted %s to thin volume with external origin %s.",
+ display_lvname(thin_lv), display_lvname(lv));
return 1;
deactivate_and_revert_new_lv:
- if (!swap_lv_identifiers(cmd, torigin_lv, lv))
+ if (!swap_lv_identifiers(cmd, thin_lv, lv))
stack;
- if (!deactivate_lv(cmd, torigin_lv)) {
+ if (!deactivate_lv(cmd, thin_lv)) {
log_error("Unable to deactivate failed new LV. "
"Manual intervention required.");
return 0;
}
- if (!detach_thin_external_origin(first_seg(torigin_lv)))
+ if (!detach_thin_external_origin(first_seg(thin_lv)))
return_0;
revert_new_lv:
/* FIXME Better to revert to backup of metadata? */
- if (!lv_remove(torigin_lv) || !vg_write(vg) || !vg_commit(vg))
+ if (!lv_remove(thin_lv) || !vg_write(vg) || !vg_commit(vg))
log_error("Manual intervention may be required to remove "
"abandoned LV(s) before retrying.");
else
@@ -2315,269 +2576,225 @@ revert_new_lv:
return 0;
}
-static int _lvconvert_to_thin_with_external(struct cmd_context *cmd,
- struct logical_volume *lv,
- struct logical_volume *thinpool_lv)
+static int _lvconvert_swap_pool_metadata(struct cmd_context *cmd,
+ struct logical_volume *lv,
+ struct logical_volume *metadata_lv)
{
struct volume_group *vg = lv->vg;
- struct logical_volume *thin_lv;
- const char *origin_name;
+ struct logical_volume *prev_metadata_lv;
+ struct lv_segment *seg;
+ struct lv_types *lvtype;
+ char meta_name[NAME_LEN];
+ const char *swap_name;
+ uint32_t chunk_size;
+ int is_thinpool;
+ int is_cachepool;
+ int lvt_enum;
- struct lvcreate_params lvc = {
- .activate = CHANGE_AEY,
- .alloc = ALLOC_INHERIT,
- .major = -1,
- .minor = -1,
- .suppress_zero_warn = 1, /* Suppress warning for this thin */
- .permission = LVM_READ,
- .pool_name = thinpool_lv->name,
- .pvh = &vg->pvs,
- .read_ahead = DM_READ_AHEAD_AUTO,
- .stripes = 1,
- .virtual_extents = lv->le_count,
- };
+ is_thinpool = lv_is_thin_pool(lv);
+ is_cachepool = lv_is_cache_pool(lv);
+ lvt_enum = get_lvt_enum(metadata_lv);
+ lvtype = get_lv_type(lvt_enum);
- if (lv == thinpool_lv) {
- log_error("Can't use same LV %s for thin pool and thin volume.",
- display_lvname(thinpool_lv));
+ if (lvt_enum != striped_LVT && lvt_enum != linear_LVT && lvt_enum != raid_LVT) {
+ log_error("LV %s with type %s cannot be used as a metadata LV.",
+ display_lvname(metadata_lv), lvtype ? lvtype->name : "unknown");
return 0;
}
- if ((origin_name = arg_str_value(cmd, originname_ARG, NULL)))
- if (!validate_restricted_lvname_param(cmd, &vg->name, &origin_name))
- return_0;
+ if (!lv_is_visible(metadata_lv)) {
+ log_error("Can't convert internal LV %s.",
+ display_lvname(metadata_lv));
+ return 0;
+ }
- /*
- * If NULL, an auto-generated 'lvol' name is used.
- * If set, the lv create code checks the name isn't used.
- */
- lvc.lv_name = origin_name;
+ if (lv_is_locked(metadata_lv)) {
+ log_error("Can't convert locked LV %s.",
+ display_lvname(metadata_lv));
+ return 0;
+ }
- if (is_lockd_type(vg->lock_type)) {
- /*
- * FIXME: external origins don't work in lockd VGs.
- * Prior to the lvconvert, there's a lock associated with
- * the uuid of the external origin LV. After the convert,
- * that uuid belongs to the new thin LV, and a new LV with
- * a new uuid exists as the non-thin, readonly external LV.
- * We'd need to remove the lock for the previous uuid
- * (the new thin LV will have no lock), and create a new
- * lock for the new LV uuid used by the external LV.
- */
- log_error("Can't use lock_type %s LV as external origin.",
- vg->lock_type);
+ if (lv_is_origin(metadata_lv) ||
+ lv_is_merging_origin(metadata_lv) ||
+ lv_is_external_origin(metadata_lv) ||
+ lv_is_virtual(metadata_lv)) {
+ log_error("Pool metadata LV %s is of an unsupported type.",
+ display_lvname(metadata_lv));
return 0;
}
- dm_list_init(&lvc.tags);
+ /* FIXME cache pool */
+ if (is_thinpool && pool_is_active(lv)) {
+ /* If any volume referencing pool active - abort here */
+ log_error("Cannot convert pool %s with active volumes.",
+ display_lvname(lv));
+ return 0;
+ }
- if (!pool_supports_external_origin(first_seg(thinpool_lv), lv))
- return_0;
+ if ((dm_snprintf(meta_name, sizeof(meta_name), "%s%s", lv->name, is_cachepool ? "_cmeta" : "_tmeta") < 0)) {
+ log_error("Failed to create internal lv names, pool name is too long.");
+ return 0;
+ }
- if (!(lvc.segtype = get_segtype_from_string(cmd, SEG_TYPE_NAME_THIN)))
- return_0;
+ seg = first_seg(lv);
- if (!archive(vg))
- return_0;
+ /* Normally do NOT change chunk size when swapping */
- /*
- * New thin LV needs to be created (all messages sent to pool) In this
- * case thin volume is created READ-ONLY and also warn about not
- * zeroing is suppressed.
- *
- * The new thin LV is created with the origin_name, or an autogenerated
- * 'lvol' name. Then the names and ids are swapped between the thin LV
- * and the original/external LV. So, the thin LV gets the name and id
- * of the original LV arg, and the original LV arg gets the origin_name
- * or the autogenerated name.
- */
+ if (arg_is_set(cmd, chunksize_ARG)) {
+ chunk_size = arg_uint_value(cmd, chunksize_ARG, 0);
- if (!(thin_lv = lv_create_single(vg, &lvc)))
- return_0;
+ if ((chunk_size != seg->chunk_size) && !dm_list_empty(&lv->segs_using_this_lv)) {
+ if (arg_count(cmd, force_ARG) == PROMPT) {
+ log_error("Chunk size can be only changed with --force. Conversion aborted.");
+ return 0;
+ }
- if (!deactivate_lv(cmd, thin_lv)) {
- log_error("Aborting. Unable to deactivate new LV. "
- "Manual intervention required.");
- return 0;
- }
+ if (!validate_pool_chunk_size(cmd, seg->segtype, chunk_size))
+ return_0;
- /*
- * Crashing till this point will leave plain thin volume
- * which could be easily removed by the user after i.e. power-off
- */
+ log_warn("WARNING: Changing chunk size %s to %s for %s pool volume.",
+ display_size(cmd, seg->chunk_size),
+ display_size(cmd, chunk_size),
+ display_lvname(lv));
- if (!swap_lv_identifiers(cmd, thin_lv, lv)) {
- stack;
- goto revert_new_lv;
- }
+ /* Ok, user has likely some serious reason for this */
+ if (!arg_count(cmd, yes_ARG) &&
+ yes_no_prompt("Do you really want to change chunk size for %s pool volume? [y/n]: ",
+ display_lvname(lv)) == 'n') {
+ log_error("Conversion aborted.");
+ return 0;
+ }
+ }
- /* Preserve read-write status of original LV here */
- thin_lv->status |= (lv->status & LVM_WRITE);
+ seg->chunk_size = chunk_size;
+ }
- if (!attach_thin_external_origin(first_seg(thin_lv), lv)) {
- stack;
- goto revert_new_lv;
+ if (!arg_count(cmd, yes_ARG) &&
+ yes_no_prompt("Do you want to swap metadata of %s pool with metadata volume %s? [y/n]: ",
+ display_lvname(lv),
+ display_lvname(metadata_lv)) == 'n') {
+ log_error("Conversion aborted.");
+ return 0;
}
- if (!lv_update_and_reload(thin_lv)) {
- stack;
- goto deactivate_and_revert_new_lv;
+ if (!deactivate_lv(cmd, metadata_lv)) {
+ log_error("Aborting. Failed to deactivate %s.",
+ display_lvname(metadata_lv));
+ return 0;
}
- log_print_unless_silent("Converted %s to thin volume with external origin %s.",
- display_lvname(thin_lv), display_lvname(lv));
+ if (!archive(vg))
+ return_0;
- return 1;
+ /* Swap names between old and new metadata LV */
-deactivate_and_revert_new_lv:
- if (!swap_lv_identifiers(cmd, thin_lv, lv))
- stack;
+ if (!detach_pool_metadata_lv(seg, &prev_metadata_lv))
+ return_0;
- if (!deactivate_lv(cmd, thin_lv)) {
- log_error("Unable to deactivate failed new LV. "
- "Manual intervention required.");
- return 0;
- }
+ swap_name = metadata_lv->name;
- if (!detach_thin_external_origin(first_seg(thin_lv)))
+ if (!lv_rename_update(cmd, metadata_lv, "pvmove_tmeta", 0))
return_0;
-revert_new_lv:
- /* FIXME Better to revert to backup of metadata? */
- if (!lv_remove(thin_lv) || !vg_write(vg) || !vg_commit(vg))
- log_error("Manual intervention may be required to remove "
- "abandoned LV(s) before retrying.");
- else
- backup(vg);
+ /* Give the previous metadata LV the name of the LV replacing it. */
- return 0;
-}
+ if (!lv_rename_update(cmd, prev_metadata_lv, swap_name, 0))
+ return_0;
-static int _lvconvert_update_pool_params(struct logical_volume *pool_lv,
- struct lvconvert_params *lp)
-{
- if (lp->pool_metadata_size &&
- !(lp->pool_metadata_extents =
- extents_from_size(pool_lv->vg->cmd, lp->pool_metadata_size, pool_lv->vg->extent_size)))
+ /* Rename deactivated metadata LV to have _tmeta suffix */
+
+ if (!lv_rename_update(cmd, metadata_lv, meta_name, 0))
+ return_0;
+
+ if (!attach_pool_metadata_lv(seg, metadata_lv))
+ return_0;
+
+ if (!vg_write(vg) || !vg_commit(vg))
return_0;
- return update_pool_params(lp->segtype,
- pool_lv->vg,
- lp->target_attr,
- lp->passed_args,
- pool_lv->le_count,
- &lp->pool_metadata_extents,
- &lp->thin_chunk_size_calc_policy,
- &lp->chunk_size,
- &lp->discards,
- &lp->zero);
+ backup(vg);
+ return 1;
}
/*
- * Converts a data lv and a metadata lv into a thin or cache pool lv.
- *
- * Thin lvconvert version which
- * rename metadata
- * convert/layers thinpool over data
- * attach metadata
- *
- * pool_lv might or might not already be a pool.
+ * Create a new pool LV, using the lv arg as the data sub LV.
+ * The metadata sub LV is either a new LV created here, or an
+ * existing LV specified by --poolmetadata.
*/
-static int _lvconvert_pool(struct cmd_context *cmd,
- struct logical_volume *pool_lv,
- struct lvconvert_params *lp)
+
+static int _lvconvert_to_pool(struct cmd_context *cmd,
+ struct logical_volume *lv,
+ int to_thinpool,
+ int to_cachepool,
+ struct dm_list *use_pvh)
{
- int r = 0;
- const char *old_name;
+ struct volume_group *vg = lv->vg;
+ struct logical_volume *metadata_lv = NULL; /* existing or created */
+ struct logical_volume *data_lv; /* lv arg renamed */
+ struct logical_volume *pool_lv; /* new lv created here */
+ const char *pool_metadata_name; /* user-specified lv name */
+ const char *pool_name; /* name of original lv arg */
+ char meta_name[NAME_LEN]; /* generated sub lv name */
+ char data_name[NAME_LEN]; /* generated sub lv name */
+ struct segment_type *pool_segtype; /* thinpool or cachepool */
struct lv_segment *seg;
- struct volume_group *vg = pool_lv->vg;
- struct logical_volume *data_lv;
- struct logical_volume *metadata_lv = NULL;
- struct logical_volume *pool_metadata_lv;
+ unsigned int target_attr = ~0;
+ unsigned int passed_args = 0;
+ unsigned int activate_pool;
+ unsigned int zero_metadata;
+ uint64_t meta_size;
+ uint32_t meta_extents;
+ uint32_t chunk_size;
+ int chunk_calc;
+ int r = 0;
+
+ /* for handling lvmlockd cases */
char *lockd_data_args = NULL;
char *lockd_meta_args = NULL;
char *lockd_data_name = NULL;
char *lockd_meta_name = NULL;
struct id lockd_data_id;
struct id lockd_meta_id;
- char metadata_name[NAME_LEN], data_name[NAME_LEN];
- int zero_metadata = 1;
- int activate_pool;
-
- if (lp->pool_data_name) {
- if ((lp->thin || lp->cache) &&
- !strcmp(lp->pool_data_name, pool_lv->name)) {
- log_error("Converted volume %s and pool volume must differ.",
- display_lvname(pool_lv));
- return 0;
- }
- if (!(pool_lv = find_lv(vg, lp->pool_data_name))) {
- log_error("Unknown pool data LV %s.", lp->pool_data_name);
- return 0;
- }
- }
-
- /* An existing LV needs to have its lock freed once it becomes a data LV. */
- if (is_lockd_type(vg->lock_type) && !lv_is_pool(pool_lv) && pool_lv->lock_args) {
- lockd_data_args = dm_pool_strdup(cmd->mem, pool_lv->lock_args);
- lockd_data_name = dm_pool_strdup(cmd->mem, pool_lv->name);
- memcpy(&lockd_data_id, &pool_lv->lvid.id[1], sizeof(struct id));
- }
- if (!lv_is_visible(pool_lv)) {
- log_error("Can't convert internal LV %s.", display_lvname(pool_lv));
- return 0;
- }
- if (lv_is_locked(pool_lv)) {
- log_error("Can't convert locked LV %s.", display_lvname(pool_lv));
+ if (lv_is_thin_pool(lv) || lv_is_cache_pool(lv)) {
+ log_error(INTERNAL_ERROR "LV %s is already a pool.", display_lvname(lv));
return 0;
}
- if (lv_is_thin_pool(pool_lv) && (segtype_is_cache_pool(lp->segtype) || lp->cache)) {
- log_error("Can't convert thin pool LV %s.", display_lvname(pool_lv));
- return 0;
- }
+ pool_segtype = to_cachepool ? get_segtype_from_string(cmd, SEG_TYPE_NAME_CACHE_POOL) :
+ get_segtype_from_string(cmd, SEG_TYPE_NAME_THIN_POOL);
- if (lv_is_cache(pool_lv) && !segtype_is_thin_pool(lp->segtype)) {
- log_error("Cached LV %s could be only converted into a thin pool volume.",
- display_lvname(pool_lv));
+ if (!pool_segtype->ops->target_present(cmd, NULL, &target_attr)) {
+ log_error("%s: Required device-mapper target(s) not detected in your kernel.", pool_segtype->name);
return 0;
}
- if (lv_is_cache_pool(pool_lv) && (segtype_is_thin_pool(lp->segtype) || lp->thin)) {
- log_error("Cannot convert cache pool %s as pool data volume.",
- display_lvname(pool_lv));
- return 0;
- }
+ /* Allow to have only thinpool active and restore it's active state. */
+ activate_pool = to_thinpool && lv_is_active(lv);
- if (lv_is_mirror(pool_lv)) {
- log_error("Mirror logical volumes cannot be used as pools.");
- log_print_unless_silent("Try \"%s\" segment type instead.", SEG_TYPE_NAME_RAID1);
- return 0;
+ /* Wipe metadata_lv by default, but allow skipping this for cache pools. */
+ zero_metadata = to_cachepool ? arg_int_value(cmd, zero_ARG, 1) : 1;
+
+ /* An existing LV needs to have its lock freed once it becomes a data LV. */
+ if (is_lockd_type(vg->lock_type) && lv->lock_args) {
+ lockd_data_args = dm_pool_strdup(cmd->mem, lv->lock_args);
+ lockd_data_name = dm_pool_strdup(cmd->mem, lv->name);
+ memcpy(&lockd_data_id, &lv->lvid.id[1], sizeof(struct id));
}
/*
- * Only linear, striped and raid supported.
- * FIXME Tidy up all these type restrictions.
+ * If an existing LV is to be used as the metadata LV,
+ * verify that it's in a usable state. These checks are
+ * not done by command def rules because this LV is not
+ * processed by process_each_lv.
*/
- if (!lv_is_pool(pool_lv) &&
- (lv_is_thin_type(pool_lv) ||
- lv_is_cow(pool_lv) || lv_is_merging_cow(pool_lv) ||
- lv_is_origin(pool_lv) ||lv_is_merging_origin(pool_lv) ||
- lv_is_external_origin(pool_lv) ||
- lv_is_virtual(pool_lv))) {
- log_error("Pool data LV %s is of an unsupported type.", display_lvname(pool_lv));
- return 0;
- }
- if (lp->pool_metadata_name) {
- if (!(lp->pool_metadata_lv = find_lv(vg, lp->pool_metadata_name))) {
- log_error("Unknown pool metadata LV %s.", lp->pool_metadata_name);
+ if ((pool_metadata_name = arg_str_value(cmd, poolmetadata_ARG, NULL))) {
+ if (!(metadata_lv = find_lv(vg, pool_metadata_name))) {
+ log_error("Unknown pool metadata LV %s.", pool_metadata_name);
return 0;
}
- lp->pool_metadata_extents = lp->pool_metadata_lv->le_count;
- metadata_lv = lp->pool_metadata_lv;
/* An existing LV needs to have its lock freed once it becomes a meta LV. */
if (is_lockd_type(vg->lock_type) && metadata_lv->lock_args) {
@@ -2586,7 +2803,7 @@ static int _lvconvert_pool(struct cmd_context *cmd,
memcpy(&lockd_meta_id, &metadata_lv->lvid.id[1], sizeof(struct id));
}
- if (metadata_lv == pool_lv) {
+ if (metadata_lv == lv) {
log_error("Can't use same LV for pool data and metadata LV %s.",
display_lvname(metadata_lv));
return 0;
@@ -2621,199 +2838,152 @@ static int _lvconvert_pool(struct cmd_context *cmd,
display_lvname(metadata_lv));
return 0;
}
-
- if (!lv_is_pool(pool_lv)) {
- if (!_lvconvert_update_pool_params(pool_lv, lp))
- return_0;
-
- if (lp->pool_metadata_extents > metadata_lv->le_count) {
- log_error("Logical volume %s is too small for metadata.",
- display_lvname(metadata_lv));
- return 0;
- }
- }
}
- if (lv_is_pool(pool_lv)) {
- lp->pool_data_lv = pool_lv;
+ /*
+ * Determine the size of the metadata LV and the chunk size. When an
+ * existing LV is to be used for metadata, this introduces some
+ * constraints/defaults. When chunk_size=0 and/or meta_extents=0 are
+ * passed to the "update params" function, defaults are calculated and
+ * returned.
+ */
- if (!metadata_lv) {
- if (arg_from_list_is_set(cmd, "is invalid with existing pool",
- discards_ARG,
- poolmetadatasize_ARG, -1))
- return_0;
+ if (arg_is_set(cmd, chunksize_ARG)) {
+ passed_args |= PASS_ARG_CHUNK_SIZE;
+ chunk_size = arg_uint_value(cmd, chunksize_ARG, 0);
+ if (!validate_pool_chunk_size(cmd, pool_segtype, chunk_size))
+ return_0;
+ } else {
+ /* A default will be chosen by the "update" function. */
+ chunk_size = 0;
+ }
- if (lp->thin &&
- arg_from_list_is_set(cmd, "is invalid with existing thin pool",
- chunksize_ARG, zero_ARG, -1))
- return_0;
+ if (arg_is_set(cmd, poolmetadatasize_ARG)) {
+ meta_size = arg_uint64_value(cmd, poolmetadatasize_ARG, UINT64_C(0));
+ meta_extents = extents_from_size(cmd, meta_size, vg->extent_size);
+ passed_args |= PASS_ARG_POOL_METADATA_SIZE;
+ } else if (metadata_lv) {
+ meta_extents = metadata_lv->le_count;
+ passed_args |= PASS_ARG_POOL_METADATA_SIZE;
+ } else {
+ /* A default will be chosen by the "update" function. */
+ meta_extents = 0;
+ }
- if (lp->cache) {
- if (!lp->chunk_size)
- lp->chunk_size = first_seg(pool_lv)->chunk_size;
-
- if (!validate_lv_cache_chunk_size(pool_lv, lp->chunk_size))
- return_0;
-
- /* Check is user requested zeroing logic via [-Z y|n] */
- if (!arg_is_set(cmd, zero_ARG)) {
- /* Note: requires rather deep know-how to skip zeroing */
- if (!lp->yes &&
- yes_no_prompt("Do you want wipe existing metadata of "
- "cache pool volume %s? [y/n]: ",
- display_lvname(pool_lv)) == 'n') {
- log_error("Conversion aborted.");
- log_error("To preserve cache metadata add option \"--zero n\".");
- log_warn("WARNING: Reusing mismatched cache pool metadata "
- "MAY DESTROY YOUR DATA!");
- return 0;
- }
- /* Wiping confirmed, go ahead */
- if (!wipe_cache_pool(pool_lv))
- return_0;
- } else if (arg_int_value(cmd, zero_ARG, 0)) {
- if (!wipe_cache_pool(pool_lv)) /* Wipe according to -Z y|n */
- return_0;
- } else
- log_warn("WARNING: Reusing cache pool metadata %s "
- "for volume caching.", display_lvname(pool_lv));
- }
+ /* Tell the "update" function to ignore these, they are handled below. */
+ passed_args |= PASS_ARG_DISCARDS | PASS_ARG_ZERO;
- if (lp->thin || lp->cache)
- /* already pool, can continue converting volume */
- return 1;
+ /*
+ * Validate and/or choose defaults for meta_extents and chunk_size,
+ * this involves some complicated calculations.
+ */
- log_error("LV %s is already pool.", display_lvname(pool_lv));
- return 0;
- }
+ if (to_cachepool) {
+ if (!update_cache_pool_params(pool_segtype, vg, target_attr,
+ passed_args, lv->le_count,
+ &meta_extents,
+ &chunk_calc,
+ &chunk_size))
+ return_0;
+ } else {
+ if (!update_thin_pool_params(pool_segtype, vg, target_attr,
+ passed_args, lv->le_count,
+ &meta_extents,
+ &chunk_calc,
+ &chunk_size,
+ NULL, NULL))
+ return_0;
+ }
- if (lp->thin || lp->cache) {
- log_error("--%s and pool metadata swap is not supported.",
- lp->thin ? "thin" : "cache");
- return 0;
- }
+ if ((uint64_t)chunk_size > ((uint64_t)lv->le_count * vg->extent_size)) {
+ log_error("Pool data LV %s is too small (%s) for specified chunk size (%s).",
+ display_lvname(lv),
+ display_size(cmd, (uint64_t)lv->le_count * vg->extent_size),
+ display_size(cmd, chunk_size));
+ return 0;
+ }
- /* FIXME cache pool */
- if (lv_is_thin_pool(pool_lv) && pool_is_active(pool_lv)) {
- /* If any volume referencing pool active - abort here */
- log_error("Cannot convert pool %s with active volumes.",
- display_lvname(pool_lv));
- return 0;
- }
+ if (metadata_lv && (meta_extents > metadata_lv->le_count)) {
+ log_error("Pool metadata LV %s is too small (%u extents) for required metadata (%u extents).",
+ display_lvname(metadata_lv), metadata_lv->le_count, meta_extents);
+ return 0;
+ }
- lp->passed_args |= PASS_ARG_CHUNK_SIZE | PASS_ARG_DISCARDS | PASS_ARG_ZERO;
- seg = first_seg(pool_lv);
+ log_verbose("Pool metadata extents %u chunk_size %u", meta_extents, chunk_size);
- /* Normally do NOT change chunk size when swapping */
- if (arg_is_set(cmd, chunksize_ARG) &&
- (lp->chunk_size != seg->chunk_size) &&
- !dm_list_empty(&pool_lv->segs_using_this_lv)) {
- if (lp->force == PROMPT) {
- log_error("Chunk size can be only changed with --force. Conversion aborted.");
- return 0;
- }
- log_warn("WARNING: Changing chunk size %s to "
- "%s for %s pool volume.",
- display_size(cmd, seg->chunk_size),
- display_size(cmd, lp->chunk_size),
- display_lvname(pool_lv));
- /* Ok, user has likely some serious reason for this */
- if (!lp->yes &&
- yes_no_prompt("Do you really want to change chunk size "
- "for %s pool volume? [y/n]: ",
- display_lvname(pool_lv)) == 'n') {
- log_error("Conversion aborted.");
- return 0;
- }
- } else
- lp->chunk_size = seg->chunk_size;
- if (!_lvconvert_update_pool_params(pool_lv, lp))
- return_0;
+ /*
+ * Verify that user wants to use these LVs.
+ */
- if (metadata_lv->le_count < lp->pool_metadata_extents)
- log_print_unless_silent("Continuing with swap...");
+ log_warn("WARNING: Converting logical volume %s%s%s to %s pool's data%s %s metadata wiping.",
+ display_lvname(lv),
+ metadata_lv ? " and " : "",
+ metadata_lv ? display_lvname(metadata_lv) : "",
+ to_cachepool ? "cache" : "thin",
+ metadata_lv ? " and metadata volumes" : " volume",
+ zero_metadata ? "with" : "WITHOUT");
- if (!arg_is_set(cmd, discards_ARG))
- lp->discards = seg->discards;
- if (!arg_is_set(cmd, zero_ARG))
- lp->zero = seg->zero_new_blocks;
+ if (zero_metadata)
+ log_warn("THIS WILL DESTROY CONTENT OF LOGICAL VOLUME (filesystem etc.)");
+ else if (to_cachepool)
+ log_warn("WARNING: Using mismatched cache pool metadata MAY DESTROY YOUR DATA!");
- if (!lp->yes &&
- yes_no_prompt("Do you want to swap metadata of %s "
- "pool with metadata volume %s? [y/n]: ",
- display_lvname(pool_lv),
- display_lvname(metadata_lv)) == 'n') {
- log_error("Conversion aborted.");
- return 0;
- }
- } else {
- /* Only cache pool conversion may suppress metadata zeroing
- * TODO: Maybe similar support could be useful for thin-pool, but --zero
- * is already overloade and we would also need to possibly match transaction Id. */
- if (segtype_is_cache_pool(lp->segtype) && metadata_lv)
- /* Check is user requested zeroing logic via [-Z y|n] (default is yes) */
- zero_metadata = arg_int_value(cmd, zero_ARG, 1);
-
- log_warn("WARNING: Converting logical volume %s%s%s to %s pool's data%s %s metadata wiping.",
- display_lvname(pool_lv),
- metadata_lv ? " and " : "",
- metadata_lv ? display_lvname(metadata_lv) : "",
- segtype_is_cache_pool(lp->segtype) ? "cache" : "thin",
- metadata_lv ? " and metadata volumes" : " volume",
- zero_metadata ? "with" : "WITHOUT");
-
- if (zero_metadata)
- log_warn("THIS WILL DESTROY CONTENT OF LOGICAL VOLUME (filesystem etc.)");
- else /* ATM supported only for cache pools */
- log_warn("WARNING: Using mismatched cache pool metadata "
- "MAY DESTROY YOUR DATA!");
-
- if (!lp->yes &&
- yes_no_prompt("Do you really want to convert %s%s%s? [y/n]: ",
- display_lvname(pool_lv),
- metadata_lv ? " and " : "",
- metadata_lv ? display_lvname(metadata_lv) : "") == 'n') {
- log_error("Conversion aborted.");
- return 0;
- }
+ if (!arg_count(cmd, yes_ARG) &&
+ yes_no_prompt("Do you really want to convert %s%s%s? [y/n]: ",
+ display_lvname(lv),
+ metadata_lv ? " and " : "",
+ metadata_lv ? display_lvname(metadata_lv) : "") == 'n') {
+ log_error("Conversion aborted.");
+ return 0;
}
- if (segtype_is_cache_pool(lp->segtype))
- activate_pool = 0; /* Cannot activate cache pool */
- else
- /* Allow to have only thinpool active and restore it's active state */
- activate_pool = lv_is_active(pool_lv);
-
- if ((dm_snprintf(metadata_name, sizeof(metadata_name), "%s%s",
- pool_lv->name,
- (segtype_is_cache_pool(lp->segtype)) ?
- "_cmeta" : "_tmeta") < 0) ||
- (dm_snprintf(data_name, sizeof(data_name), "%s%s",
- pool_lv->name,
- (segtype_is_cache_pool(lp->segtype)) ?
- "_cdata" : "_tdata") < 0)) {
- log_error("Failed to create internal lv names, "
- "pool name is too long.");
+ /*
+ * The internal LV names for pool data/meta LVs.
+ */
+
+ if ((dm_snprintf(meta_name, sizeof(meta_name), "%s%s", lv->name, to_cachepool ? "_cmeta" : "_tmeta") < 0) ||
+ (dm_snprintf(data_name, sizeof(data_name), "%s%s", lv->name, to_cachepool ? "_cdata" : "_tdata") < 0)) {
+ log_error("Failed to create internal lv names, pool name is too long.");
return 0;
}
+ /*
+ * If a new metadata LV needs to be created, collect the settings for
+ * the new LV and create it.
+ *
+ * If an existing LV is used for metadata, deactivate/activate/wipe it.
+ */
+
if (!metadata_lv) {
- if (!_lvconvert_update_pool_params(pool_lv, lp))
- return_0;
+ uint32_t meta_stripes;
+ uint32_t meta_stripe_size;
+ uint32_t meta_readahead;
+ alloc_policy_t meta_alloc;
+ unsigned meta_stripes_supplied;
+ unsigned meta_stripe_size_supplied;
if (!get_stripe_params(cmd, get_segtype_from_string(cmd, SEG_TYPE_NAME_STRIPED),
- &lp->stripes, &lp->stripe_size, &lp->stripes_supplied, &lp->stripe_size_supplied))
+ &meta_stripes,
+ &meta_stripe_size,
+ &meta_stripes_supplied,
+ &meta_stripe_size_supplied))
return_0;
+ meta_readahead = arg_uint_value(cmd, readahead_ARG, cmd->default_settings.read_ahead);
+ meta_alloc = (alloc_policy_t) arg_uint_value(cmd, alloc_ARG, ALLOC_INHERIT);
+
if (!archive(vg))
return_0;
- if (!(metadata_lv = alloc_pool_metadata(pool_lv, metadata_name,
- lp->read_ahead, lp->stripes,
- lp->stripe_size,
- lp->pool_metadata_extents,
- lp->alloc, lp->pvh)))
+ if (!(metadata_lv = alloc_pool_metadata(lv,
+ meta_name,
+ meta_readahead,
+ meta_stripes,
+ meta_stripe_size,
+ meta_extents,
+ meta_alloc,
+ use_pvh)))
return_0;
} else {
if (!deactivate_lv(cmd, metadata_lv)) {
@@ -2825,21 +2995,6 @@ static int _lvconvert_pool(struct cmd_context *cmd,
if (!archive(vg))
return_0;
- /* Swap normal LV with pool's metadata LV ? */
- if (lv_is_pool(pool_lv)) {
- /* Swap names between old and new metadata LV */
- seg = first_seg(pool_lv);
- if (!detach_pool_metadata_lv(seg, &pool_metadata_lv))
- return_0;
- old_name = metadata_lv->name;
- if (!lv_rename_update(cmd, metadata_lv, "pvmove_tmeta", 0))
- return_0;
- if (!lv_rename_update(cmd, pool_metadata_lv, old_name, 0))
- return_0;
-
- goto mda_write;
- }
-
if (zero_metadata) {
metadata_lv->status |= LV_TEMPORARY;
if (!activate_lv_local(cmd, metadata_lv)) {
@@ -2854,41 +3009,66 @@ static int _lvconvert_pool(struct cmd_context *cmd,
}
}
- /* We are changing target type, so deactivate first */
+ /*
+ * Deactivate the data LV and metadata LV.
+ * We are changing target type, so deactivate first.
+ */
+
if (!deactivate_lv(cmd, metadata_lv)) {
log_error("Aborting. Failed to deactivate metadata lv. "
"Manual intervention required.");
return 0;
}
- if (!deactivate_lv(cmd, pool_lv)) {
+ if (!deactivate_lv(cmd, lv)) {
log_error("Aborting. Failed to deactivate logical volume %s.",
- display_lvname(pool_lv));
+ display_lvname(lv));
return 0;
}
- data_lv = pool_lv;
- old_name = data_lv->name; /* Use for pool name */
/*
+ * When the LV referenced by the original function arg "lv"
+ * is renamed, it is then referenced as "data_lv".
+ *
+ * pool_name pool name taken from lv arg
+ * data_name sub lv name, generated
+ * meta_name sub lv name, generated
+ *
+ * pool_lv new lv for pool object, created here
+ * data_lv sub lv, was lv arg, now renamed
+ * metadata_lv sub lv, existing or created here
+ */
+
+ data_lv = lv;
+ pool_name = lv->name; /* Use original LV name for pool name */
+
+ /*
+ * Rename the original LV arg to the internal data LV naming scheme.
+ *
* Since we wish to have underlaying devs to match _[ct]data
* rename data LV to match pool LV subtree first,
* also checks for visible LV.
+ *
+ * FIXME: any more types prohibited here?
*/
- /* FIXME: any more types prohibited here? */
+
if (!lv_rename_update(cmd, data_lv, data_name, 0))
return_0;
- if (!(pool_lv = lv_create_empty(old_name, NULL,
- ((segtype_is_cache_pool(lp->segtype)) ?
- CACHE_POOL : THIN_POOL) |
- VISIBLE_LV | LVM_READ | LVM_WRITE,
+ /*
+ * Create LV structures for the new pool LV object,
+ * and connect it to the data/meta LVs.
+ */
+
+ if (!(pool_lv = lv_create_empty(pool_name, NULL,
+ (to_cachepool ? CACHE_POOL : THIN_POOL) | VISIBLE_LV | LVM_READ | LVM_WRITE,
ALLOC_INHERIT, vg))) {
log_error("Creation of pool LV failed.");
return 0;
}
/* Allocate a new pool segment */
- if (!(seg = alloc_lv_segment(lp->segtype, pool_lv, 0, data_lv->le_count,
+ if (!(seg = alloc_lv_segment(pool_segtype, pool_lv, 0, data_lv->le_count,
pool_lv->status, 0, NULL, 1,
data_lv->le_count, 0, 0, 0, NULL)))
return_0;
@@ -2907,7 +3087,7 @@ static int _lvconvert_pool(struct cmd_context *cmd,
* data and meta LVs (they are unlocked and deleted below.)
*/
if (is_lockd_type(vg->lock_type)) {
- if (segtype_is_cache_pool(lp->segtype)) {
+ if (to_cachepool) {
data_lv->lock_args = NULL;
metadata_lv->lock_args = NULL;
} else {
@@ -2919,1763 +3099,182 @@ static int _lvconvert_pool(struct cmd_context *cmd,
else if (!strcmp(vg->lock_type, "dlm"))
pool_lv->lock_args = "dlm";
/* The lock_args will be set in vg_write(). */
- }
- }
-
- /* FIXME: revert renamed LVs in fail path? */
- /* FIXME: any common code with metadata/thin_manip.c extend_pool() ? */
-
- seg->transaction_id = 0;
-
-mda_write:
- seg->chunk_size = lp->chunk_size;
- seg->discards = lp->discards;
- seg->zero_new_blocks = lp->zero ? 1 : 0;
-
- if (lp->cache_mode &&
- !cache_set_cache_mode(seg, lp->cache_mode))
- return_0;
-
- if ((lp->policy_name || lp->policy_settings) &&
- !cache_set_policy(seg, lp->policy_name, lp->policy_settings))
- return_0;
-
- /* Rename deactivated metadata LV to have _tmeta suffix */
- /* Implicit checks if metadata_lv is visible */
- if (lp->pool_metadata_name &&
- !lv_rename_update(cmd, metadata_lv, metadata_name, 0))
- return_0;
-
- if (!attach_pool_metadata_lv(seg, metadata_lv))
- return_0;
-
- if (!handle_pool_metadata_spare(vg, metadata_lv->le_count,
- lp->pvh, lp->poolmetadataspare))
- return_0;
-
- if (!vg_write(vg) || !vg_commit(vg))
- return_0;
-
- if (seg->zero_new_blocks &&
- seg->chunk_size >= DEFAULT_THIN_POOL_CHUNK_SIZE_PERFORMANCE * 2)
- log_warn("WARNING: Pool zeroing and large %s chunk size slows down "
- "provisioning.", display_size(cmd, seg->chunk_size));
-
- if (activate_pool && !lockd_lv(cmd, pool_lv, "ex", LDLV_PERSISTENT)) {
- log_error("Failed to lock pool LV %s.", display_lvname(pool_lv));
- goto out;
- }
-
- if (activate_pool &&
- !activate_lv_excl(cmd, pool_lv)) {
- log_error("Failed to activate pool logical volume %s.",
- display_lvname(pool_lv));
- /* Deactivate subvolumes */
- if (!deactivate_lv(cmd, seg_lv(seg, 0)))
- log_error("Failed to deactivate pool data logical volume %s.",
- display_lvname(seg_lv(seg, 0)));
- if (!deactivate_lv(cmd, seg->metadata_lv))
- log_error("Failed to deactivate pool metadata logical volume %s.",
- display_lvname(seg->metadata_lv));
- goto out;
- }
-
- r = 1;
- lp->pool_data_lv = pool_lv;
-
-out:
- backup(vg);
-
- if (r)
- log_print_unless_silent("Converted %s to %s pool.",
- display_lvname(pool_lv),
- (segtype_is_cache_pool(lp->segtype)) ?
- "cache" : "thin");
-
- /*
- * Unlock and free the locks from existing LVs that became pool data
- * and meta LVs.
- */
- if (lockd_data_name) {
- if (!lockd_lv_name(cmd, vg, lockd_data_name, &lockd_data_id, lockd_data_args, "un", LDLV_PERSISTENT))
- log_error("Failed to unlock pool data LV %s/%s", vg->name, lockd_data_name);
- lockd_free_lv(cmd, vg, lockd_data_name, &lockd_data_id, lockd_data_args);
- }
-
- if (lockd_meta_name) {
- if (!lockd_lv_name(cmd, vg, lockd_meta_name, &lockd_meta_id, lockd_meta_args, "un", LDLV_PERSISTENT))
- log_error("Failed to unlock pool metadata LV %s/%s", vg->name, lockd_meta_name);
- lockd_free_lv(cmd, vg, lockd_meta_name, &lockd_meta_id, lockd_meta_args);
- }
-
- return r;
-#if 0
-revert_new_lv:
- /* TBD */
- if (!lp->pool_metadata_lv_name) {
- if (!deactivate_lv(cmd, metadata_lv)) {
- log_error("Failed to deactivate metadata lv.");
- return 0;
- }
- if (!lv_remove(metadata_lv) || !vg_write(vg) || !vg_commit(vg))
- log_error("Manual intervention may be required to remove "
- "abandoned LV(s) before retrying.");
- else
- backup(vg);
- }
-
- return 0;
-#endif
-}
-
-static int _lvconvert_swap_pool_metadata(struct cmd_context *cmd,
- struct logical_volume *lv,
- struct logical_volume *metadata_lv)
-{
- struct volume_group *vg = lv->vg;
- struct logical_volume *prev_metadata_lv;
- struct lv_segment *seg;
- struct lv_types *lvtype;
- char meta_name[NAME_LEN];
- const char *swap_name;
- uint32_t chunk_size;
- int is_thinpool;
- int is_cachepool;
- int lvt_enum;
-
- is_thinpool = lv_is_thin_pool(lv);
- is_cachepool = lv_is_cache_pool(lv);
- lvt_enum = get_lvt_enum(metadata_lv);
- lvtype = get_lv_type(lvt_enum);
-
- if (lvt_enum != striped_LVT && lvt_enum != linear_LVT && lvt_enum != raid_LVT) {
- log_error("LV %s with type %s cannot be used as a metadata LV.",
- display_lvname(metadata_lv), lvtype ? lvtype->name : "unknown");
- return 0;
- }
-
- if (!lv_is_visible(metadata_lv)) {
- log_error("Can't convert internal LV %s.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- if (lv_is_locked(metadata_lv)) {
- log_error("Can't convert locked LV %s.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- if (lv_is_origin(metadata_lv) ||
- lv_is_merging_origin(metadata_lv) ||
- lv_is_external_origin(metadata_lv) ||
- lv_is_virtual(metadata_lv)) {
- log_error("Pool metadata LV %s is of an unsupported type.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- /* FIXME cache pool */
- if (is_thinpool && pool_is_active(lv)) {
- /* If any volume referencing pool active - abort here */
- log_error("Cannot convert pool %s with active volumes.",
- display_lvname(lv));
- return 0;
- }
-
- if ((dm_snprintf(meta_name, sizeof(meta_name), "%s%s", lv->name, is_cachepool ? "_cmeta" : "_tmeta") < 0)) {
- log_error("Failed to create internal lv names, pool name is too long.");
- return 0;
- }
-
- seg = first_seg(lv);
-
- /* Normally do NOT change chunk size when swapping */
-
- if (arg_is_set(cmd, chunksize_ARG)) {
- chunk_size = arg_uint_value(cmd, chunksize_ARG, 0);
-
- if ((chunk_size != seg->chunk_size) && !dm_list_empty(&lv->segs_using_this_lv)) {
- if (arg_count(cmd, force_ARG) == PROMPT) {
- log_error("Chunk size can be only changed with --force. Conversion aborted.");
- return 0;
- }
-
- if (!validate_pool_chunk_size(cmd, seg->segtype, chunk_size))
- return_0;
-
- log_warn("WARNING: Changing chunk size %s to %s for %s pool volume.",
- display_size(cmd, seg->chunk_size),
- display_size(cmd, chunk_size),
- display_lvname(lv));
-
- /* Ok, user has likely some serious reason for this */
- if (!arg_count(cmd, yes_ARG) &&
- yes_no_prompt("Do you really want to change chunk size for %s pool volume? [y/n]: ",
- display_lvname(lv)) == 'n') {
- log_error("Conversion aborted.");
- return 0;
- }
- }
-
- seg->chunk_size = chunk_size;
- }
-
- if (!arg_count(cmd, yes_ARG) &&
- yes_no_prompt("Do you want to swap metadata of %s pool with metadata volume %s? [y/n]: ",
- display_lvname(lv),
- display_lvname(metadata_lv)) == 'n') {
- log_error("Conversion aborted.");
- return 0;
- }
-
- if (!deactivate_lv(cmd, metadata_lv)) {
- log_error("Aborting. Failed to deactivate %s.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- if (!archive(vg))
- return_0;
-
- /* Swap names between old and new metadata LV */
-
- if (!detach_pool_metadata_lv(seg, &prev_metadata_lv))
- return_0;
-
- swap_name = metadata_lv->name;
-
- if (!lv_rename_update(cmd, metadata_lv, "pvmove_tmeta", 0))
- return_0;
-
- /* Give the previous metadata LV the name of the LV replacing it. */
-
- if (!lv_rename_update(cmd, prev_metadata_lv, swap_name, 0))
- return_0;
-
- /* Rename deactivated metadata LV to have _tmeta suffix */
-
- if (!lv_rename_update(cmd, metadata_lv, meta_name, 0))
- return_0;
-
- if (!attach_pool_metadata_lv(seg, metadata_lv))
- return_0;
-
- if (!vg_write(vg) || !vg_commit(vg))
- return_0;
-
- backup(vg);
- return 1;
-}
-
-/*
- * Create a new pool LV, using the lv arg as the data sub LV.
- * The metadata sub LV is either a new LV created here, or an
- * existing LV specified by --poolmetadata.
- */
-
-static int _lvconvert_to_pool(struct cmd_context *cmd,
- struct logical_volume *lv,
- int to_thinpool,
- int to_cachepool,
- struct dm_list *use_pvh)
-{
- struct volume_group *vg = lv->vg;
- struct logical_volume *metadata_lv = NULL; /* existing or created */
- struct logical_volume *data_lv; /* lv arg renamed */
- struct logical_volume *pool_lv; /* new lv created here */
- const char *pool_metadata_name; /* user-specified lv name */
- const char *pool_name; /* name of original lv arg */
- char meta_name[NAME_LEN]; /* generated sub lv name */
- char data_name[NAME_LEN]; /* generated sub lv name */
- struct segment_type *pool_segtype; /* thinpool or cachepool */
- struct lv_segment *seg;
- unsigned int target_attr = ~0;
- unsigned int passed_args = 0;
- unsigned int activate_pool;
- unsigned int zero_metadata;
- uint64_t meta_size;
- uint32_t meta_extents;
- uint32_t chunk_size;
- int chunk_calc;
- int r = 0;
-
- /* for handling lvmlockd cases */
- char *lockd_data_args = NULL;
- char *lockd_meta_args = NULL;
- char *lockd_data_name = NULL;
- char *lockd_meta_name = NULL;
- struct id lockd_data_id;
- struct id lockd_meta_id;
-
-
- if (lv_is_thin_pool(lv) || lv_is_cache_pool(lv)) {
- log_error(INTERNAL_ERROR "LV %s is already a pool.", display_lvname(lv));
- return 0;
- }
-
- pool_segtype = to_cachepool ? get_segtype_from_string(cmd, SEG_TYPE_NAME_CACHE_POOL) :
- get_segtype_from_string(cmd, SEG_TYPE_NAME_THIN_POOL);
-
- if (!pool_segtype->ops->target_present(cmd, NULL, &target_attr)) {
- log_error("%s: Required device-mapper target(s) not detected in your kernel.", pool_segtype->name);
- return 0;
- }
-
- /* Allow to have only thinpool active and restore it's active state. */
- activate_pool = to_thinpool && lv_is_active(lv);
-
- /* Wipe metadata_lv by default, but allow skipping this for cache pools. */
- zero_metadata = to_cachepool ? arg_int_value(cmd, zero_ARG, 1) : 1;
-
- /* An existing LV needs to have its lock freed once it becomes a data LV. */
- if (is_lockd_type(vg->lock_type) && lv->lock_args) {
- lockd_data_args = dm_pool_strdup(cmd->mem, lv->lock_args);
- lockd_data_name = dm_pool_strdup(cmd->mem, lv->name);
- memcpy(&lockd_data_id, &lv->lvid.id[1], sizeof(struct id));
- }
-
- /*
- * If an existing LV is to be used as the metadata LV,
- * verify that it's in a usable state. These checks are
- * not done by command def rules because this LV is not
- * processed by process_each_lv.
- */
-
- if ((pool_metadata_name = arg_str_value(cmd, poolmetadata_ARG, NULL))) {
- if (!(metadata_lv = find_lv(vg, pool_metadata_name))) {
- log_error("Unknown pool metadata LV %s.", pool_metadata_name);
- return 0;
- }
-
- /* An existing LV needs to have its lock freed once it becomes a meta LV. */
- if (is_lockd_type(vg->lock_type) && metadata_lv->lock_args) {
- lockd_meta_args = dm_pool_strdup(cmd->mem, metadata_lv->lock_args);
- lockd_meta_name = dm_pool_strdup(cmd->mem, metadata_lv->name);
- memcpy(&lockd_meta_id, &metadata_lv->lvid.id[1], sizeof(struct id));
- }
-
- if (metadata_lv == lv) {
- log_error("Can't use same LV for pool data and metadata LV %s.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- if (!lv_is_visible(metadata_lv)) {
- log_error("Can't convert internal LV %s.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- if (lv_is_locked(metadata_lv)) {
- log_error("Can't convert locked LV %s.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- if (lv_is_mirror(metadata_lv)) {
- log_error("Mirror logical volumes cannot be used for pool metadata.");
- log_print_unless_silent("Try \"%s\" segment type instead.", SEG_TYPE_NAME_RAID1);
- return 0;
- }
-
- /* FIXME Tidy up all these type restrictions. */
- if (lv_is_cache_type(metadata_lv) ||
- lv_is_thin_type(metadata_lv) ||
- lv_is_cow(metadata_lv) || lv_is_merging_cow(metadata_lv) ||
- lv_is_origin(metadata_lv) || lv_is_merging_origin(metadata_lv) ||
- lv_is_external_origin(metadata_lv) ||
- lv_is_virtual(metadata_lv)) {
- log_error("Pool metadata LV %s is of an unsupported type.",
- display_lvname(metadata_lv));
- return 0;
- }
- }
-
- /*
- * Determine the size of the metadata LV and the chunk size. When an
- * existing LV is to be used for metadata, this introduces some
- * constraints/defaults. When chunk_size=0 and/or meta_extents=0 are
- * passed to the "update params" function, defaults are calculated and
- * returned.
- */
-
- if (arg_is_set(cmd, chunksize_ARG)) {
- passed_args |= PASS_ARG_CHUNK_SIZE;
- chunk_size = arg_uint_value(cmd, chunksize_ARG, 0);
- if (!validate_pool_chunk_size(cmd, pool_segtype, chunk_size))
- return_0;
- } else {
- /* A default will be chosen by the "update" function. */
- chunk_size = 0;
- }
-
- if (arg_is_set(cmd, poolmetadatasize_ARG)) {
- meta_size = arg_uint64_value(cmd, poolmetadatasize_ARG, UINT64_C(0));
- meta_extents = extents_from_size(cmd, meta_size, vg->extent_size);
- passed_args |= PASS_ARG_POOL_METADATA_SIZE;
- } else if (metadata_lv) {
- meta_extents = metadata_lv->le_count;
- passed_args |= PASS_ARG_POOL_METADATA_SIZE;
- } else {
- /* A default will be chosen by the "update" function. */
- meta_extents = 0;
- }
-
- /* Tell the "update" function to ignore these, they are handled below. */
- passed_args |= PASS_ARG_DISCARDS | PASS_ARG_ZERO;
-
- /*
- * Validate and/or choose defaults for meta_extents and chunk_size,
- * this involves some complicated calculations.
- */
-
- if (to_cachepool) {
- if (!update_cache_pool_params(pool_segtype, vg, target_attr,
- passed_args, lv->le_count,
- &meta_extents,
- &chunk_calc,
- &chunk_size))
- return_0;
- } else {
- if (!update_thin_pool_params(pool_segtype, vg, target_attr,
- passed_args, lv->le_count,
- &meta_extents,
- &chunk_calc,
- &chunk_size,
- NULL, NULL))
- return_0;
- }
-
- if ((uint64_t)chunk_size > ((uint64_t)lv->le_count * vg->extent_size)) {
- log_error("Pool data LV %s is too small (%s) for specified chunk size (%s).",
- display_lvname(lv),
- display_size(cmd, (uint64_t)lv->le_count * vg->extent_size),
- display_size(cmd, chunk_size));
- return 0;
- }
-
- if (metadata_lv && (meta_extents > metadata_lv->le_count)) {
- log_error("Pool metadata LV %s is too small (%u extents) for required metadata (%u extents).",
- display_lvname(metadata_lv), metadata_lv->le_count, meta_extents);
- return 0;
- }
-
- log_verbose("Pool metadata extents %u chunk_size %u", meta_extents, chunk_size);
-
-
- /*
- * Verify that user wants to use these LVs.
- */
-
- log_warn("WARNING: Converting logical volume %s%s%s to %s pool's data%s %s metadata wiping.",
- display_lvname(lv),
- metadata_lv ? " and " : "",
- metadata_lv ? display_lvname(metadata_lv) : "",
- to_cachepool ? "cache" : "thin",
- metadata_lv ? " and metadata volumes" : " volume",
- zero_metadata ? "with" : "WITHOUT");
-
- if (zero_metadata)
- log_warn("THIS WILL DESTROY CONTENT OF LOGICAL VOLUME (filesystem etc.)");
- else if (to_cachepool)
- log_warn("WARNING: Using mismatched cache pool metadata MAY DESTROY YOUR DATA!");
-
- if (!arg_count(cmd, yes_ARG) &&
- yes_no_prompt("Do you really want to convert %s%s%s? [y/n]: ",
- display_lvname(lv),
- metadata_lv ? " and " : "",
- metadata_lv ? display_lvname(metadata_lv) : "") == 'n') {
- log_error("Conversion aborted.");
- return 0;
- }
-
- /*
- * The internal LV names for pool data/meta LVs.
- */
-
- if ((dm_snprintf(meta_name, sizeof(meta_name), "%s%s", lv->name, to_cachepool ? "_cmeta" : "_tmeta") < 0) ||
- (dm_snprintf(data_name, sizeof(data_name), "%s%s", lv->name, to_cachepool ? "_cdata" : "_tdata") < 0)) {
- log_error("Failed to create internal lv names, pool name is too long.");
- return 0;
- }
-
- /*
- * If a new metadata LV needs to be created, collect the settings for
- * the new LV and create it.
- *
- * If an existing LV is used for metadata, deactivate/activate/wipe it.
- */
-
- if (!metadata_lv) {
- uint32_t meta_stripes;
- uint32_t meta_stripe_size;
- uint32_t meta_readahead;
- alloc_policy_t meta_alloc;
- unsigned meta_stripes_supplied;
- unsigned meta_stripe_size_supplied;
-
- if (!get_stripe_params(cmd, get_segtype_from_string(cmd, SEG_TYPE_NAME_STRIPED),
- &meta_stripes,
- &meta_stripe_size,
- &meta_stripes_supplied,
- &meta_stripe_size_supplied))
- return_0;
-
- meta_readahead = arg_uint_value(cmd, readahead_ARG, cmd->default_settings.read_ahead);
- meta_alloc = (alloc_policy_t) arg_uint_value(cmd, alloc_ARG, ALLOC_INHERIT);
-
- if (!archive(vg))
- return_0;
-
- if (!(metadata_lv = alloc_pool_metadata(lv,
- meta_name,
- meta_readahead,
- meta_stripes,
- meta_stripe_size,
- meta_extents,
- meta_alloc,
- use_pvh)))
- return_0;
- } else {
- if (!deactivate_lv(cmd, metadata_lv)) {
- log_error("Aborting. Failed to deactivate %s.",
- display_lvname(metadata_lv));
- return 0;
- }
-
- if (!archive(vg))
- return_0;
-
- if (zero_metadata) {
- metadata_lv->status |= LV_TEMPORARY;
- if (!activate_lv_local(cmd, metadata_lv)) {
- log_error("Aborting. Failed to activate metadata lv.");
- return 0;
- }
-
- if (!wipe_lv(metadata_lv, (struct wipe_params) { .do_zero = 1 })) {
- log_error("Aborting. Failed to wipe metadata lv.");
- return 0;
- }
- }
- }
-
- /*
- * Deactivate the data LV and metadata LV.
- * We are changing target type, so deactivate first.
- */
-
- if (!deactivate_lv(cmd, metadata_lv)) {
- log_error("Aborting. Failed to deactivate metadata lv. "
- "Manual intervention required.");
- return 0;
- }
-
- if (!deactivate_lv(cmd, lv)) {
- log_error("Aborting. Failed to deactivate logical volume %s.",
- display_lvname(lv));
- return 0;
- }
-
- /*
- * When the LV referenced by the original function arg "lv"
- * is renamed, it is then referenced as "data_lv".
- *
- * pool_name pool name taken from lv arg
- * data_name sub lv name, generated
- * meta_name sub lv name, generated
- *
- * pool_lv new lv for pool object, created here
- * data_lv sub lv, was lv arg, now renamed
- * metadata_lv sub lv, existing or created here
- */
-
- data_lv = lv;
- pool_name = lv->name; /* Use original LV name for pool name */
-
- /*
- * Rename the original LV arg to the internal data LV naming scheme.
- *
- * Since we wish to have underlaying devs to match _[ct]data
- * rename data LV to match pool LV subtree first,
- * also checks for visible LV.
- *
- * FIXME: any more types prohibited here?
- */
-
- if (!lv_rename_update(cmd, data_lv, data_name, 0))
- return_0;
-
- /*
- * Create LV structures for the new pool LV object,
- * and connect it to the data/meta LVs.
- */
-
- if (!(pool_lv = lv_create_empty(pool_name, NULL,
- (to_cachepool ? CACHE_POOL : THIN_POOL) | VISIBLE_LV | LVM_READ | LVM_WRITE,
- ALLOC_INHERIT, vg))) {
- log_error("Creation of pool LV failed.");
- return 0;
- }
-
- /* Allocate a new pool segment */
- if (!(seg = alloc_lv_segment(pool_segtype, pool_lv, 0, data_lv->le_count,
- pool_lv->status, 0, NULL, 1,
- data_lv->le_count, 0, 0, 0, NULL)))
- return_0;
-
- /* Add the new segment to the layer LV */
- dm_list_add(&pool_lv->segments, &seg->list);
- pool_lv->le_count = data_lv->le_count;
- pool_lv->size = data_lv->size;
-
- if (!attach_pool_data_lv(seg, data_lv))
- return_0;
-
- /*
- * Create a new lock for a thin pool LV. A cache pool LV has no lock.
- * Locks are removed from existing LVs that are being converted to
- * data and meta LVs (they are unlocked and deleted below.)
- */
- if (is_lockd_type(vg->lock_type)) {
- if (to_cachepool) {
- data_lv->lock_args = NULL;
- metadata_lv->lock_args = NULL;
- } else {
- data_lv->lock_args = NULL;
- metadata_lv->lock_args = NULL;
-
- if (!strcmp(vg->lock_type, "sanlock"))
- pool_lv->lock_args = "pending";
- else if (!strcmp(vg->lock_type, "dlm"))
- pool_lv->lock_args = "dlm";
- /* The lock_args will be set in vg_write(). */
- }
- }
-
- /*
- * Apply settings to the new pool seg, from command line, from
- * defaults, sometimes adjusted.
- */
-
- seg->transaction_id = 0;
- seg->chunk_size = chunk_size;
-
- if (to_cachepool) {
- cache_mode_t cache_mode = 0;
- const char *policy_name = NULL;
- struct dm_config_tree *policy_settings = NULL;
-
- if (!get_cache_params(cmd, &cache_mode, &policy_name, &policy_settings))
- return_0;
-
- if (cache_mode &&
- !cache_set_cache_mode(seg, cache_mode))
- return_0;
-
- if ((policy_name || policy_settings) &&
- !cache_set_policy(seg, policy_name, policy_settings))
- return_0;
-
- if (policy_settings)
- dm_config_destroy(policy_settings);
- } else {
- const char *discards_name;
-
- if (arg_is_set(cmd, zero_ARG))
- seg->zero_new_blocks = arg_int_value(cmd, zero_ARG, 0);
- else
- seg->zero_new_blocks = find_config_tree_bool(cmd, allocation_thin_pool_zero_CFG, vg->profile);
-
- if (arg_is_set(cmd, discards_ARG))
- seg->discards = (thin_discards_t) arg_uint_value(cmd, discards_ARG, THIN_DISCARDS_PASSDOWN);
- else {
- if (!(discards_name = find_config_tree_str(cmd, allocation_thin_pool_discards_CFG, vg->profile)))
- return_0;
- if (!set_pool_discards(&seg->discards, discards_name))
- return_0;
- }
- }
-
- /*
- * Rename deactivated metadata LV to have _tmeta suffix.
- * Implicit checks if metadata_lv is visible.
- */
- if (pool_metadata_name &&
- !lv_rename_update(cmd, metadata_lv, meta_name, 0))
- return_0;
-
- if (!attach_pool_metadata_lv(seg, metadata_lv))
- return_0;
-
- if (!handle_pool_metadata_spare(vg,
- metadata_lv->le_count,
- use_pvh,
- arg_int_value(cmd, poolmetadataspare_ARG, DEFAULT_POOL_METADATA_SPARE)))
- return_0;
-
- if (!vg_write(vg) || !vg_commit(vg))
- return_0;
-
- if (seg->zero_new_blocks &&
- seg->chunk_size >= DEFAULT_THIN_POOL_CHUNK_SIZE_PERFORMANCE * 2)
- log_warn("WARNING: Pool zeroing and large %s chunk size slows down provisioning.",
- display_size(cmd, seg->chunk_size));
-
- if (activate_pool && !lockd_lv(cmd, pool_lv, "ex", LDLV_PERSISTENT)) {
- log_error("Failed to lock pool LV %s.", display_lvname(pool_lv));
- goto out;
- }
-
- if (activate_pool &&
- !activate_lv_excl(cmd, pool_lv)) {
- log_error("Failed to activate pool logical volume %s.",
- display_lvname(pool_lv));
- /* Deactivate subvolumes */
- if (!deactivate_lv(cmd, seg_lv(seg, 0)))
- log_error("Failed to deactivate pool data logical volume %s.",
- display_lvname(seg_lv(seg, 0)));
- if (!deactivate_lv(cmd, seg->metadata_lv))
- log_error("Failed to deactivate pool metadata logical volume %s.",
- display_lvname(seg->metadata_lv));
- goto out;
- }
-
- r = 1;
-
-out:
- backup(vg);
-
- if (r)
- log_print_unless_silent("Converted %s to %s pool.",
- display_lvname(lv),
- to_cachepool ? "cache" : "thin");
-
- /*
- * Unlock and free the locks from existing LVs that became pool data
- * and meta LVs.
- */
- if (lockd_data_name) {
- if (!lockd_lv_name(cmd, vg, lockd_data_name, &lockd_data_id, lockd_data_args, "un", LDLV_PERSISTENT))
- log_error("Failed to unlock pool data LV %s/%s", vg->name, lockd_data_name);
- lockd_free_lv(cmd, vg, lockd_data_name, &lockd_data_id, lockd_data_args);
- }
-
- if (lockd_meta_name) {
- if (!lockd_lv_name(cmd, vg, lockd_meta_name, &lockd_meta_id, lockd_meta_args, "un", LDLV_PERSISTENT))
- log_error("Failed to unlock pool metadata LV %s/%s", vg->name, lockd_meta_name);
- lockd_free_lv(cmd, vg, lockd_meta_name, &lockd_meta_id, lockd_meta_args);
- }
-
- return r;
-#if 0
-revert_new_lv:
- /* TBD */
- if (!pool_metadata_lv_name) {
- if (!deactivate_lv(cmd, metadata_lv)) {
- log_error("Failed to deactivate metadata lv.");
- return 0;
- }
- if (!lv_remove(metadata_lv) || !vg_write(vg) || !vg_commit(vg))
- log_error("Manual intervention may be required to remove "
- "abandoned LV(s) before retrying.");
- else
- backup(vg);
- }
-
- return 0;
-#endif
-}
-
-/*
- * Convert origin into a cache LV by attaching a cache pool.
- */
-static int _lvconvert_cache(struct cmd_context *cmd,
- struct logical_volume *origin_lv,
- struct lvconvert_params *lp)
-{
- struct logical_volume *pool_lv = lp->pool_data_lv;
- struct logical_volume *cache_lv;
-
- if (!validate_lv_cache_create_pool(pool_lv))
- return_0;
-
- if (!archive(origin_lv->vg))
- return_0;
-
- if (!(cache_lv = lv_cache_create(pool_lv, origin_lv)))
- return_0;
-
- if (!cache_set_cache_mode(first_seg(cache_lv), lp->cache_mode))
- return_0;
-
- if (!cache_set_policy(first_seg(cache_lv), lp->policy_name, lp->policy_settings))
- return_0;
-
- cache_check_for_warns(first_seg(cache_lv));
-
- if (!lv_update_and_reload(cache_lv))
- return_0;
-
- log_print_unless_silent("Logical volume %s is now cached.",
- display_lvname(cache_lv));
-
- return 1;
-}
-
-static int _lvconvert_to_cache_vol(struct cmd_context *cmd,
- struct logical_volume *lv,
- struct logical_volume *cachepool_lv)
-{
- struct logical_volume *cache_lv;
- cache_mode_t cache_mode = 0;
- const char *policy_name = NULL;
- struct dm_config_tree *policy_settings = NULL;
-
- if (!validate_lv_cache_create_pool(cachepool_lv))
- return_0;
-
- if (!get_cache_params(cmd, &cache_mode, &policy_name, &policy_settings))
- return_0;
-
- if (!archive(lv->vg))
- return_0;
-
- if (!(cache_lv = lv_cache_create(cachepool_lv, lv)))
- return_0;
-
- if (!cache_set_cache_mode(first_seg(cache_lv), cache_mode))
- return_0;
-
- if (!cache_set_policy(first_seg(cache_lv), policy_name, policy_settings))
- return_0;
-
- if (policy_settings)
- dm_config_destroy(policy_settings);
-
- cache_check_for_warns(first_seg(cache_lv));
-
- if (!lv_update_and_reload(cache_lv))
- return_0;
-
- log_print_unless_silent("Logical volume %s is now cached.",
- display_lvname(cache_lv));
-
- return 1;
-}
-
-/*
- * Functions called to perform a specific operation on a specific LV type.
- *
- * _convert_<lvtype>_<operation>
- *
- * For cases where an operation does not apply to the LV itself, but
- * is implicitly redirected to a sub-LV, these functions locate the
- * correct sub-LV and call the operation on that sub-LV. If a sub-LV
- * of the proper type is not found, these functions report the error.
- *
- * FIXME: the _lvconvert_foo() functions can be cleaned up since they
- * are now only called for valid combinations of LV type and operation.
- * After that happens, the code remaining in those functions can be
- * moved into the _convert_lvtype_operation() functions below.
- */
-
-/*
- * Separate a COW snapshot LV from its origin.
- * lvconvert --splitsnapshot LV
- */
-static int _convert_cow_snapshot_splitsnapshot(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_splitsnapshot(cmd, lv);
-}
-
-/*
- * Merge a COW snapshot LV into its origin.
- * lvconvert --merge LV
- */
-static int _convert_cow_snapshot_merge(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* return _lvconvert_merge_old_snapshot(cmd, lv, lp); */
-}
-
-/*
- * Merge a snapshot thin LV into its origin.
- * lvconvert --merge LV
- */
-
-static int _convert_thin_volume_merge(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_merge_thin_snapshot(cmd, lv);
-}
-
-/*
- * Split and preserve a cache pool from the data portion of a thin pool LV.
- * lvconvert --splitcache LV
- */
-static int _convert_thin_pool_splitcache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- struct logical_volume *sublv1;
-
- sublv1 = seg_lv(first_seg(lv), 0); /* cached _tdata ? */
-
- if (!lv_is_cache(sublv1)) {
- log_error("Sub LV %s must be cache.", display_lvname(sublv1));
- return 0;
- }
-
- /* return _lvconvert_split_cached(cmd, sublv1); */
- return 0;
-}
-
-/*
- * Split and remove a cache pool from the data portion of a thin pool LV.
- * lvconvert --uncache LV
- */
-static int _convert_thin_pool_uncache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- struct logical_volume *sublv1 = NULL;
-
- sublv1 = seg_lv(first_seg(lv), 0); /* cached _tdata ? */
-
- if (!lv_is_cache(sublv1)) {
- log_error("Sub LV %s must be cache.", display_lvname(sublv1));
- return 0;
- }
-
- /* return _lvconvert_uncache(cmd, sublv1, lp); */
- return 0;
-}
-
-/*
- * Convert the data portion of a thin pool LV to a cache LV.
- * lvconvert --type cache LV
- *
- * Required options:
- * --cachepool LV
- *
- * Auxiliary operation:
- * Converts the --cachepool arg to a cache pool if it is not already.
- *
- * Alternate syntax:
- * lvconvert --cache LV
- */
-static int _convert_thin_pool_cache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* lvconvert --type cache includes an implicit conversion of the cachepool arg to type cache-pool. */
- if (!_lvconvert_pool(cmd, lv, lp)) {
- log_error("Implicit conversion of --cachepool arg to type cache-pool failed.");
- return 0;
- }
-
- /* Do we need to grab the tdata sub LV to pass on? */
-
- return _lvconvert_cache(cmd, lv, lp);
-}
-
-/*
- * Replace the metadata LV in a thin pool LV.
- * lvconvert --poolmetadata NewLV --thinpool LV
- * FIXME: this will change so --swap-poolmetadata defines the operation.
- * FIXME: should be lvconvert --swap-poolmetadata NewLV LV
- */
-static int _convert_thin_pool_swapmetadata(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_pool(cmd, lv, lp);
-}
-
-/*
- * Split and preserve a cache pool from a cache LV.
- * lvconvert --splitcache LV
- */
-static int _convert_cache_volume_splitcache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* return _lvconvert_split_cached(cmd, lv); */
- return 0;
-}
-
-/*
- * Split and remove a cache pool from a cache LV.
- * lvconvert --uncache LV
- */
-static int _convert_cache_volume_uncache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* return _lvconvert_uncache(cmd, lv, lp); */
- return 0;
-}
-
-/*
- * Split images from the raid1|mirror origin of a cache LV and use them to create a new LV.
- * lvconvert --splitmirrors Number LV
- *
- * Required options:
- * --trackchanges | --name Name
- */
-static int _convert_cache_volume_splitmirrors(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- struct logical_volume *sublv1;
-
- sublv1 = seg_lv(first_seg(lv), 0);
-
- if (lv_is_raid(sublv1))
- return _lvconvert_raid(sublv1, lp);
-
- if (lv_is_mirror(sublv1))
- return _lvconvert_mirrors(cmd, lv, lp);
-
- log_error("Sub LV %s must be raid or mirror.", display_lvname(sublv1));
- return 0;
-}
-
-/*
- * Convert a cache LV to a thin pool (using the cache LV for thin pool data).
- * lvconvert --type thin-pool LV
- *
- * Convert a cache LV to a thin volume with cached external origin using given
- * thinpool tpLV (when not yet Thinpool convert it to thin-pool first).
- * Conversion is 2-step process in this case.
- * Only writethrough cacheLV can be converted as external origin is read-only.
- * lvconvert --thin cacheLV --thinpool tpLV
- *
- * Alternate syntax:
- * This is equivalent to above, but not preferred because it's ambiguous and inconsistent.
- * lvconvert --thinpool LV
- */
-static int _convert_cache_volume_thin_pool(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- int is_clean;
- const struct lv_segment *pool_seg;
-
- if (!_lvconvert_pool(cmd, lv, lp))
- return_0;
-
- if (lv_is_cache(lv) && !lv_is_pool_data(lv)) {
- pool_seg = first_seg(first_seg(lv)->pool_lv);
- if (pool_seg->cache_mode != CACHE_MODE_WRITETHROUGH) {
- log_error("Cannot convert cache volume %s with %s cache mode to external origin.",
- display_lvname(lv),
- get_cache_mode_name(pool_seg));
- log_error("To proceed, run 'lvchange --cachemode writethrough %s'.",
- display_lvname(lv));
- return 0;
- }
-
- if (!lv_cache_wait_for_clean(lv, &is_clean))
- return_0;
-
- if (!is_clean) {
- log_error("Cache %s is not clean, refusing to convert to external origin.",
- display_lvname(lv));
- return 0;
- }
-
- if (!_lvconvert_thin(cmd, lv, lp))
- return_0;
- }
-
- return 1;
-}
-
-/*
- * Convert/Recombine cacheLV to be an origin for snapshot
- * lvconvert --type snapshot cacheLV snapshotLV
- */
-static int _convert_cache_volume_snapshot(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_snapshot(cmd, lv, lp->origin_name);
-}
-
-/*
- * Split a cache volume from a cache pool LV.
- * lvconvert --splitcache LV
- */
-static int _convert_cache_pool_splitcache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- struct logical_volume *sublv1;
- struct lv_segment *seg;
-
- /* When passed used cache-pool of used cached LV -> split cached LV */
-
- if ((dm_list_size(&lv->segs_using_this_lv) == 1) &&
- (seg = get_only_segment_using_this_lv(lv)) &&
- seg_is_cache(seg))
- sublv1 = seg->lv;
- else {
- log_error("Sub LV of cache type not found.");
- return 0;
- }
-
- if (!lv_is_cache(sublv1)) {
- log_error("Sub LV %s must be cache.", display_lvname(sublv1));
- return 0;
- }
-
- /* return _lvconvert_split_cached(cmd, sublv1); */
- return 0;
-}
-
-/*
- * Replace the metadata LV in a cache pool LV.
- * lvconvert --poolmetadata NewLV --cachepool LV
- * FIXME: this will change so --swap-poolmetadata defines the operation.
- * FIXME: should be lvconvert --swap-poolmetadata NewLV LV
- */
-static int _convert_cache_pool_swapmetadata(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_pool(cmd, lv, lp);
-}
-
-/*
- * Change the number of images in a mirror LV.
- * lvconvert --mirrors Number LV
- */
-static int _convert_mirror_number(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_mirrors(cmd, lv, lp);
-}
-
-/*
- * Split images from a mirror LV and use them to create a new LV.
- * lvconvert --splitmirrors Number LV
- *
- * Required options:
- * --name Name
- */
-
-static int _convert_mirror_splitmirrors(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_mirrors(cmd, lv, lp);
-}
-
-/*
- * Change the type of log used by a mirror LV.
- * lvconvert --mirrorlog Type LV
- */
-static int _convert_mirror_log(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_mirrors(cmd, lv, lp);
-}
-
-/*
- * Convert mirror LV to linear LV.
- * lvconvert --type linear LV
- *
- * Alternate syntax:
- * lvconvert --mirrors 0 LV
- */
-static int _convert_mirror_linear(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_mirrors(cmd, lv, lp);
-}
-
-/*
- * Convert mirror LV to raid1 LV.
- * lvconvert --type raid1 LV
- */
-static int _convert_mirror_raid(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Change the number of images in a raid1 LV.
- * lvconvert --mirrors Number LV
- */
-static int _convert_raid_number(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Split images from a raid1 LV and use them to create a new LV.
- * lvconvert --splitmirrors Number LV
- *
- * Required options:
- * --trackchanges | --name Name
- */
-static int _convert_raid_splitmirrors(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* FIXME: split the splitmirrors section out of _lvconvert_raid and call it here. */
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Merge a raid1 LV into originalLV if the raid1 LV was
- * previously split from the originalLV using --trackchanges.
- * lvconvert --merge LV
- */
-static int _convert_raid_merge(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* FIXME: split the merge section out of _lvconvert_raid and call it here. */
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Combine a raid* LV with a snapshot LV that was previously
- * split from the raid* LV using --splitsnapshot.
- * lvconvert --type snapshot LV SnapshotLV
- *
- * Alternate syntax:
- * lvconvert --snapshot LV SnapshotLV
- */
-static int _convert_raid_snapshot(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_snapshot(cmd, lv, lp->origin_name);
-}
-
-/*
- * Convert a raid* LV to a thin LV with an external origin.
- * lvconvert --type thin LV
- *
- * Required options:
- * --thinpool LV
- *
- * Auxiliary operation:
- * Converts the --thinpool arg to a thin pool if it is not already.
- *
- * Alternate syntax:
- * lvconvert --thin LV
- */
-static int _convert_raid_thin(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* lvconvert --thin includes an implicit conversion of the thinpool arg to type thin-pool. */
- if (!_lvconvert_pool(cmd, lv, lp)) {
- log_error("Implicit conversion of --thinpool arg to type thin-pool failed.");
- return 0;
- }
-
- return _lvconvert_thin(cmd, lv, lp);
-}
-
-/*
- * Convert a raid* LV to a cache LV.
- * lvconvert --type cache LV
- *
- * Required options:
- * --cachepool LV
- *
- * Auxiliary operation:
- * Converts the --cachepool arg to a cache pool if it is not already.
- *
- * Alternate syntax:
- * lvconvert --cache LV
- */
-static int _convert_raid_cache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* lvconvert --type cache includes an implicit conversion of the cachepool arg to type cache-pool. */
- if (!_lvconvert_pool(cmd, lv, lp)) {
- log_error("Implicit conversion of --cachepool arg to type cache-pool failed.");
- return 0;
- }
-
- return _lvconvert_cache(cmd, lv, lp);
-}
-
-/*
- * Convert a raid* LV to a thin-pool LV.
- * lvconvert --type thin-pool LV
- *
- * Alternate syntax:
- * This is equivalent to above, but not preferred because it's ambiguous and inconsistent.
- * lvconvert --thinpool LV
- */
-static int _convert_raid_thin_pool(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_pool(cmd, lv, lp);
-}
-
-/*
- * Convert a raid* LV to cache-pool LV.
- * lvconvert --type cache-pool LV
- */
-static int _convert_raid_cache_pool(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_pool(cmd, lv, lp);
-}
-
-/*
- * Convert a raid* LV to use a different raid level.
- * lvconvert --type raid* LV
- */
-static int _convert_raid_raid(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Convert a raid* LV to a mirror LV.
- * lvconvert --type mirror LV
- */
-static int _convert_raid_mirror(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Convert a raid* LV to a striped LV.
- * lvconvert --type striped LV
- */
-static int _convert_raid_striped(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Convert a raid* LV to a linear LV.
- * lvconvert --type linear LV
- */
-static int _convert_raid_linear(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Merge a striped/linear LV into a raid1 LV if the striped/linear LV was
- * previously split from the raid1 LV using --trackchanges.
- * lvconvert --merge LV
- */
-static int _convert_striped_merge(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Combine a linear/striped LV with a snapshot LV that was previously
- * split from the linear/striped LV using --splitsnapshot.
- * lvconvert --type snapshot LV SnapshotLV
- *
- * Alternate syntax:
- * lvconvert --snapshot LV SnapshotLV
- */
-static int _convert_striped_snapshot(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_snapshot(cmd, lv, lp->origin_name);
-}
-
-/*
- * Convert a striped/linear LV to a thin LV with an external origin.
- * lvconvert --type thin LV
- *
- * Required options:
- * --thinpool LV
- *
- * Auxiliary operation:
- * Converts the --thinpool arg to a thin pool if it is not already.
- *
- * Alternate syntax:
- * lvconvert --thin LV
- */
-static int _convert_striped_thin(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* lvconvert --thin includes an implicit conversion of the thinpool arg to type thin-pool. */
- if (!_lvconvert_pool(cmd, lv, lp)) {
- log_error("Conversion of --thinpool arg to type thin-pool failed.");
- return 0;
- }
-
- return _lvconvert_thin(cmd, lv, lp);
-}
-
-/*
- * Convert a striped/linear LV to a cache LV.
- * lvconvert --type cache LV
- *
- * Required options:
- * --cachepool LV
- *
- * Auxiliary operation:
- * Converts the --cachepool arg to a cache pool if it is not already.
- *
- * Alternate syntax:
- * lvconvert --cache LV
- */
-
-static int _convert_striped_cache(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* lvconvert --cache includes an implicit conversion of the cachepool arg to type cache-pool. */
- if (!_lvconvert_pool(cmd, lv, lp)) {
- log_error("Conversion of --cachepool arg to type cache-pool failed.");
- return 0;
- }
-
- return _lvconvert_cache(cmd, lv, lp);
-}
-
-/*
- * Convert a striped/linear LV to a thin-pool LV.
- * lvconvert --type thin-pool LV
- *
- * Alternate syntax:
- * This is equivalent to above, but not preferred because it's ambiguous and inconsistent.
- * lvconvert --thinpool LV
- */
-static int _convert_striped_thin_pool(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_pool(cmd, lv, lp);
-}
-
-/*
- * Convert a striped/linear LV to a cache-pool LV.
- * lvconvert --type cache-pool LV
- */
-static int _convert_striped_cache_pool(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_pool(cmd, lv, lp);
-}
-
-/*
- * Convert a striped/linear LV to a mirror LV.
- * lvconvert --type mirror LV
- *
- * Required options:
- * --mirrors Number
- *
- * Alternate syntax:
- * This is equivalent to above when global/mirror_segtype_default="mirror".
- * lvconvert --mirrors Number LV
- */
-static int _convert_striped_mirror(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_mirrors(cmd, lv, lp);
-}
-
-/*
- * Convert a striped/linear LV to a raid* LV.
- * lvconvert --type raid* LV
- *
- * Required options:
- * --mirrors Number
- *
- * Alternate syntax:
- * This is equivalent to above when global/mirror_segtype_default="raid1".
- * lvconvert --mirrors Number LV
- */
-static int _convert_striped_raid(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- return _lvconvert_raid(lv, lp);
-}
-
-/*
- * Functions called to perform all valid operations on a given LV type.
- *
- * _convert_<lvtype>
- */
-static int _convert_cow_snapshot(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- if (lp->splitsnapshot)
- return _convert_cow_snapshot_splitsnapshot(cmd, lv, lp);
-
- /* FIXME: add --merge-snapshot to make this distinct from --merge-mirror. */
- if (lp->merge)
- return _convert_cow_snapshot_merge(cmd, lv, lp);
-
- log_error("Operation not permitted on COW snapshot LV %s.", display_lvname(lv));
- log_error("Operations permitted on a COW snapshot LV are:\n"
- " --splitsnapshot\n"
- " --merge\n");
- return 0;
-}
-
-static int _convert_thin_volume(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- /* FIXME: add --merge-snapshot to make this distinct from --merge-mirror. */
- if (lp->merge)
- return _convert_thin_volume_merge(cmd, lv, lp);
-
- log_error("Operation not permitted on thin LV %s.", display_lvname(lv));
- log_error("Operations permitted on a thin LV are:\n"
- " --merge\n");
- return 0;
-}
-
-static int _convert_thin_pool(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- if (lp->splitcache)
- return _convert_thin_pool_splitcache(cmd, lv, lp);
-
- if (lp->split)
- return _convert_thin_pool_splitcache(cmd, lv, lp);
-
- if (lp->uncache)
- return _convert_thin_pool_uncache(cmd, lv, lp);
-
- if (lp->cache)
- return _convert_thin_pool_cache(cmd, lv, lp);
-
- /* FIXME: swapping the thin pool metadata LV needs a specific option like --swapmetadata */
- if (arg_is_set(cmd, poolmetadata_ARG))
- return _convert_thin_pool_swapmetadata(cmd, lv, lp);
-
- /* FIXME: add --swapmetadata to list of permitted operations. */
-
- log_error("Operation not permitted on thin pool LV %s.", display_lvname(lv));
- log_error("Operations permitted on a thin pool LV are:\n"
- " --splitcache (operates on cache sub LV)\n"
- " --uncache (operates on cache sub LV)\n"
- " --type cache (operates on data sub LV)\n"
- " --repair\n");
- return 0;
-}
-
-static int _convert_cache_volume(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- if (lp->splitcache)
- return _convert_cache_volume_splitcache(cmd, lv, lp);
-
- if (lp->split)
- return _convert_cache_volume_splitcache(cmd, lv, lp);
-
- if (lp->uncache)
- return _convert_cache_volume_uncache(cmd, lv, lp);
-
- if (arg_is_set(cmd, splitmirrors_ARG))
- return _convert_cache_volume_splitmirrors(cmd, lv, lp);
-
- if (!strcmp(lp->type_str, SEG_TYPE_NAME_THIN_POOL) ||
- arg_is_set(cmd, thinpool_ARG))
- return _convert_cache_volume_thin_pool(cmd, lv, lp);
-
- if (!strcmp(lp->type_str, SEG_TYPE_NAME_SNAPSHOT) ||
- arg_is_set(cmd, snapshot_ARG))
- return _convert_cache_volume_snapshot(cmd, lv, lp);
-
- /* The --thinpool alternative for --type thin-pool is not preferred, so not shown. */
-
- log_error("Operation not permitted on cache LV %s.", display_lvname(lv));
- log_error("Operations permitted on a cache LV are:\n"
- " --splitcache\n"
- " --uncache\n"
- " --splitmirrors (operates on mirror or raid sub LV)\n"
- " --type thin-pool\n");
- return 0;
-}
-
-static int _convert_cache_pool(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- if (lp->splitcache)
- return _convert_cache_pool_splitcache(cmd, lv, lp);
-
- if (lp->split)
- return _convert_cache_pool_splitcache(cmd, lv, lp);
+ }
+ }
- /* FIXME: swapping the cache pool metadata LV needs a specific option like --swapmetadata */
- if (arg_is_set(cmd, poolmetadata_ARG))
- return _convert_cache_pool_swapmetadata(cmd, lv, lp);
+ /*
+ * Apply settings to the new pool seg, from command line, from
+ * defaults, sometimes adjusted.
+ */
- /* FIXME: add --swapmetadata to list of permitted operations. */
+ seg->transaction_id = 0;
+ seg->chunk_size = chunk_size;
- log_error("Operation not permitted on cache pool LV %s.", display_lvname(lv));
- log_error("Operations permitted on a cache pool LV are:\n"
- " --splitcache (operates on cache LV)\n");
- return 0;
-}
+ if (to_cachepool) {
+ cache_mode_t cache_mode = 0;
+ const char *policy_name = NULL;
+ struct dm_config_tree *policy_settings = NULL;
-static int _convert_mirror(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- if (arg_is_set(cmd, mirrors_ARG))
- return _convert_mirror_number(cmd, lv, lp);
+ if (!get_cache_params(cmd, &cache_mode, &policy_name, &policy_settings))
+ return_0;
- if (arg_is_set(cmd, splitmirrors_ARG))
- return _convert_mirror_splitmirrors(cmd, lv, lp);
+ if (cache_mode &&
+ !cache_set_cache_mode(seg, cache_mode))
+ return_0;
- if (arg_is_set(cmd, mirrorlog_ARG) || arg_is_set(cmd, corelog_ARG))
- return _convert_mirror_log(cmd, lv, lp);
+ if ((policy_name || policy_settings) &&
+ !cache_set_policy(seg, policy_name, policy_settings))
+ return_0;
- if (_linear_type_requested(lp->type_str))
- return _convert_mirror_linear(cmd, lv, lp);
+ if (policy_settings)
+ dm_config_destroy(policy_settings);
+ } else {
+ const char *discards_name;
- if (segtype_is_raid(lp->segtype))
- return _convert_mirror_raid(cmd, lv, lp);
+ if (arg_is_set(cmd, zero_ARG))
+ seg->zero_new_blocks = arg_int_value(cmd, zero_ARG, 0);
+ else
+ seg->zero_new_blocks = find_config_tree_bool(cmd, allocation_thin_pool_zero_CFG, vg->profile);
- log_error("Unknown operation on mirror LV %s.", display_lvname(lv));
- return 0;
-}
+ if (arg_is_set(cmd, discards_ARG))
+ seg->discards = (thin_discards_t) arg_uint_value(cmd, discards_ARG, THIN_DISCARDS_PASSDOWN);
+ else {
+ if (!(discards_name = find_config_tree_str(cmd, allocation_thin_pool_discards_CFG, vg->profile)))
+ return_0;
+ if (!set_pool_discards(&seg->discards, discards_name))
+ return_0;
+ }
+ }
-static int _convert_raid(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- if (arg_is_set(cmd, mirrors_ARG))
- return _convert_raid_number(cmd, lv, lp);
+ /*
+ * Rename deactivated metadata LV to have _tmeta suffix.
+ * Implicit checks if metadata_lv is visible.
+ */
+ if (pool_metadata_name &&
+ !lv_rename_update(cmd, metadata_lv, meta_name, 0))
+ return_0;
- if (arg_is_set(cmd, splitmirrors_ARG))
- return _convert_raid_splitmirrors(cmd, lv, lp);
+ if (!attach_pool_metadata_lv(seg, metadata_lv))
+ return_0;
- if (segtype_is_raid(lp->segtype))
- return _convert_raid_raid(cmd, lv, lp);
+ if (!handle_pool_metadata_spare(vg,
+ metadata_lv->le_count,
+ use_pvh,
+ arg_int_value(cmd, poolmetadataspare_ARG, DEFAULT_POOL_METADATA_SPARE)))
+ return_0;
- if (segtype_is_mirror(lp->segtype))
- return _convert_raid_mirror(cmd, lv, lp);
+ if (!vg_write(vg) || !vg_commit(vg))
+ return_0;
- if (!strcmp(lp->type_str, SEG_TYPE_NAME_STRIPED))
- return _convert_raid_striped(cmd, lv, lp);
+ if (seg->zero_new_blocks &&
+ seg->chunk_size >= DEFAULT_THIN_POOL_CHUNK_SIZE_PERFORMANCE * 2)
+ log_warn("WARNING: Pool zeroing and large %s chunk size slows down provisioning.",
+ display_size(cmd, seg->chunk_size));
- if (_linear_type_requested(lp->type_str))
- return _convert_raid_linear(cmd, lv, lp);
+ if (activate_pool && !lockd_lv(cmd, pool_lv, "ex", LDLV_PERSISTENT)) {
+ log_error("Failed to lock pool LV %s.", display_lvname(pool_lv));
+ goto out;
+ }
- log_error("Unknown operation on raid LV %s.", display_lvname(lv));
- return 0;
-}
+ if (activate_pool &&
+ !activate_lv_excl(cmd, pool_lv)) {
+ log_error("Failed to activate pool logical volume %s.",
+ display_lvname(pool_lv));
+ /* Deactivate subvolumes */
+ if (!deactivate_lv(cmd, seg_lv(seg, 0)))
+ log_error("Failed to deactivate pool data logical volume %s.",
+ display_lvname(seg_lv(seg, 0)));
+ if (!deactivate_lv(cmd, seg->metadata_lv))
+ log_error("Failed to deactivate pool metadata logical volume %s.",
+ display_lvname(seg->metadata_lv));
+ goto out;
+ }
-static int _convert_striped(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
-{
- const char *mirrors_type = find_config_tree_str(cmd, global_mirror_segtype_default_CFG, NULL);
+ r = 1;
- if (!strcmp(lp->type_str, SEG_TYPE_NAME_MIRROR))
- return _convert_striped_mirror(cmd, lv, lp);
+out:
+ backup(vg);
- if (segtype_is_raid(lp->segtype))
- return _convert_striped_raid(cmd, lv, lp);
+ if (r)
+ log_print_unless_silent("Converted %s to %s pool.",
+ display_lvname(lv),
+ to_cachepool ? "cache" : "thin");
- /* --mirrors can mean --type mirror or --type raid1 depending on config setting. */
+ /*
+ * Unlock and free the locks from existing LVs that became pool data
+ * and meta LVs.
+ */
+ if (lockd_data_name) {
+ if (!lockd_lv_name(cmd, vg, lockd_data_name, &lockd_data_id, lockd_data_args, "un", LDLV_PERSISTENT))
+ log_error("Failed to unlock pool data LV %s/%s", vg->name, lockd_data_name);
+ lockd_free_lv(cmd, vg, lockd_data_name, &lockd_data_id, lockd_data_args);
+ }
- if (arg_is_set(cmd, mirrors_ARG) && mirrors_type && !strcmp(mirrors_type, SEG_TYPE_NAME_MIRROR))
- return _convert_striped_mirror(cmd, lv, lp);
+ if (lockd_meta_name) {
+ if (!lockd_lv_name(cmd, vg, lockd_meta_name, &lockd_meta_id, lockd_meta_args, "un", LDLV_PERSISTENT))
+ log_error("Failed to unlock pool metadata LV %s/%s", vg->name, lockd_meta_name);
+ lockd_free_lv(cmd, vg, lockd_meta_name, &lockd_meta_id, lockd_meta_args);
+ }
- if (arg_is_set(cmd, mirrors_ARG) && mirrors_type && !strcmp(mirrors_type, SEG_TYPE_NAME_RAID1))
- return _convert_striped_raid(cmd, lv, lp);
+ return r;
+#if 0
+revert_new_lv:
+ /* TBD */
+ if (!pool_metadata_lv_name) {
+ if (!deactivate_lv(cmd, metadata_lv)) {
+ log_error("Failed to deactivate metadata lv.");
+ return 0;
+ }
+ if (!lv_remove(metadata_lv) || !vg_write(vg) || !vg_commit(vg))
+ log_error("Manual intervention may be required to remove "
+ "abandoned LV(s) before retrying.");
+ else
+ backup(vg);
+ }
- log_error("Unknown operation on striped or linear LV %s.", display_lvname(lv));
return 0;
+#endif
}
-/*
- * Main entry point.
- * lvconvert performs a specific <operation> on a specific <lv_type>.
- *
- * The <operation> is specified by command line args.
- * The <lv_type> is found using lv_is_foo(lv) functions.
- *
- * for each lvtype,
- * _convert_lvtype();
- * for each arg_is_set(operation)
- * _convert_lvtype_operation();
- *
- * FIXME: this code (identifying/routing each unique operation through
- * _convert_lvtype_op) was designed to work based on the new type that
- * the user entered after --type, not the final segment type in lp->type_str.
- * Sometimes the two differ because tricks are played with lp->type_str.
- * So, when the use of arg_type_str(type_ARG) here was replaced with
- * lp->type_str, some commands are no longer identified/routed correctly.
- */
-static int _lvconvert(struct cmd_context *cmd, struct logical_volume *lv,
- struct lvconvert_params *lp)
+static int _lvconvert_to_cache_vol(struct cmd_context *cmd,
+ struct logical_volume *lv,
+ struct logical_volume *cachepool_lv)
{
- struct lv_segment *seg = first_seg(lv);
- int ret = 0;
+ struct logical_volume *cache_lv;
+ cache_mode_t cache_mode = 0;
+ const char *policy_name = NULL;
+ struct dm_config_tree *policy_settings = NULL;
- /* Set up segtype either from type_str or else to match the existing one. */
- if (!*lp->type_str)
- lp->segtype = seg->segtype;
- else if (!(lp->segtype = get_segtype_from_string(cmd, lp->type_str)))
- goto_out;
+ if (!validate_lv_cache_create_pool(cachepool_lv))
+ return_0;
- if (!strcmp(lp->type_str, SEG_TYPE_NAME_MIRROR)) {
- if (!lp->mirrors_supplied && !seg_is_raid1(seg)) {
- log_error("Conversions to --type mirror require -m/--mirrors");
- goto out;
- }
- }
+ if (!get_cache_params(cmd, &cache_mode, &policy_name, &policy_settings))
+ return_0;
- /* lv->segtype can't be NULL */
- if (activation() && lp->segtype->ops->target_present &&
- !lp->segtype->ops->target_present(cmd, NULL, &lp->target_attr)) {
- log_error("%s: Required device-mapper target(s) not "
- "detected in your kernel.", lp->segtype->name);
- goto out;
- }
+ if (!archive(lv->vg))
+ return_0;
- /* Process striping parameters */
- /* FIXME This is incomplete */
- if (_mirror_or_raid_type_requested(cmd, lp->type_str) || _raid0_type_requested(lp->type_str) ||
- _striped_type_requested(lp->type_str) || lp->mirrorlog || lp->corelog) {
- /* FIXME Handle +/- adjustments too? */
- if (!get_stripe_params(cmd, lp->segtype, &lp->stripes, &lp->stripe_size, &lp->stripes_supplied, &lp->stripe_size_supplied))
- goto_out;
+ if (!(cache_lv = lv_cache_create(cachepool_lv, lv)))
+ return_0;
- if (_raid0_type_requested(lp->type_str) || _striped_type_requested(lp->type_str))
- /* FIXME Shouldn't need to override get_stripe_params which defaults to 1 stripe (i.e. linear)! */
- /* The default keeps existing number of stripes, handled inside the library code */
- if (!arg_is_set(cmd, stripes_long_ARG))
- lp->stripes = 0;
- }
+ if (!cache_set_cache_mode(first_seg(cache_lv), cache_mode))
+ return_0;
- if (lv_is_cache(lv))
- lv = seg_lv(first_seg(lv), 0);
+ if (!cache_set_policy(first_seg(cache_lv), policy_name, policy_settings))
+ return_0;
- if (lv_is_mirror(lv)) {
- ret = _convert_mirror(cmd, lv, lp);
- goto out;
- }
+ if (policy_settings)
+ dm_config_destroy(policy_settings);
- if (lv_is_raid(lv)) {
- ret = _convert_raid(cmd, lv, lp);
- goto out;
- }
+ cache_check_for_warns(first_seg(cache_lv));
- /*
- * FIXME: add lv_is_striped() and lv_is_linear()?
- * This does not include raid0 which is caught by the test above.
- * If operations differ between striped and linear, split this case.
- */
- if (segtype_is_striped(seg->segtype) || segtype_is_linear(seg->segtype)) {
- ret = _convert_striped(cmd, lv, lp);
- goto out;
- }
+ if (!lv_update_and_reload(cache_lv))
+ return_0;
- /*
- * The intention is to explicitly check all cases above and never
- * reach here, but this covers anything that was missed.
- */
- log_error("Cannot convert LV %s.", display_lvname(lv));
+ log_print_unless_silent("Logical volume %s is now cached.",
+ display_lvname(cache_lv));
-out:
- return ret ? ECMD_PROCESSED : ECMD_FAILED;
+ return 1;
}
static struct convert_poll_id_list* _convert_poll_id_list_create(struct cmd_context *cmd,
@@ -4990,11 +3589,6 @@ int lvconvert_replace_pv_cmd(struct cmd_context *cmd, int argc, char **argv)
/*
- * snapshot-related lvconvert utilities
- */
-
-
-/*
* Merge a COW snapshot LV into its origin.
*/
@@ -5661,7 +4255,7 @@ static int _lvconvert_raid_types_single(struct cmd_context *cmd, struct logical_
lp->lv_to_poll = lv;
- ret = _lvconvert(cmd, lv, lp);
+ ret = _lvconvert_raid_types(cmd, lv, lp);
if (ret != ECMD_PROCESSED)
return_ECMD_FAILED;
@@ -5805,8 +4399,8 @@ static int _lvconvert_change_mirrorlog_single(struct cmd_context *cmd, struct lo
lp->pvh = use_pvh;
- /* FIXME: extract the mirrorlog functionality out of _lvconvert()? */
- return _lvconvert(cmd, lv, lp);
+ /* FIXME: extract the mirrorlog functionality out of _lvconvert_raid_types()? */
+ return _lvconvert_raid_types(cmd, lv, lp);
}
int lvconvert_change_mirrorlog_cmd(struct cmd_context * cmd, int argc, char **argv)
@@ -5861,8 +4455,8 @@ static int _lvconvert_split_mirror_images_single(struct cmd_context *cmd, struct
lp->pvh = use_pvh;
- /* FIXME: extract the split functionality out of _lvconvert()? */
- return _lvconvert(cmd, lv, lp);
+ /* FIXME: extract the split functionality out of _lvconvert_raid_types()? */
+ return _lvconvert_raid_types(cmd, lv, lp);
}
int lvconvert_split_mirror_images_cmd(struct cmd_context * cmd, int argc, char **argv)
More information about the lvm-devel
mailing list