lvm2app: Implementation of pv resize (v6)
PATCH 1/7 lvm2app: Implementation of pv resize (v6)
--- liblvm/lvm2app.h | 2 -- liblvm/lvm_pv.c | 20 +++++++++++++++++--- 2 files changed, 17 insertions(+), 5 deletions(-)
liblvm/lvm2app.h +0 -2
@@ -1626,8 +1626,6 @@ pv_t lvm_pv_from_uuid(vg_t vg, const char *uuid);* * \memberof pv_t * -* NOTE: This function is currently not implemented. -* * \param pv * Physical volume handle. *
liblvm/lvm_pv.c +17 -3
@@ -123,7 +123,21 @@ pv_t lvm_pv_from_uuid(vg_t vg, const char *uuid)int lvm_pv_resize (const pv_t pv,uint64_t new_size) { -/* FIXME: add pv resize code here */ -log_error ("NOT IMPLEMENTED YET" ); -return -1 ; +uint64_t size = new_size >>SECTOR_SHIFT ; + +if (new_size %SECTOR_SIZE ) { +log_errno (EINVAL ,"Size not a multiple of 512" ); +return -1 ; + } + +if (!vg_check_write_mode (pv->vg)) { +return -1 ; + } + +if (!pv_resize (pv, pv->vg, size)) { +log_error ("PV re-size failed!" ); +return -1 ; + }else { +return 0 ; + } }
Signature · 1 line
1.8.1.4
PATCH 2/7 lvm2app: Move percent_of_extents to lvm-percent.[h|c]
--- lib/misc/lvm-percent.c | 5 +++++ lib/misc/lvm-percent.h | 17 +++++++++++++++++ tools/toollib.c | 6 ------ tools/tools.h | 16 ---------------- 4 files changed, 22 insertions(+), 22 deletions(-)
lib/misc/lvm-percent.c +5 -0
@@ -38,3 +38,8 @@ percent_t make_percent(uint64_t numerator, uint64_t denominator) } } +uint32_t percent_of_extents (uint32_t percents,uint32_t count,int roundup) +{ +return (uint32_t )(((uint64_t )percents * (uint64_t )count + + ((roundup) ?99 :0 )) /100 ); +}
lib/misc/lvm-percent.h +17 -0
@@ -31,6 +31,21 @@typedef int32_t percent_t ;typedef enum { +SIGN_NONE =0 , +SIGN_PLUS =1 , +SIGN_MINUS =2 +}sign_t ; + +typedef enum { +PERCENT_NONE =0 , +PERCENT_VG , +PERCENT_FREE , +PERCENT_LV , +PERCENT_PVS , +PERCENT_ORIGIN +}percent_type_t ; + +typedef enum { PERCENT_0 = 0, PERCENT_1 = 1000000, PERCENT_100 = 100 * PERCENT_1,
@@ -41,4 +56,6 @@ typedef enum {float percent_to_float (percent_t v);percent_t make_percent (uint64_t numerator,uint64_t denominator); +uint32_t percent_of_extents (uint32_t percents,uint32_t count,int roundup); +#endif
tools/toollib.c +0 -6
@@ -1730,9 +1730,3 @@ int change_tag(struct cmd_context *cmd, struct volume_group *vg,return 1 ; } -/* Return percents of extents and avoid overflow, with optional roundup */ -uint32_t percent_of_extents (uint32_t percents,uint32_t count,int roundup) -{ -return (uint32_t )(((uint64_t )percents * (uint64_t )count + - ((roundup) ?99 :0 )) /100 ); -}
tools/tools.h +0 -16
@@ -74,21 +74,6 @@ enum {#undef arg }; -typedef enum { -SIGN_NONE =0 , -SIGN_PLUS =1 , -SIGN_MINUS =2 -}sign_t ; - -typedef enum { -PERCENT_NONE =0 , -PERCENT_VG , -PERCENT_FREE , -PERCENT_LV , -PERCENT_PVS , -PERCENT_ORIGIN -}percent_type_t ; -#define ARG_COUNTABLE 0x00000001/* E.g. -vvvv */ #define ARG_GROUPABLE 0x00000002/* E.g. --addtag */
@@ -188,7 +173,6 @@ int lvconvert_poll(struct cmd_context *cmd, struct logical_volume *lv, unsignedint mirror_remove_missing (struct cmd_context *cmd,struct logical_volume *lv,int force); -uint32_t percent_of_extents (uint32_t percents,uint32_t count,int roundup);int vgchange_activate (struct cmd_context *cmd,struct volume_group *vg,activation_change_t activate);
Signature · 1 line
1.8.1.4
PATCH 3/7 lvm2app: Rework argument handling for lv resize
In reply to Tony AslesonExtend the lv resize parameter structure to contain everything the re-size functions need so that the command line does not need to be present for lower level calls when we call from library functions.
--- tools/lvresize.c | 120 +++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 81 insertions(+), 39 deletions(-)
tools/lvresize.c +81 -39
@@ -44,18 +44,28 @@ struct lvresize_params {int argc;char **argv; + +/* Arg counts & values */ +unsigned ac_policy; +unsigned ac_stripes; +uint32_t ac_stripes_value; +unsigned ac_mirrors; +uint32_t ac_mirrors_value; +unsigned ac_stripesize; +uint64_t ac_stripesize_value; +unsigned ac_alloc; +unsigned ac_no_sync; +unsigned ac_force; + +const char *ac_type; };static int _validate_stripesize (struct cmd_context *cmd,const struct volume_group *vg,struct lvresize_params *lp) { -if (arg_sign_value (cmd, stripesize_ARG,SIGN_NONE ) ==SIGN_MINUS ) { -log_error ("Stripesize may not be negative." ); -return 0 ; - } -if (arg_uint64_value (cmd, stripesize_ARG,0 ) >STRIPE_SIZE_LIMIT *2 ) { +if ( lp->ac_stripesize_value >STRIPE_SIZE_LIMIT *2 ) {log_error ("Stripe size cannot be larger than %s" ,display_size (cmd, (uint64_t )STRIPE_SIZE_LIMIT ));return 0 ;
@@ -63,15 +73,14 @@ static int _validate_stripesize(struct cmd_context *cmd,if (!(vg->fid->fmt->features &FMT_SEGMENTS ))log_warn ("Varied stripesize not supported. Ignoring." ); -else if (arg_uint_value (cmd, stripesize_ARG,0 ) > (uint64_t ) vg->extent_size *2 ) { +else if (lp->ac_stripesize_value > (uint64_t ) vg->extent_size *2 ) {log_error ("Reducing stripe size %s to maximum, " "physical extent size %s" , -display_size (cmd, - (uint64_t )arg_uint_value (cmd, stripesize_ARG,0 )), +display_size (cmd,lp->ac_stripesize_value),display_size (cmd, (uint64_t ) vg->extent_size)); lp->stripe_size = vg->extent_size; }else - lp->stripe_size =arg_uint_value (cmd, stripesize_ARG,0 ); + lp->stripe_size = lp->ac_stripesize_value;if (lp->stripe_size & (lp->stripe_size -1 )) {log_error ("Stripe size must be power of 2" );
@@ -111,7 +120,7 @@ static int _request_confirmation(struct cmd_context *cmd,log_warn ("THIS MAY DESTROY YOUR DATA (filesystem etc.)" ); -if (!arg_count (cmd, force_ARG)) { +if (!lp->ac_force) {if (yes_no_prompt ("Do you really want to reduce %s? [y/n]: " , lp->lv_name) =='n' ) {log_error ("Logical volume %s NOT reduced" , lp->lv_name);
@@ -152,7 +161,7 @@ static int _fsadm_cmd(struct cmd_context *cmd,if (verbose_level () >= _LOG_NOTICE) argv[i++] ="--verbose" ; -if (arg_count (cmd, force_ARG)) +if (lp->ac_force) argv[i++] ="--force" ; argv[i++] = (fcmd ==FSADM_CMD_RESIZE ) ?"resize" :"check" ;
@@ -277,6 +286,43 @@ static int _lvresize_params(struct cmd_context *cmd, int argc, char **argv, lp->argc = argc; lp->argv = argv; + lp->ac_policy =arg_count (cmd, use_policies_ARG); + lp->ac_stripes =arg_count (cmd, stripes_ARG); +if (lp->ac_stripes) { + lp->ac_stripes_value =arg_uint_value (cmd, stripes_ARG,1 ); + }else { + lp->ac_stripes_value =0 ; + } + + lp->ac_mirrors =arg_count (cmd, mirrors_ARG); + +if (lp->ac_mirrors) { +if (arg_sign_value (cmd, mirrors_ARG,SIGN_NONE ) ==SIGN_MINUS ) { +log_error ("Mirrors argument may not be negative" ); +return 0 ; + } + + lp->ac_mirrors_value =arg_uint_value (cmd, mirrors_ARG,1 ) +1 ; + }else { + lp->ac_mirrors_value =0 ; + } + + lp->ac_stripesize =arg_count (cmd, stripesize_ARG); +if (lp->ac_stripesize) { +if (arg_sign_value (cmd, stripesize_ARG,SIGN_NONE ) ==SIGN_MINUS ) { +log_error ("Stripesize may not be negative." ); +return 0 ; + } + + lp->ac_stripesize_value =arg_uint64_value (cmd, stripesize_ARG,0 ); + } + + lp->ac_no_sync =arg_count (cmd, nosync_ARG); + lp->ac_alloc =arg_uint_value (cmd, alloc_ARG,0 ); + + lp->ac_type =arg_str_value (cmd, type_ARG,NULL ); + lp->ac_force =arg_count (cmd, force_ARG); +return 1 ; }
@@ -359,7 +405,7 @@ static uint32_t lvseg_get_stripes(struct lv_segment *seg, uint32_t *stripesize) }static int _lvresize (struct cmd_context *cmd,struct volume_group *vg, -struct lvresize_params *lp) +struct lvresize_params *lp,struct dm_list *pvh) {struct logical_volume *lv;struct lvinfo info;
@@ -376,8 +422,6 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg,uint32_t seg_extents;uint32_t sz, str;int status; -struct dm_list *pvh =NULL ; -int use_policy =arg_count (cmd, use_policies_ARG);/* does LV exist? */ if (!(lvl =find_lv_in_vg (vg, lp->lv_name))) {
@@ -408,31 +452,27 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg,return ECMD_FAILED ; } -if (arg_count (cmd, stripes_ARG)) { +if (lp->ac_stripes) {if (vg->fid->fmt->features &FMT_SEGMENTS ) - lp->stripes =arg_uint_value (cmd, stripes_ARG,1 ); + lp->stripes = lp->ac_stripes_value;else log_warn ("Varied striping not supported. Ignoring." ); } -if (arg_count (cmd, mirrors_ARG)) { +if (lp->ac_mirrors) {if (vg->fid->fmt->features &FMT_SEGMENTS ) - lp->mirrors =arg_uint_value (cmd, mirrors_ARG,1 ) +1 ; + lp->mirrors = lp->ac_mirrors_value;else log_warn ("Mirrors not supported. Ignoring." ); -if (arg_sign_value (cmd, mirrors_ARG,SIGN_NONE ) ==SIGN_MINUS ) { -log_error ("Mirrors argument may not be negative" ); -return EINVALID_CMD_LINE ; - } } -if (arg_count (cmd, stripesize_ARG) && +if (lp->ac_stripesize && !_validate_stripesize (cmd, vg, lp))return EINVALID_CMD_LINE ; lv = lvl->lv; -if (use_policy) { +if (lp->ac_policy) {if (!lv_is_cow (lv) && !lv_is_thin_pool (lv)) {log_error ("Policy-based resize is supported only for snapshot and thin pool volumes." );
@@ -457,7 +497,7 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg,return ECMD_FAILED ; } - alloc = (alloc_policy_t )arg_uint_value (cmd, alloc_ARG, lv->alloc); + alloc = (alloc_policy_t)(lp->ac_alloc)?lp->ac_alloc: lv->alloc;/* * First adjust to an exact multiple of extent size.
@@ -480,12 +520,6 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg, lp->extents = lp->size / vg->extent_size; } -if (!(pvh = lp->argc ?create_pv_list (cmd->mem, vg, lp->argc, - lp->argv,1 ) : &vg->pvs)) { - stack; -return ECMD_FAILED ; - } -switch (lp->percent) {case PERCENT_VG : lp->extents = percent_of_extents(lp->extents, vg->extent_count,
@@ -545,7 +579,7 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg, }if (lp->extents == lv->le_count) { -if (use_policy) +if (lp->ac_policy)return ECMD_PROCESSED ;/* Nothing to do. */ if (!lp->resizefs) { log_error("New size (%d extents) matches existing size "
@@ -563,8 +597,7 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg, }/* FIXME Support LVs with mixed segment types */ -if (lp->segtype !=get_segtype_from_string (cmd,arg_str_value (cmd, type_ARG, - lp->segtype->name))) { +if (lp->segtype !=get_segtype_from_string (cmd, (lp->ac_type)?lp->ac_type:lp->segtype->name)) {log_error ("VolumeType does not match (%s)" , lp->segtype->name);return EINVALID_CMD_LINE ; }
@@ -575,7 +608,7 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg,* Has the user specified that they would like the additional * extents of a mirror not to have an initial sync? */ -if (seg_is_mirrored (first_seg (lv)) &&arg_count (cmd, nosync_ARG)) +if (seg_is_mirrored (first_seg (lv)) && lp->ac_no_sync) lv->status |=LV_NOTSYNCED ; dm_list_iterate_back_items(mirr_seg, &lv->segments) {
@@ -586,12 +619,12 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg,break ; } -if (!arg_count (cmd, mirrors_ARG) && seg_mirrors) { +if (!lp->ac_mirrors && seg_mirrors) {log_print_unless_silent ("Extending %" PRIu32" mirror images." , seg_mirrors); lp->mirrors = seg_mirrors; } -if ((arg_count (cmd, mirrors_ARG) || seg_mirrors) && +if ((lp->ac_mirrors || seg_mirrors) && (lp->mirrors != seg_mirrors)) {log_error ("Cannot vary number of mirrors in LV yet." );return EINVALID_CMD_LINE ;
@@ -739,7 +772,7 @@ static int _lvresize(struct cmd_context *cmd, struct volume_group *vg, } lp->resize =LV_EXTEND ; }else if (lp->extents == lv->le_count) { -if (use_policy) +if (lp->ac_policy)return ECMD_PROCESSED ;/* Nothing to do. */ if (!lp->resizefs) { log_error("New size (%d extents) matches existing size "
@@ -892,10 +925,12 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv)struct lvresize_params lp = {0 };struct volume_group *vg;int r; +struct dm_list *pvh =NULL ;if (!_lvresize_params (cmd, argc, argv, &lp))return EINVALID_CMD_LINE ; +log_verbose ("Finding volume group %s" , lp.vg_name); vg =vg_read_for_update (cmd, lp.vg_name,NULL ,0 );if (vg_read_error (vg)) {
@@ -904,7 +939,14 @@ int lvresize(struct cmd_context *cmd, int argc, char **argv)return ECMD_FAILED ; } -if (!(r =_lvresize (cmd, vg, &lp))) +/* How does this list get cleaned up? */ +if (!(pvh = lp.argc ?create_pv_list (cmd->mem, vg, lp.argc, + lp.argv,1 ) : &vg->pvs)) { + stack; +return ECMD_FAILED ; + } + +if (!(r =_lvresize (cmd, vg, &lp, pvh))) stack;unlock_and_release_vg (cmd, vg, lp.vg_name);
Signature · 1 line
1.8.1.4
PATCH 4/7 lvm2app: Move core lv re-size code (v2)
In reply to Tony AslesonMoved to allow use from command line and for library use.
--- lib/metadata/lv_manip.c | 734 +++++++++++++++++++++++++++++++++++++ lib/metadata/metadata-exported.h | 46 +++ tools/lvresize.c | 773 +-------------------------------------- 3 files changed, 781 insertions(+), 772 deletions(-)
lib/metadata/lv_manip.c +734 -0
@@ -27,6 +27,8 @@#include "activate.h" #include "str_list.h" #include "defaults.h" +#include "lvm-exec.h" +#include "errors.h" typedef enum { PREFERRED,
@@ -3083,6 +3085,738 @@ int lv_rename(struct cmd_context *cmd, struct logical_volume *lv,return lv_rename_update (cmd, lv, new_name,1 ); } +/* +* Core lv resize code +*/ + +#define SIZE_BUF 128 + +static int _validate_stripesize (struct cmd_context *cmd, +const struct volume_group *vg, +struct lvresize_params *lp) +{ + +if ( lp->ac_stripesize_value >STRIPE_SIZE_LIMIT *2 ) { +log_error ("Stripe size cannot be larger than %s" , +display_size (cmd, (uint64_t )STRIPE_SIZE_LIMIT )); +return 0 ; + } + +if (!(vg->fid->fmt->features &FMT_SEGMENTS )) +log_warn ("Varied stripesize not supported. Ignoring." ); +else if (lp->ac_stripesize_value > (uint64_t ) vg->extent_size *2 ) { +log_error ("Reducing stripe size %s to maximum, " +"physical extent size %s" , +display_size (cmd,lp->ac_stripesize_value), +display_size (cmd, (uint64_t ) vg->extent_size)); + lp->stripe_size = vg->extent_size; + }else + lp->stripe_size = lp->ac_stripesize_value; + +if (lp->stripe_size & (lp->stripe_size -1 )) { +log_error ("Stripe size must be power of 2" ); +return 0 ; + } + +return 1 ; +} + +static int _request_confirmation (struct cmd_context *cmd, +const struct volume_group *vg, +const struct logical_volume *lv, +const struct lvresize_params *lp) +{ +struct lvinfo info = {0 }; + +if (!lv_info (cmd, lv,0 , &info,1 ,0 ) &&driver_version (NULL ,0 )) { +log_error ("lv_info failed: aborting" ); +return 0 ; + } + +if (lp->resizefs) { +if (!info.exists) { +log_error ("Logical volume %s must be activated " +"before resizing filesystem" , lp->lv_name); +return 0 ; + } +return 1 ; + } + +if (!info.exists) +return 1 ; + +log_warn ("WARNING: Reducing active%s logical volume to %s" , + info.open_count ?" and open" :"" , +display_size (cmd, (uint64_t ) lp->extents * vg->extent_size)); + +log_warn ("THIS MAY DESTROY YOUR DATA (filesystem etc.)" ); + +if (!lp->ac_force) { +if (yes_no_prompt ("Do you really want to reduce %s? [y/n]: " , + lp->lv_name) =='n' ) { +log_error ("Logical volume %s NOT reduced" , lp->lv_name); +return 0 ; + } +if (sigint_caught ()) +return 0 ; + } + +return 1 ; +} + +enum fsadm_cmd_e {FSADM_CMD_CHECK ,FSADM_CMD_RESIZE }; +#define FSADM_CMD "fsadm" +#define FSADM_CMD_MAX_ARGS 6 +#define FSADM_CHECK_FAILS_FOR_MOUNTED 3/* shell exist status code */ + +/* +* FSADM_CMD --dry-run --verbose --force check lv_path +* FSADM_CMD --dry-run --verbose --force resize lv_path size +*/ +static int _fsadm_cmd (struct cmd_context *cmd, +const struct volume_group *vg, +const struct lvresize_params *lp, +enum fsadm_cmd_e fcmd, +int *status) +{ +char lv_path[PATH_MAX ]; +char size_buf[SIZE_BUF ]; +const char *argv[FSADM_CMD_MAX_ARGS +2 ]; +unsigned i =0 ; + + argv[i++] =FSADM_CMD ; + +if (test_mode ()) + argv[i++] ="--dry-run" ; + +if (verbose_level () >= _LOG_NOTICE) + argv[i++] ="--verbose" ; + +if (lp->ac_force) + argv[i++] ="--force" ; + + argv[i++] = (fcmd ==FSADM_CMD_RESIZE ) ?"resize" :"check" ; + +if (status) + *status =-1 ; + +if (dm_snprintf (lv_path,PATH_MAX ,"%s%s/%s" , cmd->dev_dir, lp->vg_name, + lp->lv_name) <0 ) { +log_error ("Couldn't create LV path for %s" , lp->lv_name); +return 0 ; + } + + argv[i++] = lv_path; + +if (fcmd ==FSADM_CMD_RESIZE ) { +if (dm_snprintf (size_buf,SIZE_BUF ,"%" PRIu64"K" , + (uint64_t ) lp->extents * vg->extent_size /2 ) <0 ) { +log_error ("Couldn't generate new LV size string" ); +return 0 ; + } + + argv[i++] = size_buf; + } + + argv[i] =NULL ; + +return exec_cmd (cmd, argv, status,1 ); +} + +static int _adjust_policy_params (struct cmd_context *cmd, +struct logical_volume *lv,struct lvresize_params *lp) +{ +percent_t percent; +int policy_threshold, policy_amount; + +if (lv_is_thin_pool (lv)) { + policy_threshold = +find_config_tree_int (cmd, activation_thin_pool_autoextend_threshold_CFG) *PERCENT_1 ; + policy_amount = +find_config_tree_int (cmd, activation_thin_pool_autoextend_percent_CFG); +if (!policy_amount && policy_threshold <PERCENT_100 ) +return 0 ; + }else { + policy_threshold = +find_config_tree_int (cmd, activation_snapshot_autoextend_threshold_CFG) *PERCENT_1 ; + policy_amount = +find_config_tree_int (cmd, activation_snapshot_autoextend_percent_CFG); + } + +if (policy_threshold >=PERCENT_100 ) +return 1 ;/* nothing to do */ + +if (lv_is_thin_pool (lv)) { +if (!lv_thin_pool_percent (lv,1 , &percent)) + return_0; +if (percent > policy_threshold) { +/* FIXME: metadata resize support missing */ +log_error ("Resize for %s/%s is not yet supported." , + lp->vg_name, lp->lv_name); +return ECMD_FAILED ; + } + +if (!lv_thin_pool_percent (lv,0 , &percent)) + return_0; +if (!(PERCENT_0 < percent && percent <=PERCENT_100 ) || + percent <= policy_threshold) +return 1 ;/* nothing to do */ + }else { +if (!lv_snapshot_percent (lv, &percent)) + return_0; +if (!(PERCENT_0 < percent && percent <PERCENT_100 ) || percent <= policy_threshold) +return 1 ;/* nothing to do */ + } + + lp->extents = policy_amount; + +return 1 ; +} + +static uint32_t lvseg_get_stripes (struct lv_segment *seg,uint32_t *stripesize) +{ +uint32_t s; +struct lv_segment *seg_mirr; + +/* If segment mirrored, check if images are striped */ +if (seg_is_mirrored (seg)) +for (s =0 ; s < seg->area_count; s++) { +if (seg_type (seg, s) !=AREA_LV ) +continue ; + seg_mirr =first_seg (seg_lv (seg, s)); + +if (seg_is_striped (seg_mirr)) { + seg = seg_mirr; +break ; + } + } + + +if (seg_is_striped (seg)) { + *stripesize = seg->stripe_size; +return seg->area_count; + } + + *stripesize =0 ; +return 0 ; +} + +int lv_resize (struct cmd_context *cmd,struct volume_group *vg, +struct lvresize_params *lp,struct dm_list *pvh) +{ +struct logical_volume *lv; +struct lvinfo info; +uint32_t stripesize_extents; +uint32_t seg_stripes =0 , seg_stripesize =0 , seg_size; +uint32_t seg_mirrors =0 ; +uint32_t extents_used; +uint32_t size_rest; +uint32_t pv_extent_count; +alloc_policy_t alloc; +struct logical_volume *lock_lv; +struct lv_list *lvl; +struct lv_segment *seg, *uninitialized_var (mirr_seg ); +uint32_t seg_extents; +uint32_t sz, str; +int status; + +/* does LV exist? */ +if (!(lvl =find_lv_in_vg (vg, lp->lv_name))) { +log_error ("Logical volume %s not found in volume group %s" , + lp->lv_name, lp->vg_name); +return ECMD_FAILED ; + } + +if (lv_is_external_origin (lvl->lv)) { +/* +* Since external-origin can be activated read-only, +* there is no way to use extended areas. +*/ +log_error ("Cannot resize external origin \"%s\"." , lvl->lv->name); +return EINVALID_CMD_LINE ; + } + +if (lvl->lv->status & (RAID_IMAGE |RAID_META )) { +log_error ("Cannot resize a RAID %s directly" , + (lvl->lv->status &RAID_IMAGE ) ?"image" : +"metadata area" ); +return ECMD_FAILED ; + } + +if (lv_is_raid_with_tracking (lvl->lv)) { +log_error ("Cannot resize %s while it is tracking a split image" , + lvl->lv->name); +return ECMD_FAILED ; + } + +if (lp->ac_stripes) { +if (vg->fid->fmt->features &FMT_SEGMENTS ) + lp->stripes = lp->ac_stripes_value; +else +log_warn ("Varied striping not supported. Ignoring." ); + } + +if (lp->ac_mirrors) { +if (vg->fid->fmt->features &FMT_SEGMENTS ) + lp->mirrors = lp->ac_mirrors_value; +else +log_warn ("Mirrors not supported. Ignoring." ); + } + +if (lp->ac_stripesize && + !_validate_stripesize (cmd, vg, lp)) +return EINVALID_CMD_LINE ; + + lv = lvl->lv; + +if (lp->ac_policy) { +if (!lv_is_cow (lv) && + !lv_is_thin_pool (lv)) { +log_error ("Policy-based resize is supported only for snapshot and thin pool volumes." ); +return ECMD_FAILED ; + } +if (!_adjust_policy_params (cmd, lv, lp)) +return ECMD_FAILED ; + } + +if (!lv_is_visible (lv)) { +log_error ("Can't resize internal logical volume %s" , lv->name); +return ECMD_FAILED ; + } + +if (lv->status &LOCKED ) { +log_error ("Can't resize locked LV %s" , lv->name); +return ECMD_FAILED ; + } + +if (lv->status &CONVERTING ) { +log_error ("Can't resize %s while lvconvert in progress" , lv->name); +return ECMD_FAILED ; + } + + alloc = (alloc_policy_t)(lp->ac_alloc)?lp->ac_alloc: lv->alloc; + +/* +* First adjust to an exact multiple of extent size. +* When extending by a relative amount we round that amount up. +* When reducing by a relative amount we remove at most that amount. +* When changing to an absolute size, we round that size up. +*/ +if (lp->size) { +if (lp->size % vg->extent_size) { +if (lp->sign ==SIGN_MINUS ) + lp->size -= lp->size % vg->extent_size; +else + lp->size += vg->extent_size - + (lp->size % vg->extent_size); + +log_print_unless_silent ("Rounding size to boundary between physical extents: %s" , +display_size (cmd, lp->size)); + } + + lp->extents = lp->size / vg->extent_size; + } + +switch (lp->percent) { +case PERCENT_VG : + lp->extents =percent_of_extents (lp->extents, vg->extent_count, + (lp->sign !=SIGN_MINUS )); +break ; +case PERCENT_FREE : + lp->extents =percent_of_extents (lp->extents, vg->free_count, + (lp->sign !=SIGN_MINUS )); +break ; +case PERCENT_LV : + lp->extents =percent_of_extents (lp->extents, lv->le_count, + (lp->sign !=SIGN_MINUS )); +break ; +case PERCENT_PVS : +if (lp->argc) { + pv_extent_count =pv_list_extents_free (pvh); + lp->extents =percent_of_extents (lp->extents, pv_extent_count, + (lp->sign !=SIGN_MINUS )); + }else + lp->extents =percent_of_extents (lp->extents, vg->extent_count, + (lp->sign !=SIGN_MINUS )); +break ; +case PERCENT_ORIGIN : +if (!lv_is_cow (lv)) { +log_error ("Specified LV does not have an origin LV." ); +return EINVALID_CMD_LINE ; + } + lp->extents =percent_of_extents (lp->extents,origin_from_cow (lv)->le_count, + (lp->sign !=SIGN_MINUS )); +break ; +case PERCENT_NONE : +break ; + } + +if (lp->sign ==SIGN_PLUS ) { +if (lp->extents >= (MAX_EXTENT_COUNT - lv->le_count)) { +log_error ("Unable to extend %s by %u extents, exceeds limit (%u)." , + lp->lv_name, lv->le_count,MAX_EXTENT_COUNT ); +return EINVALID_CMD_LINE ; + } + lp->extents += lv->le_count; + } + +if (lp->sign ==SIGN_MINUS ) { +if (lp->extents >= lv->le_count) { +log_error ("Unable to reduce %s below 1 extent" , + lp->lv_name); +return EINVALID_CMD_LINE ; + } + + lp->extents = lv->le_count - lp->extents; + } + +if (!lp->extents) { +log_error ("New size of 0 not permitted" ); +return EINVALID_CMD_LINE ; + } + +if (lp->extents == lv->le_count) { +if (lp->ac_policy) +return ECMD_PROCESSED ;/* Nothing to do. */ +if (!lp->resizefs) { +log_error ("New size (%d extents) matches existing size " +"(%d extents)" , lp->extents, lv->le_count); +return EINVALID_CMD_LINE ; + } + lp->resize =LV_EXTEND ;/* lets pretend zero size extension */ + } + + seg_size = lp->extents - lv->le_count; + +/* Use segment type of last segment */ + dm_list_iterate_items(seg, &lv->segments) { + lp->segtype = seg->segtype; + } + +/* FIXME Support LVs with mixed segment types */ +if (lp->segtype !=get_segtype_from_string (cmd, (lp->ac_type)?lp->ac_type:lp->segtype->name)) { +log_error ("VolumeType does not match (%s)" , lp->segtype->name); +return EINVALID_CMD_LINE ; + } + +/* If extending, find mirrors of last segment */ +if ((lp->extents > lv->le_count)) { +/* +* Has the user specified that they would like the additional +* extents of a mirror not to have an initial sync? +*/ +if (seg_is_mirrored (first_seg (lv)) && lp->ac_no_sync) + lv->status |=LV_NOTSYNCED ; + + dm_list_iterate_back_items(mirr_seg, &lv->segments) { +if (seg_is_mirrored (mirr_seg)) + seg_mirrors =lv_mirror_count (mirr_seg->lv); +else + seg_mirrors =0 ; +break ; + } + +if (!lp->ac_mirrors && seg_mirrors) { +log_print_unless_silent ("Extending %" PRIu32" mirror images." , + seg_mirrors); + lp->mirrors = seg_mirrors; + } +if ((lp->ac_mirrors || seg_mirrors) && + (lp->mirrors != seg_mirrors)) { +log_error ("Cannot vary number of mirrors in LV yet." ); +return EINVALID_CMD_LINE ; + } + +if (seg_mirrors && !strcmp (mirr_seg->segtype->name,"raid10" )) { + lp->stripes = mirr_seg->area_count / seg_mirrors; + lp->stripe_size = mirr_seg->stripe_size; + } + } + +/* If extending, find stripes, stripesize & size of last segment */ +if ((lp->extents > lv->le_count) && + !(lp->stripes ==1 || (lp->stripes >1 && lp->stripe_size)) && +strcmp (mirr_seg->segtype->name,"raid10" )) { +/* FIXME Don't assume mirror seg will always be AREA_LV */ +/* FIXME We will need to support resize for metadata LV as well, +* and data LV could be any type (i.e. mirror)) */ +dm_list_iterate_items (seg, seg_mirrors ? &seg_lv (mirr_seg,0 )->segments : + lv_is_thin_pool(lv) ? &seg_lv(first_seg(lv), 0)->segments : &lv->segments) { +/* Allow through "striped" and RAID 4/5/6/10 */ +if (!seg_is_striped (seg) && + (!seg_is_raid (seg) ||seg_is_mirrored (seg)) && +strcmp (seg->segtype->name,"raid10" )) +continue ; + + sz = seg->stripe_size; + str = seg->area_count - lp->segtype->parity_devs; + +if ((seg_stripesize && seg_stripesize != sz && + sz && !lp->stripe_size) || + (seg_stripes && seg_stripes != str && !lp->stripes)) { +log_error ("Please specify number of " +"stripes (-i) and stripesize (-I)" ); +return EINVALID_CMD_LINE ; + } + + seg_stripesize = sz; + seg_stripes = str; + } + +if (!lp->stripes) + lp->stripes = seg_stripes; +else if (seg_is_raid (first_seg (lv)) && + (lp->stripes != seg_stripes)) { +log_error ("Unable to extend \"%s\" segment type with different number of stripes." ,first_seg (lv)->segtype->ops->name (first_seg (lv))); +return ECMD_FAILED ; + } + +if (!lp->stripe_size && lp->stripes >1 ) { +if (seg_stripesize) { +log_print_unless_silent ("Using stripesize of last segment %s" , +display_size (cmd, (uint64_t ) seg_stripesize)); + lp->stripe_size = seg_stripesize; + }else { + lp->stripe_size = +find_config_tree_int (cmd, metadata_stripesize_CFG) *2 ; +log_print_unless_silent ("Using default stripesize %s" , +display_size (cmd, (uint64_t ) lp->stripe_size)); + } + } + } + +/* If reducing, find stripes, stripesize & size of last segment */ +if (lp->extents < lv->le_count) { + extents_used =0 ; + +if (lp->stripes || lp->stripe_size || lp->mirrors) +log_error ("Ignoring stripes, stripesize and mirrors " +"arguments when reducing" ); + + dm_list_iterate_items(seg, &lv->segments) { + seg_extents = seg->len; + +/* Check for underlying stripe sizes */ + seg_stripes =lvseg_get_stripes (seg, &seg_stripesize); + +if (seg_is_mirrored (seg)) + seg_mirrors =lv_mirror_count (seg->lv); +else + seg_mirrors =0 ; + +if (lp->extents <= extents_used + seg_extents) +break ; + + extents_used += seg_extents; + } + + seg_size = lp->extents - extents_used; + lp->stripe_size = seg_stripesize; + lp->stripes = seg_stripes; + lp->mirrors = seg_mirrors; + } + +if (lp->stripes >1 && !lp->stripe_size) { +log_error ("Stripesize for striped segment should not be 0!" ); +return EINVALID_CMD_LINE ; + } + +if (lp->stripes >1 ) { +if (lp->stripe_size <STRIPE_SIZE_MIN ) { +log_error ("Invalid stripe size %s" , +display_size (cmd, (uint64_t ) lp->stripe_size)); +return EINVALID_CMD_LINE ; + } + +if (!(stripesize_extents = lp->stripe_size / vg->extent_size)) + stripesize_extents =1 ; + + size_rest = seg_size % (lp->stripes * stripesize_extents); +/* Round toward the original size. */ +if (size_rest && + ((lp->extents < lv->le_count) || + !lp->percent || + (vg->free_count >= (lp->extents - lv->le_count - size_rest + + (lp->stripes * stripesize_extents))))) { +log_print_unless_silent ("Rounding size (%d extents) up to stripe " +"boundary size for segment (%d extents)" , + lp->extents, lp->extents - size_rest + + (lp->stripes * stripesize_extents)); + lp->extents = lp->extents - size_rest + + (lp->stripes * stripesize_extents); + }else if (size_rest) { +log_print_unless_silent ("Rounding size (%d extents) down to stripe " +"boundary size for segment (%d extents)" , + lp->extents, lp->extents - size_rest); + lp->extents = lp->extents - size_rest; + } + } + +if (lp->extents < lv->le_count) { +if (lp->resize ==LV_EXTEND ) { +log_error ("New size given (%d extents) not larger " +"than existing size (%d extents)" , + lp->extents, lv->le_count); +return EINVALID_CMD_LINE ; + } + lp->resize =LV_REDUCE ; + }else if (lp->extents > lv->le_count) { +if (lp->resize ==LV_REDUCE ) { +log_error ("New size given (%d extents) not less than " +"existing size (%d extents)" , lp->extents, + lv->le_count); +return EINVALID_CMD_LINE ; + } + lp->resize =LV_EXTEND ; + }else if (lp->extents == lv->le_count) { +if (lp->ac_policy) +return ECMD_PROCESSED ;/* Nothing to do. */ +if (!lp->resizefs) { +log_error ("New size (%d extents) matches existing size " +"(%d extents)" , lp->extents, lv->le_count); +return EINVALID_CMD_LINE ; + } + lp->resize =LV_EXTEND ; + } + +if (lv_is_origin (lv)) { +if (lp->resize ==LV_REDUCE ) { +log_error ("Snapshot origin volumes cannot be reduced " +"in size yet." ); +return ECMD_FAILED ; + } + +if (lv_info (cmd, lv,0 , &info,0 ,0 ) && info.exists) { +log_error ("Snapshot origin volumes can be resized " +"only while inactive: try lvchange -an" ); +return ECMD_FAILED ; + } + } + +if (lv_is_thin_pool (lv)) { +if (lp->resize ==LV_REDUCE ) { +log_error ("Thin pool volumes cannot be reduced in size yet." ); +return ECMD_FAILED ; + } + +if (lp->resizefs) { +log_warn ("Thin pool volumes do not have filesystem." ); + lp->resizefs =0 ; + } + } + +if ((lp->resize ==LV_REDUCE ) && lp->argc) +log_warn ("Ignoring PVs on command line when reducing" ); + +/* Request confirmation before operations that are often mistakes. */ +if ((lp->resizefs || (lp->resize ==LV_REDUCE )) && + !_request_confirmation (cmd, vg, lv, lp)) { + stack; +return ECMD_FAILED ; + } + +if (lp->resizefs) { +if (!lp->nofsck && + !_fsadm_cmd (cmd, vg, lp,FSADM_CMD_CHECK , &status)) { +if (status !=FSADM_CHECK_FAILS_FOR_MOUNTED ) { +log_error ("Filesystem check failed." ); +return ECMD_FAILED ; + } +/* some filesystems supports online resize */ + } + +if ((lp->resize ==LV_REDUCE ) && + !_fsadm_cmd (cmd, vg, lp,FSADM_CMD_RESIZE ,NULL )) { +log_error ("Filesystem resize failed." ); +return ECMD_FAILED ; + } + } + +if (!archive (vg)) { + stack; +return ECMD_FAILED ; + } + +log_print_unless_silent ("%sing logical volume %s to %s" , + (lp->resize ==LV_REDUCE ) ?"Reduc" :"Extend" , + lp->lv_name, +display_size (cmd, (uint64_t ) lp->extents * vg->extent_size)); + +if (lp->resize ==LV_REDUCE ) { +if (!lv_reduce (lv, lv->le_count - lp->extents)) { + stack; +return ECMD_FAILED ; + } + }else if ((lp->extents > lv->le_count) &&/* Ensure we extend */ + !lv_extend (lv, lp->segtype, + lp->stripes, lp->stripe_size, + lp->mirrors,first_seg (lv)->region_size, + lp->extents - lv->le_count,NULL , + pvh, alloc)) { + stack; +return ECMD_FAILED ; + } + +/* store vg on disk(s) */ +if (!vg_write (vg)) { + stack; +return ECMD_FAILED ; + } + +/* If snapshot, must suspend all associated devices */ +if (lv_is_cow (lv)) + lock_lv =origin_from_cow (lv); +else + lock_lv = lv; + +if (!suspend_lv (cmd, lock_lv)) { +log_error ("Failed to suspend %s" , lp->lv_name); +vg_revert (vg); +backup (vg); +return ECMD_FAILED ; + } + +if (!vg_commit (vg)) { + stack; +if (!resume_lv (cmd, lock_lv)) + stack; +backup (vg); +return ECMD_FAILED ; + } + +if (!resume_lv (cmd, lock_lv)) { +log_error ("Problem reactivating %s" , lp->lv_name); +backup (vg); +return ECMD_FAILED ; + } + +backup (vg); + +/* +* Update lvm pool metadata (drop messages) if the pool has been +* resumed and do a pool active/deactivate in other case. +* +* Note: Active thin pool can be waiting for resize. +* +* FIXME: Activate only when thin volume is active +*/ +if (lv_is_thin_pool (lv) && + !update_pool_lv (lv, !lv_is_active (lv))) { + stack; +return ECMD_FAILED ; + } + +log_print_unless_silent ("Logical volume %s successfully resized" , lp->lv_name); + +if (lp->resizefs && (lp->resize ==LV_EXTEND ) && + !_fsadm_cmd (cmd, vg, lp,FSADM_CMD_RESIZE ,NULL )) { + stack; +return ECMD_FAILED ; + } + +return ECMD_PROCESSED ; +} +char *generate_lv_name (struct volume_group *vg,const char *format,char *buffer,size_t len) {
lib/metadata/metadata-exported.h +46 -0
58 lines not on this page · raw message
tools/lvresize.c +1 -772
791 lines not on this page · raw message
Signature · 1 line
1.8.1.4
PATCH 5/7 lvm2app: Implement lv resize (v2)
In reply to Tony AslesonSimplified version of lv resize.
--- lib/metadata/metadata-exported.h | 1 + liblvm/lvm2app.h | 2 -- liblvm/lvm_lv.c | 19 ++++++++++++++++--- 3 files changed, 17 insertions(+), 5 deletions(-)
lib/metadata/metadata-exported.h +1 -0
@@ -26,6 +26,7 @@#include "vg.h" #include "lv.h" #include "lvm-percent.h" +#include "errors.h" #define MAX_STRIPES 128U#define SECTOR_SHIFT 9L
liblvm/lvm2app.h +0 -2
@@ -1365,8 +1365,6 @@ int lvm_lv_rename(lv_t lv, const char *new_name);* * \memberof lv_t * -* NOTE: This function is currently not implemented. -* * \param lv * Logical volume handle. *
liblvm/lvm_lv.c +16 -3
@@ -309,9 +309,22 @@ int lvm_lv_rename(lv_t lv, const char *new_name)int lvm_lv_resize (const lv_t lv,uint64_t new_size) { -/* FIXME: add lv resize code here */ -log_error ("NOT IMPLEMENTED YET" ); -return -1 ; +struct lvresize_params lp = {0 }; + + lp.vg_name = lv->vg->name; + lp.lv_name = lv->name; + lp.sign =SIGN_NONE ; + lp.percent =PERCENT_NONE ; + lp.resize =LV_ANY ; + lp.size = new_size >>SECTOR_SHIFT ; + lp.ac_force =1 ;/* Assume the user has a good backup? */ + +if (ECMD_PROCESSED !=lv_resize (lv->vg->cmd, lv->vg, &lp, &lv->vg->pvs)) { +log_verbose ("LV Re-size failed." ); +return -1 ; + } + +return 0 ; }lv_t lvm_lv_snapshot (const lv_t lv,const char *snap_name,uint64_t max_snap_size)
Signature · 1 line
1.8.1.4
PATCH 6/7 lvm2app: Add function to retrieve list of PVs
In reply to Tony AslesonAs locks are held, you need to call the included function to release the memory and locks when done transversing the list of physical volumes.
--- lib/metadata/metadata-exported.h | 12 +++- lib/metadata/metadata.c | 81 +++++++++++++++------ liblvm/lvm2app.h | 28 ++++++++ liblvm/lvm_pv.c | 79 ++++++++++++++++++++ python/liblvm.c | 152 ++++++++++++++++++++++++++++++++++++--- 5 files changed, 322 insertions(+), 30 deletions(-)
lib/metadata/metadata-exported.h +11 -1
@@ -393,6 +393,11 @@ struct lv_list {struct logical_volume *lv; }; +struct vg_list { +struct dm_list list; +struct volume_group *vg; +}; +#define PV_PE_START_CALC ((uint64_t) -1)/* Calculate pe_start value */ struct pvcreate_restorable_params {
@@ -480,7 +485,12 @@ struct volume_group *vg_read_internal(struct cmd_context *cmd, const char *vg_nastruct physical_volume *pv_read (struct cmd_context *cmd,const char *pv_name,int warnings,int scan_label_only); -struct dm_list *get_pvs (struct cmd_context *cmd); + +#define get_pvs ( cmd ) get_pvs_internal((cmd), NULL, NULL) +#define get_pvs_perserve_vg ( cmd, pv_list, vg_list ) get_pvs_internal((cmd), (pv_list), (vg_list)) + +struct dm_list *get_pvs_internal (struct cmd_context *cmd, +struct dm_list *pvslist,struct dm_list *vgslist);/* * Add/remove LV to/from volume group
lib/metadata/metadata.c +60 -21
118 lines not on this page · raw message
liblvm/lvm2app.h +28 -0
@@ -534,6 +534,34 @@ vg_t lvm_vg_create(lvm_t libh, const char *vg_name);struct dm_list *lvm_vg_list_lvs (vg_t vg);/** +* Return a list of PV handles for all. +* +* \memberof lvm_t +* +* \param libh +* Library handle retrieved from lvm_init +* +* \return +* A list of lvm_pv_list structures containing pv handles for all physical +* volumes. If no PVs exist or a global lock was unable to be obtained a +* NULL is returned. +*/ +struct dm_list *lvm_list_pvs (lvm_t libh); + +/** +* Free the resources used by acquiring the pvlist. This should be called as +* soon as possible after processing the needed information from the pv list as +* a global locks are held. +* +* \param pvlist +* PV list to be freed +* +* \return +* 0 on success, else -1 with library errno and text set. +*/ +int lvm_list_pvs_free (struct dm_list *pvlist); + +/** * Return a list of PV handles for a given VG handle. * * \memberof vg_t
liblvm/lvm_pv.c +79 -0
96 lines not on this page · raw message
python/liblvm.c +144 -8
224 lines not on this page · raw message
Signature · 1 line
1.8.1.4
PATCH 7/7 config_def_check: Fix memory leak
In reply to Tony AslesonThere is no need to strdup a key when inserting into the hash table as the table allocates memory and copies the string. This was causing memory to be lost.
--- lib/config/config.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/config/config.c +1 -1
@@ -577,7 +577,7 @@ int config_def_check(struct cmd_context *cmd, int force, int skip, int suppress_ cmd->cft_def_hash =NULL ; r =0 ; goto out; } -dm_hash_insert (cmd->cft_def_hash,dm_strdup (vp), def); +dm_hash_insert (cmd->cft_def_hash, vp, def); } }
Signature · 1 line
1.8.1.4
PATCH 7/7 config_def_check: Fix memory leak
Quoted 15 lines · Tony Asleson
There is no need to strdup a key when inserting into the hash table as the table allocates memory and copies the string. This was causing memory to be lost.
Signed-off-by Tony Asleson <[email protected]>--- lib/config/config.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)lib/config/config.c +0
-0
lib/config/config.c int config_def_check(struct cmd_context *cmd, int force, int skip, int suppress_ · line 583
Quoted 8 lines
lib/config/config.c +1
-1@@ -577,7 +577,7 @@ int config_def_check(struct cmd_context *cmd, int force, int skip, int suppress_ cmd->cft_def_hash =NULL ; r =0 ; goto out; } -dm_hash_insert (cmd->cft_def_hash,dm_strdup (vp), def); +dm_hash_insert (cmd->cft_def_hash, vp, def); } }
I've committed this one. Thanks for spotting it!
Peter