diff options
author | Zdenek Kabelac <zkabelac@redhat.com> | 2012-05-09 12:17:06 +0000 |
---|---|---|
committer | Zdenek Kabelac <zkabelac@redhat.com> | 2012-05-09 12:17:06 +0000 |
commit | 9f60083aff1b68298d38b487a6a80c74259ecaae (patch) | |
tree | a3159fd0cb565c7244c098e5797d0918cedd5db5 | |
parent | b54dc45c9096c53940ab01acd97b652fc11740ce (diff) | |
download | lvm2-9f60083aff1b68298d38b487a6a80c74259ecaae.tar.gz |
Initial support for lvconvert for thin pool volumes.
Support has many limitations and lots of FIXMEs inside,
however it makes initial task when user creates a separate LV for
thin pool data and thin metadata already usable, so let's enable
it for testing.
Easiest API:
lvconvert --chunksize XX --thinpool data_lv metadata_lv
More functionality extensions will follow up.
TODO: Code needs some rework since a lot of same code is getting copied.
-rw-r--r-- | WHATS_NEW | 1 | ||||
-rw-r--r-- | man/lvconvert.8.in | 15 | ||||
-rw-r--r-- | tools/commands.h | 10 | ||||
-rw-r--r-- | tools/lvconvert.c | 221 |
4 files changed, 246 insertions, 1 deletions
@@ -1,5 +1,6 @@ Version 2.02.96 - ================================ + Add initial support for thin pool lvconvert. Fix lvrename for thin volumes (regression in for_each_sub_lv() 2.02.89). Fix up-convert when mirror activation is controled by volume_list and tags. Disallow snapshots of mirror segment type. diff --git a/man/lvconvert.8.in b/man/lvconvert.8.in index 3fb4c7958..2a47da87d 100644 --- a/man/lvconvert.8.in +++ b/man/lvconvert.8.in @@ -59,6 +59,21 @@ lvconvert \- convert a logical volume from linear to mirror or snapshot .RB [ \-\-version ] .IR LogicalVolume [ Path ]... .sp +.B lvconvert \-\-thinpool +.IR ThinPoolLogicalVolume { Name | Path } +.RB [ \-c | \-\-chunksize +.IR ChunkSize ] +.RB [[ \-\-poolmetadatasize +.IR MetadataSize [ bBsSkKmMgG ] +.RI [ PhysicalVolume [ Path ][ :PE [ -PE ]]...]] +| +.IR ThinMetadataLogicalVolume { Name | Path }] +.RB [ \-Z | \-\-zero +.RI { y | n }] +.RB [ \-h | \-? | \-\-help ] +.RB [ \-v | \-\-verbose ] +.RB [ \-\-version ] +.sp .B lvconvert \-\-repair .RB [ \-h | \-? | \-\-help ] .RB [ \-v | \-\-verbose ] diff --git a/tools/commands.h b/tools/commands.h index 7101ef0f0..a008a7b26 100644 --- a/tools/commands.h +++ b/tools/commands.h @@ -138,12 +138,20 @@ xx(lvconvert, "\t[-d|--debug]\n" "\t[-h|-?|--help]\n" "\t[-v|--verbose]\n" - "\tLogicalVolume[Path]\n", + "\tLogicalVolume[Path]\n\n" + + "lvconvert " + "--thinpool ThinPoolLogicalVolume[Path]\n" + "\t[--chunksize size]\n" + "\t[[--poolmetadatasize size] | ThinMetadataLogicalVolume[Path]]\n" + "\t[-z|--zero {y|n}]\n" + "\t[-d|--debug] [-h|-?|--help] [-v|--verbose]\n", alloc_ARG, background_ARG, chunksize_ARG, corelog_ARG, interval_ARG, merge_ARG, mirrorlog_ARG, mirrors_ARG, name_ARG, noudevsync_ARG, regionsize_ARG, repair_ARG, replace_ARG, snapshot_ARG, splitmirrors_ARG, trackchanges_ARG, type_ARG, stripes_long_ARG, stripesize_ARG, test_ARG, + chunksize_ARG, poolmetadatasize_ARG, thinpool_ARG, use_policies_ARG, yes_ARG, force_ARG, zero_ARG) xx(lvcreate, diff --git a/tools/lvconvert.c b/tools/lvconvert.c index 83518517a..39e196b43 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -53,6 +53,10 @@ struct lvconvert_params { struct dm_list *replace_pvh; struct logical_volume *lv_to_poll; + + uint64_t poolmetadata_size; /* thin pool */ + const char *pool_data_lv_name; + /* pool_metadata_lv_name is lv_name */ }; static int _lvconvert_name_params(struct lvconvert_params *lp, @@ -85,6 +89,15 @@ static int _lvconvert_name_params(struct lvconvert_params *lp, lp->origin = ptr + 1; } + if (!*pargc && lp->pool_data_lv_name) { + if (!lp->vg_name || !validate_name(lp->vg_name)) { + log_error("Please provide a valid volume group name."); + return 0; + } + lp->lv_name = lp->pool_data_lv_name; + return 1; /* Create metadata LV on it's own */ + } + if (!*pargc) { log_error("Please provide logical volume path"); return 0; @@ -120,6 +133,11 @@ static int _lvconvert_name_params(struct lvconvert_params *lp, return 0; } + if (lp->pool_data_lv_name && lp->lv_name && lp->poolmetadata_size) { + log_error("Please specify either metadata logical volume or its size."); + return 0; + } + return 1; } @@ -159,6 +177,29 @@ static int _read_params(struct lvconvert_params *lp, struct cmd_context *cmd, return 0; } + if (arg_count(cmd, thinpool_ARG)) { + if (arg_count(cmd, merge_ARG)) { + log_error("--thinpool and --merge are mutually exlusive."); + return 0; + } + if (arg_count(cmd, mirrors_ARG)) { + log_error("--thinpool and --mirrors are mutually exlusive."); + return 0; + } + if (arg_count(cmd, repair_ARG)) { + log_error("--thinpool and --repair are mutually exlusive."); + return 0; + } + if (arg_count(cmd, snapshot_ARG)) { + log_error("--thinpool and --snapshot are mutually exlusive."); + return 0; + } + if (arg_count(cmd, splitmirrors_ARG)) { + log_error("--thinpool and --splitmirrors are mutually exlusive."); + return 0; + } + } + /* * The '--splitmirrors n' argument is equivalent to '--mirrors -n' * (note the minus sign), except that it signifies the additional @@ -280,6 +321,67 @@ static int _read_params(struct lvconvert_params *lp, struct cmd_context *cmd, tmp_str))) return_0; } + } else if (arg_count(cmd, thinpool_ARG)) { + if (!(lp->pool_data_lv_name = arg_str_value(cmd, thinpool_ARG, NULL))) { + log_error("Missing pool logical volume name."); + return 0; + } + + if (arg_count(cmd, poolmetadatasize_ARG)) { + if (arg_sign_value(cmd, poolmetadatasize_ARG, SIGN_NONE) == SIGN_MINUS) { + log_error("Negative pool metadata size is invalid."); + return 0; + } + lp->poolmetadata_size = arg_uint64_value(cmd, poolmetadatasize_ARG, UINT64_C(0)); + + if (lp->poolmetadata_size > (2 * DEFAULT_THIN_POOL_MAX_METADATA_SIZE)) { + if (arg_count(cmd, poolmetadatasize_ARG)) + log_warn("WARNING: Maximum supported pool metadata size is 16GB."); + lp->poolmetadata_size = 2 * DEFAULT_THIN_POOL_MAX_METADATA_SIZE; + } else if (lp->poolmetadata_size < (2 * DEFAULT_THIN_POOL_MIN_METADATA_SIZE)) { + if (arg_count(cmd, poolmetadatasize_ARG)) + log_warn("WARNING: Minimum supported pool metadata size is 2M."); + lp->poolmetadata_size = 2 * DEFAULT_THIN_POOL_MIN_METADATA_SIZE; + } + + log_verbose("Setting pool metadata size to %" PRIu64 " sectors.", + lp->poolmetadata_size); + } + + if (arg_count(cmd, chunksize_ARG)) { + if (arg_sign_value(cmd, chunksize_ARG, SIGN_NONE) == SIGN_MINUS) { + log_error("Negative chunk size is invalid."); + return 0; + } + lp->chunk_size = arg_uint_value(cmd, chunksize_ARG, + DM_THIN_MIN_DATA_BLOCK_SIZE); + + if ((lp->chunk_size < DM_THIN_MIN_DATA_BLOCK_SIZE) || + (lp->chunk_size > DM_THIN_MAX_DATA_BLOCK_SIZE)) { + log_error("Chunk size must be in the range %uK to %uK.", + (DM_THIN_MIN_DATA_BLOCK_SIZE / 2), + (DM_THIN_MAX_DATA_BLOCK_SIZE / 2)); + return 0; + } + } else + lp->chunk_size = DM_THIN_MIN_DATA_BLOCK_SIZE; + log_verbose("Setting pool metadata chunk size to %u sectors.", + lp->chunk_size); + + if (arg_count(cmd, zero_ARG)) + lp->zero = strcmp(arg_str_value(cmd, zero_ARG, "y"), "n"); + + /* If --thinpool contains VG name, extract it. */ + if ((tmp_str = strchr(lp->pool_data_lv_name, (int) '/'))) { + if (!(lp->vg_name = extract_vgname(cmd, lp->pool_data_lv_name))) + return 0; + /* Strip VG from pool */ + lp->pool_data_lv_name = tmp_str + 1; + } + + lp->segtype = get_segtype_from_string(cmd, arg_str_value(cmd, type_ARG, "thin-pool")); + if (!lp->segtype) + return_0; } else { /* Mirrors (and some RAID functions) */ if (arg_count(cmd, chunksize_ARG)) { log_error("--chunksize is only available with " @@ -1723,6 +1825,116 @@ out: return r; } +static int _lvconvert_thinpool(struct cmd_context *cmd, + struct logical_volume *metadata_lv, + struct lvconvert_params *lp) +{ + int r = 0; + char *name; + int len; + int was_active; + struct lv_segment *seg; + struct logical_volume *data_lv; + struct logical_volume *pool_lv = + (lp->pool_data_lv_name == lp->lv_name) ? + metadata_lv : find_lv(metadata_lv->vg, + lp->pool_data_lv_name); + + if (!pool_lv) { + log_error("Can't find pool logical volume %s.", pool_lv->name); + goto_out; + } + + if ((pool_lv != metadata_lv)) { + if (!lv_is_visible(metadata_lv)) { + log_error("Can't use hidden logical volume %s/%s for thin pool metadata.", + metadata_lv->vg->name, metadata_lv->name); + goto out; + } + if (lv_is_thin_pool(metadata_lv)) { + log_error("Can't use thin pool logical volume %s/%s for thin pool metadata.", + metadata_lv->vg->name, metadata_lv->name); + goto out; + } + /* FIXME: any more types prohibited here ? */ + if (!deactivate_lv(cmd, metadata_lv)) { + log_error("Can't deactivate logical volume %s/%s.", + metadata_lv->vg->name, metadata_lv->name); + goto out; + } + /* FIXME: initialize metadata LV! */ + } else { + /* FIXME: add creation of metadata LV */ + } + + if (!lv_is_visible(pool_lv)) { + log_error("Can't use hidden logical volume %s/%s for thin pool data.", + metadata_lv->vg->name, metadata_lv->name); + goto out; + } + if (lv_is_thin_pool(pool_lv)) { + log_error("Can't use thin pool logical volume %s/%s for thin pool data.", + metadata_lv->vg->name, metadata_lv->name); + goto out; + } + /* FIXME: any more types prohibited here ? */ + if ((was_active = lv_is_active(pool_lv))) { + if (!deactivate_lv(cmd, pool_lv)) { + log_error("Can't deactivate logical volume %s/%s.", + pool_lv->vg->name, pool_lv->name); + goto out; + } + } + + /* FIXME: common code with metadata/thin_manip.c extend_pool() */ + if (!(data_lv = insert_layer_for_lv(pool_lv->vg->cmd, pool_lv, + pool_lv->status, "_tdata"))) + return_0; + + seg = first_seg(pool_lv); + seg->segtype = lp->segtype; + seg->lv->status |= THIN_POOL; + + seg->chunk_size = lp->chunk_size; + seg->zero_new_blocks = lp->zero ? 1 : 0; + seg->low_water_mark = 0; + + len = strlen(pool_lv->name) + 16; + if (!(name = dm_pool_alloc(pool_lv->vg->vgmem, len))) { + log_error("Cannot allocate new name."); + return 0; + } + + if (dm_snprintf(name, len, "%s_tmeta", pool_lv->name) < 0) + return_0; + metadata_lv->name = name; + + if (!attach_pool_metadata_lv(seg, metadata_lv)) + return_0; + + /* Drop reference as attach_pool_data_lv() takes it again */ + remove_seg_from_segs_using_this_lv(data_lv, seg); + if (!attach_pool_data_lv(seg, data_lv)) + return_0; + + /* store vg on disk(s) */ + if (!vg_write(pool_lv->vg) || !vg_commit(pool_lv->vg)) + return_0; + + log_print("Converted %s/%s to thin pool.", + pool_lv->vg->name, pool_lv->name); + if (was_active && !activate_lv(cmd, pool_lv)) { + log_error("Failed to activate pool logical volume %s/%s.", + pool_lv->vg->name, pool_lv->name); + goto out; + } + + r = 1; +out: + backup(pool_lv->vg); + return r; +} + static int _lvconvert_single(struct cmd_context *cmd, struct logical_volume *lv, void *handle) { @@ -1831,6 +2043,15 @@ static int _lvconvert_single(struct cmd_context *cmd, struct logical_volume *lv, /* If repairing and using policies, remove missing PVs from VG */ if (arg_count(cmd, repair_ARG) && arg_count(cmd, use_policies_ARG)) _remove_missing_empty_pv(lv->vg, failed_pvs); + } else if (arg_count(cmd, thinpool_ARG)) { + if (!archive(lv->vg)) { + stack; + return ECMD_FAILED; + } + if (!_lvconvert_thinpool(cmd, lv, lp)) { + stack; + return ECMD_FAILED; + } } return ECMD_PROCESSED; |