June 2020 - lvm2-commits - Fedora mailing-lists

master - integrity: add initial size to metadata size
by David Teigland 30 Jun '20

30 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=ad773511c59aea239592c… Commit: ad773511c59aea239592c014a2dab4161ed92214 Parent: 3f32f9811e01c8953d201c7c9b563561ad856130 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Tue Jun 30 12:52:27 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Jun 30 16:43:05 2020 -0500 integrity: add initial size to metadata size The metadata device size needs to include space for the dm-integrity "initial_sectors" which hold journals. --- lib/metadata/integrity_manip.c | 28 +++++++++++++++++++++++++++- test/shell/integrity-large.sh | 20 +++++++++++--------- 2 files changed, 38 insertions(+), 10 deletions(-) diff --git a/lib/metadata/integrity_manip.c b/lib/metadata/integrity_manip.c index b622743f0..3322a2101 100644 --- a/lib/metadata/integrity_manip.c +++ b/lib/metadata/integrity_manip.c @@ -28,6 +28,7 @@ #define DEFAULT_BLOCK_SIZE 512 #define ONE_MB_IN_BYTES 1048576 +#define ONE_GB_IN_BYTES 1073741824 int lv_is_integrity_origin(const struct logical_volume *lv) { @@ -45,10 +46,35 @@ int lv_is_integrity_origin(const struct logical_volume *lv) /* * Every 500M of data needs 4M of metadata. * (From trial and error testing.) + * + * plus some initial space for journals. + * (again from trial and error testing.) */ static uint64_t _lv_size_bytes_to_integrity_meta_bytes(uint64_t lv_size_bytes) { - return ((lv_size_bytes / (500 * ONE_MB_IN_BYTES)) + 1) * (4 * ONE_MB_IN_BYTES); + uint64_t meta_bytes; + uint64_t initial_bytes; + + /* Every 500M of data needs 4M of metadata. */ + meta_bytes = ((lv_size_bytes / (500 * ONE_MB_IN_BYTES)) + 1) * (4 * ONE_MB_IN_BYTES); + + /* + * initial space used for journals + * lv_size <= 512M -> 4M + * lv_size <= 1G -> 8M + * lv_size <= 4G -> 32M + * lv_size > 4G -> 64M + */ + if (lv_size_bytes <= (512 * ONE_MB_IN_BYTES)) + initial_bytes = 4 * ONE_MB_IN_BYTES; + else if (lv_size_bytes <= ONE_GB_IN_BYTES) + initial_bytes = 8 * ONE_MB_IN_BYTES; + else if (lv_size_bytes <= (4ULL * ONE_GB_IN_BYTES)) + initial_bytes = 32 * ONE_MB_IN_BYTES; + else if (lv_size_bytes > (4ULL * ONE_GB_IN_BYTES)) + initial_bytes = 64 * ONE_MB_IN_BYTES; + + return meta_bytes + initial_bytes; } /* diff --git a/test/shell/integrity-large.sh b/test/shell/integrity-large.sh index 1df9e6b53..06b0e03db 100644 --- a/test/shell/integrity-large.sh +++ b/test/shell/integrity-large.sh @@ -23,7 +23,7 @@ mnt="mnt" mkdir -p $mnt # raid1 LV needs to be extended to 512MB to test imeta being exended -aux prepare_devs 4 600 +aux prepare_devs 4 632 printf "%0.sA" {1..16384} >> fileA printf "%0.sB" {1..16384} >> fileB @@ -131,8 +131,8 @@ _verify_data_on_lv _wait_recalc $vg/${lv1}_rimage_0 _wait_recalc $vg/${lv1}_rimage_1 lvs -a -o+devices $vg -check lv_field $vg/${lv1}_rimage_0_imeta size "8.00m" -check lv_field $vg/${lv1}_rimage_1_imeta size "8.00m" +check lv_field $vg/${lv1}_rimage_0_imeta size "12.00m" +check lv_field $vg/${lv1}_rimage_1_imeta size "12.00m" # provide space to extend the images onto new devs vgextend $vg "$dev3" "$dev4" @@ -153,33 +153,35 @@ lvconvert --raidintegrity y $vg/$lv1 _wait_recalc $vg/${lv1}_rimage_0 _wait_recalc $vg/${lv1}_rimage_1 lvs -a -o+devices $vg -check lv_field $vg/${lv1}_rimage_0_imeta size "12.00m" -check lv_field $vg/${lv1}_rimage_1_imeta size "12.00m" +check lv_field $vg/${lv1}_rimage_0_imeta size "20.00m" +check lv_field $vg/${lv1}_rimage_1_imeta size "20.00m" lvchange -an $vg/$lv1 lvremove $vg/$lv1 # this succeeds because dev1,dev2 can hold rmeta+rimage lvcreate --type raid1 -n $lv1 -L 592M -an $vg "$dev1" "$dev2" +lvs -a -o+devices $vg +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 # this fails because dev1,dev2 can hold rmeta+rimage, but not imeta # and we require imeta to be on same devs as rmeta/rimeta -not lvcreate --type raid1 --raidintegrity y -n $lv1 -L 592M -an $vg "$dev1" "$dev2" +not lvcreate --type raid1 --raidintegrity y -n $lv1 -L 624M -an $vg "$dev1" "$dev2" lvs -a -o+devices $vg -lvremove $vg/$lv1 # this can allocate from more devs so there's enough space for imeta to # be allocated in the vg, but lvcreate fails because rmeta+rimage are # allocated from dev1,dev2, we restrict imeta to being allocated on the # same devs as rmeta/rimage, and dev1,dev2 can't fit imeta. -not lvcreate --type raid1 --raidintegrity y -n $lv1 -L 592M -an $vg +not lvcreate --type raid1 --raidintegrity y -n $lv1 -L 624M -an $vg lvs -a -o+devices $vg # counterintuitively, increasing the size will allow lvcreate to succeed # because rmeta+rimage are pushed to being allocated on dev1,dev2,dev3,dev4 # which means imeta is now free to be allocated from dev3,dev4 which have # plenty of space -lvcreate --type raid1 --raidintegrity y -n $lv1 -L 600M -an $vg +lvcreate --type raid1 --raidintegrity y -n $lv1 -L 640M -an $vg lvs -a -o+devices $vg vgremove -ff $vg

1 0

master - tests: check pool metadata are zeroed
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=3f32f9811e01c8953d201… Commit: 3f32f9811e01c8953d201c7c9b563561ad856130 Parent: 094d6f80ddb6d8a1c64977dfaae4073827063fe3 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Wed Jun 24 14:42:11 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 tests: check pool metadata are zeroed --- test/lib/aux.sh | 1 + test/shell/lvcreate-thin.sh | 21 +++++++++++++++++++++ 2 files changed, 22 insertions(+) diff --git a/test/lib/aux.sh b/test/lib/aux.sh index e40da9592..17e7935ee 100644 --- a/test/lib/aux.sh +++ b/test/lib/aux.sh @@ -1234,6 +1234,7 @@ activation/verify_udev_operations = $LVM_VERIFY_UDEV activation/raid_region_size = 512 allocation/wipe_signatures_when_zeroing_new_lvs = 0 allocation/vdo_slab_size_mb = 128 +allocation/zero_metadata = 0 backup/archive = 0 backup/backup = 0 devices/cache_dir = "$TESTDIR/etc" diff --git a/test/shell/lvcreate-thin.sh b/test/shell/lvcreate-thin.sh index 9ca7f1141..c073eaf24 100644 --- a/test/shell/lvcreate-thin.sh +++ b/test/shell/lvcreate-thin.sh @@ -248,4 +248,25 @@ not lvcreate -s $vg/lv1 -L4M -V2G --name $vg/lv4 not lvcreate -T mirpool -L4M --alloc anywhere -m1 $vg not lvcreate --thinpool mirpool -L4M --alloc anywhere -m1 $vg + +# Check pool metadata volume is zeroed, when zero_metadata is enabled. +# 1st. ensure 8megs of both PVs will have some non-0 data +lvcreate -L8m -n $lv1 $vg "$dev1" +lvextend -L+8m $vg/$lv1 "$dev2" +dd if=/dev/urandom of="$DM_DEV_DIR/$vg/$lv1" bs=1M count=16 oflag=direct conv=fdatasync +lvremove -ff $vg/$lv1 + +lvcreate -l1 --poolmetadatasize 4m --conf 'allocation/zero_metadata=1' -vvvv -T $vg/pool +lvchange -an $vg +# component activation to check device was zeroed +lvchange -y -ay $vg/pool_tmeta +dd if="$DM_DEV_DIR/$vg/pool_tmeta" of=file bs=1M count=3 skip=1 iflag=direct conv=fdatasync + +md5sum -b file | tee out +# md5sum of 3M of zeros +grep d1dd210d6b1312cb342b56d02bd5e651 out +lvchange -an $vg +lvremove -ff $vg + + vgremove -ff $vg

1 0

master - tests: failure of zeroing fails command
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=094d6f80ddb6d8a1c6497… Commit: 094d6f80ddb6d8a1c64977dfaae4073827063fe3 Parent: 88b92d4225b90db82047f3bac55d8059918e9c1b Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Tue Jun 23 14:10:18 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 tests: failure of zeroing fails command --- test/shell/lvcreate-signature-wiping.sh | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/shell/lvcreate-signature-wiping.sh b/test/shell/lvcreate-signature-wiping.sh index 73fea54fd..18d7a2f7e 100644 --- a/test/shell/lvcreate-signature-wiping.sh +++ b/test/shell/lvcreate-signature-wiping.sh @@ -42,6 +42,13 @@ init_lv_ test_blkid_ || skip lvremove -f $vg/$lv1 +# Zeroing stops the command when there is a failure (write error in this case) +aux error_dev "$dev1" "$(get first_extent_sector "$dev1"):2" +not lvcreate -l1 -n $lv1 $vg 2>&1 | tee out +grep "Failed to initialize" out +aux enable_dev "$dev1" + + aux lvmconf "allocation/wipe_signatures_when_zeroing_new_lvs = 0" lvcreate -y -Zn -l1 -n $lv1 $vg 2>&1 | tee out

1 0

master - make: make generate
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=88b92d4225b90db82047f… Commit: 88b92d4225b90db82047f3bac55d8059918e9c1b Parent: b7885dbb734de97e39dca28a38850cbb623cf57f Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Tue Jun 23 12:19:35 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 make: make generate update --- conf/example.conf.in | 6 +- man/lvconvert.8_pregen | 58 ++++++++++++ man/lvcreate.8_pregen | 246 +++++++++++++++++++++++++++++++++++++++++++++---- man/lvs.8_pregen | 4 + man/vgck.8_pregen | 9 ++ 5 files changed, 303 insertions(+), 20 deletions(-) diff --git a/conf/example.conf.in b/conf/example.conf.in index 05b085792..a3d8ca380 100644 --- a/conf/example.conf.in +++ b/conf/example.conf.in @@ -488,7 +488,7 @@ allocation { # This configuration option does not have a default value defined. # Configuration option allocation/thin_pool_metadata_require_separate_pvs. - # Thin pool metdata and data will always use different PVs. + # Thin pool metadata and data will always use different PVs. thin_pool_metadata_require_separate_pvs = 0 # Configuration option allocation/thin_pool_zero. @@ -526,6 +526,10 @@ allocation { # This configuration option has an automatic default value. # thin_pool_chunk_size_policy = "generic" + # Configuration option allocation/zero_metadata. + # Zero whole metadata area before use with thin or cache pool. + zero_metadata = 1 + # Configuration option allocation/thin_pool_chunk_size. # The minimal chunk size in KiB for thin pool volumes. # Larger chunk sizes may improve performance for plain thin volumes, diff --git a/man/lvconvert.8_pregen b/man/lvconvert.8_pregen index 74409848c..37b0a47d2 100644 --- a/man/lvconvert.8_pregen +++ b/man/lvconvert.8_pregen @@ -22,6 +22,10 @@ lvconvert - Change logical volume layout \fB-H\fP|\fB--cache\fP .ad b .br +.ad l + \fB--cachedevice\fP \fIPV\fP +.ad b +.br .ad l \fB--cachemetadataformat\fP \fBauto\fP|\fB1\fP|\fB2\fP .ad b @@ -42,6 +46,10 @@ lvconvert - Change logical volume layout \fB--cachesettings\fP \fIString\fP .ad b .br +.ad l + \fB--cachesize\fP \fISize\fP[m|UNIT] +.ad b +.br .ad l \fB--cachevol\fP \fILV\fP .ad b @@ -738,6 +746,44 @@ Attach a cache to an LV, converts the LV to type cache. .br - +Add a writecache to an LV, using a specified cache device. +.br +.P +\fBlvconvert\fP \fB--type\fP \fBwritecache\fP \fB--cachedevice\fP \fIPV\fP \fILV\fP +.br +.RS 4 +.ad l +[ \fB--cachesize\fP \fISize\fP[m|UNIT] ] +.ad b +.br +.ad l +[ \fB--cachesettings\fP \fIString\fP ] +.ad b +.br +[ COMMON_OPTIONS ] +.RE +.br +- + +Add a cache to an LV, using a specified cache device. +.br +.P +\fBlvconvert\fP \fB--type\fP \fBcache\fP \fB--cachedevice\fP \fIPV\fP \fILV\fP +.br +.RS 4 +.ad l +[ \fB--cachesize\fP \fISize\fP[m|UNIT] ] +.ad b +.br +.ad l +[ \fB--cachesettings\fP \fIString\fP ] +.ad b +.br +[ COMMON_OPTIONS ] +.RE +.br +- + Convert LV to type thin-pool. .br .P @@ -1135,6 +1181,12 @@ See \fBlvmcache\fP(7) for more information about LVM caching. .ad b .HP .ad l +\fB--cachedevice\fP \fIPV\fP +.br +The name of a device to use for a cache. +.ad b +.HP +.ad l \fB--cachemetadataformat\fP \fBauto\fP|\fB1\fP|\fB2\fP .br Specifies the cache metadata format used by cache target. @@ -1182,6 +1234,12 @@ See \fBlvmcache\fP(7) for more information. .ad b .HP .ad l +\fB--cachesize\fP \fISize\fP[m|UNIT] +.br +The size of cache to use. +.ad b +.HP +.ad l \fB--cachevol\fP \fILV\fP .br The name of a cache volume. diff --git a/man/lvcreate.8_pregen b/man/lvcreate.8_pregen index be8e78389..ee6903431 100644 --- a/man/lvcreate.8_pregen +++ b/man/lvcreate.8_pregen @@ -30,6 +30,10 @@ lvcreate - Create a logical volume \fB-H\fP|\fB--cache\fP .ad b .br +.ad l + \fB--cachedevice\fP \fIPV\fP +.ad b +.br .ad l \fB--cachemetadataformat\fP \fBauto\fP|\fB1\fP|\fB2\fP .ad b @@ -50,6 +54,14 @@ lvcreate - Create a logical volume \fB--cachesettings\fP \fIString\fP .ad b .br +.ad l + \fB--cachesize\fP \fISize\fP[m|UNIT] +.ad b +.br +.ad l + \fB--cachevol\fP \fILV\fP +.ad b +.br .ad l \fB-c\fP|\fB--chunksize\fP \fISize\fP[k|UNIT] .ad b @@ -816,11 +828,9 @@ where the new thin pool is named by the --thinpool arg. .RE - -Create a cache LV, first creating a new origin LV, +Create a new LV, then attach the specified cachepool .br -then combining it with the existing cache pool named -.br -by the --cachepool arg. +which converts the new LV to type cache. .br .P \fBlvcreate\fP \fB--type\fP \fBcache\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] @@ -881,6 +891,190 @@ by the --cachepool arg. .RE - +Create a new LV, then attach the specified cachevol +.br +which converts the new LV to type cache. +.br +.P +\fBlvcreate\fP \fB--type\fP \fBcache\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] +.RS 5 + \fB--cachevol\fP \fILV\fP \fIVG\fP +.RE +.br +.RS 4 +.ad l +[ \fB-l\fP|\fB--extents\fP \fINumber\fP[PERCENT] ] +.ad b +.br +.ad l +[ \fB-c\fP|\fB--chunksize\fP \fISize\fP[k|UNIT] ] +.ad b +.br +.ad l +[ \fB-i\fP|\fB--stripes\fP \fINumber\fP ] +.ad b +.br +.ad l +[ \fB-I\fP|\fB--stripesize\fP \fISize\fP[k|UNIT] ] +.ad b +.br +.ad l +[ \fB--cachemode\fP \fBwritethrough\fP|\fBwriteback\fP|\fBpassthrough\fP ] +.ad b +.br +.ad l +[ \fB--cachepolicy\fP \fIString\fP ] +.ad b +.br +.ad l +[ \fB--cachesettings\fP \fIString\fP ] +.ad b +.br +.ad l +[ \fB--cachemetadataformat\fP \fBauto\fP|\fB1\fP|\fB2\fP ] +.ad b +.br +[ COMMON_OPTIONS ] +.RE +.br +.RS 4 +[ \fIPV\fP ... ] +.RE +- + +Create a new LV, then attach a cachevol created from +.br +the specified cache device, which converts the +.br +new LV to type cache. +.br +.P +\fBlvcreate\fP \fB--type\fP \fBcache\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] +.RS 5 + \fB--cachedevice\fP \fIPV\fP \fIVG\fP +.RE +.br +.RS 4 +.ad l +[ \fB-l\fP|\fB--extents\fP \fINumber\fP[PERCENT] ] +.ad b +.br +.ad l +[ \fB-c\fP|\fB--chunksize\fP \fISize\fP[k|UNIT] ] +.ad b +.br +.ad l +[ \fB-i\fP|\fB--stripes\fP \fINumber\fP ] +.ad b +.br +.ad l +[ \fB-I\fP|\fB--stripesize\fP \fISize\fP[k|UNIT] ] +.ad b +.br +.ad l +[ \fB--cachemode\fP \fBwritethrough\fP|\fBwriteback\fP|\fBpassthrough\fP ] +.ad b +.br +.ad l +[ \fB--cachepolicy\fP \fIString\fP ] +.ad b +.br +.ad l +[ \fB--cachesettings\fP \fIString\fP ] +.ad b +.br +.ad l +[ \fB--cachemetadataformat\fP \fBauto\fP|\fB1\fP|\fB2\fP ] +.ad b +.br +.ad l +[ \fB--cachesize\fP \fISize\fP[m|UNIT] ] +.ad b +.br +[ COMMON_OPTIONS ] +.RE +.br +.RS 4 +[ \fIPV\fP ... ] +.RE +- + +Create a new LV, then attach the specified cachevol +.br +which converts the new LV to type writecache. +.br +.P +\fBlvcreate\fP \fB--type\fP \fBwritecache\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] +.RS 5 + \fB--cachevol\fP \fILV\fP \fIVG\fP +.RE +.br +.RS 4 +.ad l +[ \fB-l\fP|\fB--extents\fP \fINumber\fP[PERCENT] ] +.ad b +.br +.ad l +[ \fB-i\fP|\fB--stripes\fP \fINumber\fP ] +.ad b +.br +.ad l +[ \fB-I\fP|\fB--stripesize\fP \fISize\fP[k|UNIT] ] +.ad b +.br +.ad l +[ \fB--cachesettings\fP \fIString\fP ] +.ad b +.br +[ COMMON_OPTIONS ] +.RE +.br +.RS 4 +[ \fIPV\fP ... ] +.RE +- + +Create a new LV, then attach a cachevol created from +.br +the specified cache device, which converts the +.br +new LV to type writecache. +.br +.P +\fBlvcreate\fP \fB--type\fP \fBwritecache\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] +.RS 5 + \fB--cachedevice\fP \fIPV\fP \fIVG\fP +.RE +.br +.RS 4 +.ad l +[ \fB-l\fP|\fB--extents\fP \fINumber\fP[PERCENT] ] +.ad b +.br +.ad l +[ \fB-i\fP|\fB--stripes\fP \fINumber\fP ] +.ad b +.br +.ad l +[ \fB-I\fP|\fB--stripesize\fP \fISize\fP[k|UNIT] ] +.ad b +.br +.ad l +[ \fB--cachesize\fP \fISize\fP[m|UNIT] ] +.ad b +.br +.ad l +[ \fB--cachesettings\fP \fIString\fP ] +.ad b +.br +[ COMMON_OPTIONS ] +.RE +.br +.RS 4 +[ \fIPV\fP ... ] +.RE +- + Common options for command: . .RS 4 @@ -1091,6 +1285,12 @@ See \fBlvmcache\fP(7) for more information about LVM caching. .ad b .HP .ad l +\fB--cachedevice\fP \fIPV\fP +.br +The name of a device to use for a cache. +.ad b +.HP +.ad l \fB--cachemetadataformat\fP \fBauto\fP|\fB1\fP|\fB2\fP .br Specifies the cache metadata format used by cache target. @@ -1138,6 +1338,18 @@ See \fBlvmcache\fP(7) for more information. .ad b .HP .ad l +\fB--cachesize\fP \fISize\fP[m|UNIT] +.br +The size of cache to use. +.ad b +.HP +.ad l +\fB--cachevol\fP \fILV\fP +.br +The name of a cache volume. +.ad b +.HP +.ad l \fB-c\fP|\fB--chunksize\fP \fISize\fP[k|UNIT] .br The size of chunks in a snapshot, cache pool or thin pool. @@ -2659,11 +2871,11 @@ config setting sparse_segtype_default. .RE - -Create a cache LV, first creating a new origin LV, +Create a new LV, then attach the specified cachepool .br -then combining it with the existing cache pool named +which converts the new LV to type cache .br -by the --cachepool arg (variant, infers --type cache). +(variant, infers --type cache.) .br .P \fBlvcreate\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] \fB--cachepool\fP \fILV\fP\fI_cachepool\fP \fIVG\fP @@ -2717,11 +2929,11 @@ by the --cachepool arg (variant, infers --type cache). .RE - -Create a cache LV, first creating a new origin LV, +Create a new LV, then attach the specified cachepool .br -then combining it with the existing cache pool named +which converts the new LV to type cache. .br -in the first arg (variant, also use --cachepool). +(variant, also use --cachepool). .br .P \fBlvcreate\fP \fB--type\fP \fBcache\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] \fILV\fP\fI_cachepool\fP @@ -2779,19 +2991,15 @@ in the first arg (variant, also use --cachepool). .RE - -When LV is a cache pool, create a cache LV, -.br -first creating a new origin LV, then combining it with -.br -the existing cache pool named in the first arg +When the LV arg is a cachepool, then create a new LV and .br -(variant, infers --type cache, also use --cachepool). +attach the cachepool arg to it. .br -When LV is not a cache pool, convert the specified LV +(variant, use --type cache and --cachepool.) .br -to type cache after creating a new cache pool LV to use +When the LV arg is not a cachepool, then create a new cachepool .br -(use lvconvert). +and attach it to the LV arg (alternative, use lvconvert.) .br .P \fBlvcreate\fP \fB-H\fP|\fB--cache\fP \fB-L\fP|\fB--size\fP \fISize\fP[m|UNIT] \fILV\fP diff --git a/man/lvs.8_pregen b/man/lvs.8_pregen index 8c3091dee..8aea3566a 100644 --- a/man/lvs.8_pregen +++ b/man/lvs.8_pregen @@ -577,6 +577,10 @@ Related to Thin Logical Volumes: (F)ailed. .br (F)ailed is set when related thin pool enters Failed state and no further I/O is permitted at all. +.IP +Related to writecache logical volumes: (E)rror. +.br +(E)rror is set dm-writecache reports an error. .IP 10 3 s(k)ip activation: this volume is flagged to be skipped during activation. .SH SEE ALSO diff --git a/man/vgck.8_pregen b/man/vgck.8_pregen index a66de5d7f..2a1ec2364 100644 --- a/man/vgck.8_pregen +++ b/man/vgck.8_pregen @@ -199,6 +199,15 @@ back metadata it believes has changed but hasn't. \fB--updatemetadata\fP .br Update VG metadata to correct problems. +If VG metadata was updated while a PV was missing, and the PV +reappears with an old version of metadata, then this option +(or any other command that writes metadata) will update the +metadata on the previously missing PV. If a PV was removed +from a VG while it was missing, and the PV reappears, using +this option will clear the outdated metadata from the previously +missing PV. If metadata text is damaged on one PV, using this +option will replace the damaged metadata text. For more severe +damage, e.g. with headers, see \fBpvck\fP(8). .ad b .HP .ad l

1 0

master - man: update cache page
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=b7885dbb734de97e39dca… Commit: b7885dbb734de97e39dca28a38850cbb623cf57f Parent: cca2a652d1ac2fa67677e3dca50141efa8e2c1a9 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Tue Jun 23 12:19:54 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 man: update cache page Few more sentences around migration threshold. --- man/lvmcache.7_main | 55 +++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 51 insertions(+), 4 deletions(-) diff --git a/man/lvmcache.7_main b/man/lvmcache.7_main index 244ea1e48..37d0e3359 100644 --- a/man/lvmcache.7_main +++ b/man/lvmcache.7_main @@ -129,6 +129,17 @@ attached. LV VG Attr Type Devices fast vg -wi------- linear /dev/fast_ssd main vg -wi------- linear /dev/slow_hhd + +To stop caching the main LV and also remove unneeded cache pool, +use the --uncache: + +.nf + $ lvconvert --uncache vg/main + + $ lvs -a + LV VG Attr Type Devices + main vg -wi------- linear /dev/slow_hhd + .fi .SS Create a new LV with caching. @@ -170,8 +181,10 @@ same fast LV. This option can be used with dm-writecache or dm-cache. Pass this option a cachepool LV or a standard LV. When using a cache pool, lvm places cache data and cache metadata on different LVs. The two -LVs together are called a cache pool. This permits specific placement of -data and metadata. A cache pool is represented as a special type of LV +LVs together are called a cache pool. This has a bit better performance +for dm-cache and permits specific placement and segment type selection +for data and metadata volumes. +A cache pool is represented as a special type of LV that cannot be used directly. If a standard LV is passed with this option, lvm will first convert it to a cache pool by combining it with another LV to use for metadata. This option can be used with dm-cache. @@ -361,11 +374,16 @@ $ lvconvert --type cache --cachevol fast \\ The size of data blocks managed by dm-cache can be specified with the --chunksize option when caching is started. The default unit is KiB. The -value must be a multiple of 32KiB between 32KiB and 1GiB. +value must be a multiple of 32KiB between 32KiB and 1GiB. Cache chunks +bigger then 512KiB shall be only used when necessary. Using a chunk size that is too large can result in wasteful use of the cache, in which small reads and writes cause large sections of an LV to be -stored in the cache. However, choosing a chunk size that is too small +stored in the cache. It can also require increasing migration threshold +which defaults to 2048 sectors (1 MiB). Lvm2 ensures migration threshold is +at least 8 chunks in size. This may in some cases result in very +high bandwidth load of transfering data between the cache LV and its +cache origin LV. However, choosing a chunk size that is too small can result in more overhead trying to manage the numerous chunks that become mapped into the cache. Overhead can include both excessive CPU time searching for chunks, and excessive memory tracking chunks. @@ -383,6 +401,35 @@ The default value is shown by: .br .B lvmconfig --type default allocation/cache_pool_chunk_size +Checking migration threshold (in sectors) of running cached LV: +.br +.B lvs -o+kernel_cache_settings VG/LV + + +.SS dm-cache migration threshold + +\& + +Migrating data between the origin and cache LV uses bandwidth. +The user can set a throttle to prevent more than a certain amount of +migration occurring at any one time. Currently dm-cache is not taking any +account of normal io traffic going to the devices. + +User can set migration threshold via cache policy settings as +"migration_threshold=<#sectors>" to set the maximum number +of sectors being migrated, the default being 2048 sectors (1MiB). + +Command to set migration threshold to 2MiB (4096 sectors): +.br +.B lvcreate --cachepolicy 'migration_threshold=4096' VG/LV + + +Command to display the migration threshold: +.br +.B lvs -o+kernel_cache_settings,cache_settings VG/LV +.br +.B lvs -o+chunksize VG/LV + .SS dm-cache cache policy

1 0

master - cov: avoid double call of free_hints() on error path
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=cca2a652d1ac2fa67677e… Commit: cca2a652d1ac2fa67677e3dca50141efa8e2c1a9 Parent: eb06832b37d6d1e3d1c5fba69c5829d76d5d27a5 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Mon Jun 22 11:07:34 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 cov: avoid double call of free_hints() on error path Since we 'free_hints()' on return error path from call of _read_hint_file(), avoid calling it twice in the middle of error path process. --- lib/label/hints.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/lib/label/hints.c b/lib/label/hints.c index 9546f4880..efa02f7c5 100644 --- a/lib/label/hints.c +++ b/lib/label/hints.c @@ -801,10 +801,8 @@ static int _read_hint_file(struct cmd_context *cmd, struct dm_list *hints, int * if (fclose(fp)) stack; - if (!ret) { - free_hints(hints); + if (!ret) return 0; - } if (!found) return 1;

1 0

master - cov: remove unused header
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=eb06832b37d6d1e3d1c5f… Commit: eb06832b37d6d1e3d1c5fba69c5829d76d5d27a5 Parent: dccaab3d79c0439fff26fd4d98e7f55be5a14318 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Tue Jun 16 16:38:15 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 cov: remove unused header --- lib/metadata/integrity_manip.c | 1 - lib/metadata/writecache_manip.c | 1 - 2 files changed, 2 deletions(-) diff --git a/lib/metadata/integrity_manip.c b/lib/metadata/integrity_manip.c index 334452711..b622743f0 100644 --- a/lib/metadata/integrity_manip.c +++ b/lib/metadata/integrity_manip.c @@ -21,7 +21,6 @@ #include "lib/metadata/segtype.h" #include "lib/activate/activate.h" #include "lib/config/defaults.h" -#include "lib/activate/dev_manager.h" #define DEFAULT_TAG_SIZE 4 /* bytes */ #define DEFAULT_MODE 'J' diff --git a/lib/metadata/writecache_manip.c b/lib/metadata/writecache_manip.c index 7ad8c75e7..fade82ef5 100644 --- a/lib/metadata/writecache_manip.c +++ b/lib/metadata/writecache_manip.c @@ -19,7 +19,6 @@ #include "lib/commands/toolcontext.h" #include "lib/display/display.h" #include "lib/metadata/segtype.h" -#include "lib/metadata/lv_alloc.h" #include "lib/activate/activate.h" #include "lib/config/defaults.h" #include "lib/datastruct/str_list.h"

1 0

master - cov: use 64bit arithmetic
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=dccaab3d79c0439fff26f… Commit: dccaab3d79c0439fff26fd4d98e7f55be5a14318 Parent: bc39d5bec6fea787a8d8d16fa484084b7d2a7c29 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Wed Jun 10 23:36:06 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 cov: use 64bit arithmetic Although values of VDO block_map_cache_size, index_memory_size, slab_size should not overflow here - use proper 64bit math. --- lib/report/report.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/report/report.c b/lib/report/report.c index 74ec74cf7..979cbee52 100644 --- a/lib/report/report.c +++ b/lib/report/report.c @@ -3961,7 +3961,7 @@ static int _vdo_ ## vdo_field_name ## _disp (struct dm_report *rh, struct dm_poo if (!seg_is_vdo_pool(seg)) \ return _field_set_value(field, "", &GET_TYPE_RESERVED_VALUE(num_undef_64)); \ \ - size = seg->vdo_params.vdo_field_name ## _mb * (1024 * 1024 >> SECTOR_SHIFT); \ + size = seg->vdo_params.vdo_field_name ## _mb * (UINT64_C(1024) * 1024 >> SECTOR_SHIFT); \ \ return _size64_disp(rh, mem, field, &size, private);\ }

1 0

master - pool: zero metadata
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=bc39d5bec6fea787a8d8d… Commit: bc39d5bec6fea787a8d8d16fa484084b7d2a7c29 Parent: edbc5a62b26806e5c4de59b5292609e955303576 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Wed Jun 24 12:11:21 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 pool: zero metadata To avoid polution of metadata with some 'garbage' content or eventualy some leak of stale data in case user want to upload metadata somewhere, ensure upon allocation the metadata device is fully zeroed. Behaviour may slow down allocation of thin-pool or cache-pool a bit so the old behaviour can be restored with lvm.conf setting: allocation/zero_metadata=0 TODO: add zeroing for extension of metadata volume. --- WHATS_NEW | 1 + lib/config/config_settings.h | 5 ++++- lib/config/defaults.h | 1 + lib/metadata/lv_manip.c | 29 ++++++++++++++++++++++------- lib/metadata/metadata-exported.h | 2 ++ lib/metadata/pool_manip.c | 6 ++++-- 6 files changed, 34 insertions(+), 10 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index b770455fb..2e2e6d919 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ Version 2.03.10 - ================================= + Zero pool metadata on allocation (disable with allocation/zero_metadata=0). Failure in zeroing or wiping will fail command (bypass with -Zn, -Wn). Fix running out of free buffers for async writing for larger writes. Add integrity with raid capability. diff --git a/lib/config/config_settings.h b/lib/config/config_settings.h index 2bb72ba71..531fb139d 100644 --- a/lib/config/config_settings.h +++ b/lib/config/config_settings.h @@ -626,7 +626,7 @@ cfg(allocation_cache_pool_max_chunks_CFG, "cache_pool_max_chunks", allocation_CF "Using cache pool with more chunks may degrade cache performance.\n") cfg(allocation_thin_pool_metadata_require_separate_pvs_CFG, "thin_pool_metadata_require_separate_pvs", allocation_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_THIN_POOL_METADATA_REQUIRE_SEPARATE_PVS, vsn(2, 2, 89), NULL, 0, NULL, - "Thin pool metdata and data will always use different PVs.\n") + "Thin pool metadata and data will always use different PVs.\n") cfg(allocation_thin_pool_zero_CFG, "thin_pool_zero", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_THIN_POOL_ZERO, vsn(2, 2, 99), NULL, 0, NULL, "Thin pool data chunks are zeroed before they are first used.\n" @@ -657,6 +657,9 @@ cfg(allocation_thin_pool_chunk_size_policy_CFG, "thin_pool_chunk_size_policy", a " 512KiB.\n" "#\n") +cfg(allocation_zero_metadata_CFG, "zero_metadata", allocation_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_ZERO_METADATA, vsn(2, 3, 10), NULL, 0, NULL, + "Zero whole metadata area before use with thin or cache pool.\n") + cfg_runtime(allocation_thin_pool_chunk_size_CFG, "thin_pool_chunk_size", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_UNDEFINED, CFG_TYPE_INT, vsn(2, 2, 99), 0, NULL, "The minimal chunk size in KiB for thin pool volumes.\n" "Larger chunk sizes may improve performance for plain thin volumes,\n" diff --git a/lib/config/defaults.h b/lib/config/defaults.h index be4f5ff7f..708a57554 100644 --- a/lib/config/defaults.h +++ b/lib/config/defaults.h @@ -129,6 +129,7 @@ #define DEFAULT_THIN_POOL_DISCARDS "passdown" #define DEFAULT_THIN_POOL_ZERO 1 #define DEFAULT_POOL_METADATA_SPARE 1 /* thin + cache */ +#define DEFAULT_ZERO_METADATA 1 /* thin + cache */ #ifdef CACHE_CHECK_NEEDS_CHECK # define DEFAULT_CACHE_CHECK_OPTION1 "-q" diff --git a/lib/metadata/lv_manip.c b/lib/metadata/lv_manip.c index 8250819da..d96137aff 100644 --- a/lib/metadata/lv_manip.c +++ b/lib/metadata/lv_manip.c @@ -7576,8 +7576,10 @@ int wipe_lv(struct logical_volume *lv, struct wipe_params wp) struct device *dev; char name[PATH_MAX]; uint64_t zero_sectors; + int zero_metadata = wp.is_metadata ? + find_config_tree_bool(lv->vg->cmd, allocation_zero_metadata_CFG, NULL) : 0; - if (!wp.do_zero && !wp.do_wipe_signatures) + if (!wp.do_zero && !wp.do_wipe_signatures && !wp.is_metadata) /* nothing to do */ return 1; @@ -7629,17 +7631,29 @@ int wipe_lv(struct logical_volume *lv, struct wipe_params wp) } } - if (wp.do_zero) { - zero_sectors = wp.zero_sectors ? : UINT64_C(4096) >> SECTOR_SHIFT; - - if (zero_sectors > lv->size) + if (wp.do_zero || wp.is_metadata) { + zero_metadata = !wp.is_metadata ? 0 : + find_config_tree_bool(lv->vg->cmd, allocation_zero_metadata_CFG, NULL); + if (zero_metadata) { + log_debug("Metadata logical volume %s will be fully zeroed.", + display_lvname(lv)); zero_sectors = lv->size; + } else { + if (wp.is_metadata) /* Verbosely notify metadata will not be fully zeroed */ + log_verbose("Metadata logical volume %s not fully zeroed and may contain stale data.", + display_lvname(lv)); + zero_sectors = wp.zero_sectors ? : UINT64_C(4096) >> SECTOR_SHIFT; + + if (zero_sectors > lv->size) + zero_sectors = lv->size; + } log_verbose("Initializing %s of logical volume %s with value %d.", display_size(lv->vg->cmd, zero_sectors), display_lvname(lv), wp.zero_value); - if ((wp.zero_value && !dev_set_bytes(dev, UINT64_C(0), + if ((!wp.is_metadata && + wp.zero_value && !dev_set_bytes(dev, UINT64_C(0), (size_t) zero_sectors << SECTOR_SHIFT, (uint8_t)wp.zero_value)) || !dev_write_zeros(dev, UINT64_C(0), (size_t) zero_sectors << SECTOR_SHIFT)) { @@ -8465,7 +8479,8 @@ static struct logical_volume *_lv_create_an_lv(struct volume_group *vg, .do_zero = lp->zero, .do_wipe_signatures = lp->wipe_signatures, .yes = lp->yes, - .force = lp->force + .force = lp->force, + .is_metadata = lp->is_metadata, })) { log_error("Aborting. Failed to wipe %s.", lp->snapshot ? "snapshot exception store" : "start of new LV"); diff --git a/lib/metadata/metadata-exported.h b/lib/metadata/metadata-exported.h index 0cc5f37a0..06ea757b8 100644 --- a/lib/metadata/metadata-exported.h +++ b/lib/metadata/metadata-exported.h @@ -803,6 +803,7 @@ struct wipe_params { int do_wipe_signatures; /* should we wipe known signatures found on LV? */ int yes; /* answer yes automatically to all questions */ force_t force; /* force mode */ + int is_metadata; /* wipe volume is metadata LV */ }; /* Zero out LV and/or wipe signatures */ @@ -955,6 +956,7 @@ struct lvcreate_params { unsigned suppress_zero_warn : 1; unsigned needs_lockd_init : 1; unsigned ignore_type : 1; + unsigned is_metadata : 1; /* created LV will be used as metadata LV (and can be zeroed) */ const char *vg_name; /* only-used when VG is not yet opened (in /tools) */ const char *lv_name; /* all */ diff --git a/lib/metadata/pool_manip.c b/lib/metadata/pool_manip.c index bed51f12a..23b5b63ba 100644 --- a/lib/metadata/pool_manip.c +++ b/lib/metadata/pool_manip.c @@ -545,8 +545,8 @@ int create_pool(struct logical_volume *pool_lv, display_lvname(pool_lv)); goto bad; } - /* Clear 4KB of pool metadata device. */ - if (!(r = wipe_lv(pool_lv, (struct wipe_params) { .do_zero = 1 }))) { + /* Clear pool metadata device. */ + if (!(r = wipe_lv(pool_lv, (struct wipe_params) { .is_metadata = 1 }))) { log_error("Aborting. Failed to wipe pool metadata %s.", display_lvname(pool_lv)); } @@ -627,6 +627,7 @@ struct logical_volume *alloc_pool_metadata(struct logical_volume *pool_lv, .tags = DM_LIST_HEAD_INIT(lvc.tags), .temporary = 1, .zero = 1, + .is_metadata = 1, }; if (!(lvc.segtype = get_segtype_from_string(pool_lv->vg->cmd, SEG_TYPE_NAME_STRIPED))) @@ -663,6 +664,7 @@ static struct logical_volume *_alloc_pool_metadata_spare(struct volume_group *vg .tags = DM_LIST_HEAD_INIT(lp.tags), .temporary = 1, .zero = 1, + .is_metadata = 1, }; if (!(lp.segtype = get_segtype_from_string(vg->cmd, SEG_TYPE_NAME_STRIPED)))

1 0

master - wipe_lv: make error a fatal event
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=edbc5a62b26806e5c4de5… Commit: edbc5a62b26806e5c4de59b5292609e955303576 Parent: 6eb9eba59bf53101b5148ace3ddaf4140592495f Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Tue Jun 23 13:56:15 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 wipe_lv: make error a fatal event Failure in wiping/zeroing stop the command. If user wants to avoid command abortion he should use -Zn or -Wn to avoid wiping. Note: there is no easy way to distinguish which kind of failure has happend - so it's safe to not proceed any futher. --- WHATS_NEW | 1 + lib/metadata/lv_manip.c | 43 ++++++++++++++++++++++++------------------- 2 files changed, 25 insertions(+), 19 deletions(-) diff --git a/WHATS_NEW b/WHATS_NEW index c6dad99e2..b770455fb 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ Version 2.03.10 - ================================= + Failure in zeroing or wiping will fail command (bypass with -Zn, -Wn). Fix running out of free buffers for async writing for larger writes. Add integrity with raid capability. Fix support for lvconvert --repair used by foreign apps (i.e. Docker). diff --git a/lib/metadata/lv_manip.c b/lib/metadata/lv_manip.c index 1642b90a0..8250819da 100644 --- a/lib/metadata/lv_manip.c +++ b/lib/metadata/lv_manip.c @@ -7582,14 +7582,14 @@ int wipe_lv(struct logical_volume *lv, struct wipe_params wp) return 1; if (!lv_is_active(lv)) { - log_error("Volume \"%s/%s\" is not active locally (volume_list activation filter?).", - lv->vg->name, lv->name); + log_error("Volume %s is not active locally (volume_list activation filter?).", + display_lvname(lv)); return 0; } /* Wait until devices are available */ if (!sync_local_dev_names(lv->vg->cmd)) { - log_error("Failed to sync local devices before wiping LV %s.", + log_error("Failed to sync local devices before wiping volume %s.", display_lvname(lv)); return 0; } @@ -7613,17 +7613,20 @@ int wipe_lv(struct logical_volume *lv, struct wipe_params wp) } if (!label_scan_open_rw(dev)) { - log_error("Failed to open %s/%s for wiping and zeroing.", lv->vg->name, lv->name); - goto out; + log_error("Failed to open %s for wiping and zeroing.", display_lvname(lv)); + return 0; } if (wp.do_wipe_signatures) { - log_verbose("Wiping known signatures on logical volume \"%s/%s\"", - lv->vg->name, lv->name); + log_verbose("Wiping known signatures on logical volume %s.", + display_lvname(lv)); if (!wipe_known_signatures(lv->vg->cmd, dev, name, 0, TYPE_DM_SNAPSHOT_COW, - wp.yes, wp.force, NULL)) - stack; + wp.yes, wp.force, NULL)) { + log_error("Filed to wipe signatures of logical volume %s.", + display_lvname(lv)); + return 0; + } } if (wp.do_zero) { @@ -7632,21 +7635,23 @@ int wipe_lv(struct logical_volume *lv, struct wipe_params wp) if (zero_sectors > lv->size) zero_sectors = lv->size; - log_verbose("Initializing %s of logical volume \"%s/%s\" with value %d.", + log_verbose("Initializing %s of logical volume %s with value %d.", display_size(lv->vg->cmd, zero_sectors), - lv->vg->name, lv->name, wp.zero_value); - - if (!wp.zero_value) { - if (!dev_write_zeros(dev, UINT64_C(0), (size_t) zero_sectors << SECTOR_SHIFT)) - stack; - } else { - if (!dev_set_bytes(dev, UINT64_C(0), (size_t) zero_sectors << SECTOR_SHIFT, (uint8_t)wp.zero_value)) - stack; + display_lvname(lv), wp.zero_value); + + if ((wp.zero_value && !dev_set_bytes(dev, UINT64_C(0), + (size_t) zero_sectors << SECTOR_SHIFT, + (uint8_t)wp.zero_value)) || + !dev_write_zeros(dev, UINT64_C(0), (size_t) zero_sectors << SECTOR_SHIFT)) { + log_error("Failed to initialize %s of logical volume %s with value %d.", + display_size(lv->vg->cmd, zero_sectors), + display_lvname(lv), wp.zero_value); + return 0; } } label_scan_invalidate(dev); -out: + lv->status &= ~LV_NOSCAN; return 1;

1 0

master - bcache: support longer writes
by Zdenek Kabelac 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=6eb9eba59bf53101b5148… Commit: 6eb9eba59bf53101b5148ace3ddaf4140592495f Parent: 04bba5ea421b02275197bfb16b4d1bbf8879b240 Author: Zdenek Kabelac <zkabelac(a)redhat.com> AuthorDate: Wed Jun 24 13:37:23 2020 +0200 Committer: Zdenek Kabelac <zkabelac(a)redhat.com> CommitterDate: Wed Jun 24 15:01:03 2020 +0200 bcache: support longer writes When initiated larger write request, it may have happened, bcache got out of free chunks - fix the loop, that is supposed to wait until next free chunk becomes avain available. --- WHATS_NEW | 1 + lib/device/bcache.c | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/WHATS_NEW b/WHATS_NEW index c0267b7a3..c6dad99e2 100644 --- a/WHATS_NEW +++ b/WHATS_NEW @@ -1,5 +1,6 @@ Version 2.03.10 - ================================= + Fix running out of free buffers for async writing for larger writes. Add integrity with raid capability. Fix support for lvconvert --repair used by foreign apps (i.e. Docker). diff --git a/lib/device/bcache.c b/lib/device/bcache.c index a7d805526..7e7e18542 100644 --- a/lib/device/bcache.c +++ b/lib/device/bcache.c @@ -950,7 +950,7 @@ static struct block *_new_block(struct bcache *cache, int fd, block_address i, b struct block *b; b = _alloc_block(cache); - while (!b && !dm_list_empty(&cache->clean)) { + while (!b) { b = _find_unused_clean_block(cache); if (!b) { if (can_wait) {

1 0

stable-2.02 - lv{resize, extend, reduce}: also check for 2-legged raid4
by Heinz Mauelshagen 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=e7e2288ff4ac34d825dd1… Commit: e7e2288ff4ac34d825dd13dd45b0418723a7da84 Parent: d17780c6b85a0f136e0ed395d5722d82bd8c7464 Author: Heinz Mauelshagen <heinzm(a)redhat.com> AuthorDate: Wed Jun 24 14:02:29 2020 +0200 Committer: Heinz Mauelshagen <heinzm(a)redhat.com> CommitterDate: Wed Jun 24 14:04:36 2020 +0200 lv{resize,extend,reduce}: also check for 2-legged raid4 Users can also convert 2-legged raid1 to raid4 thus causing 'Bus error' on resize requests. Related: https://bugzilla.redhat.com/show_bug.cgi?id=1784351 --- lib/metadata/lv_manip.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/metadata/lv_manip.c b/lib/metadata/lv_manip.c index d35eb5e0a..0b1fdce27 100644 --- a/lib/metadata/lv_manip.c +++ b/lib/metadata/lv_manip.c @@ -4797,7 +4797,7 @@ static int _lvresize_check(struct logical_volume *lv, return 0; } - if (seg && seg_is_any_raid5(seg) && seg->area_count < 3) { + if (seg && (seg_is_raid4(seg) || seg_is_any_raid5(seg)) && seg->area_count < 3) { log_error("Cannot resize %s LV %s. Convert to more stripes first.", lvseg_name(seg), display_lvname(lv)); return 0;

1 0

master - lv{resize,extend,reduce}: also check for 2-legged raid4
by Heinz Mauelshagen 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=04bba5ea421b02275197b… Commit: 04bba5ea421b02275197bfb16b4d1bbf8879b240 Parent: 2cf0f90780bed64cb4062eb6dfa714ed03eecfb7 Author: Heinz Mauelshagen <heinzm(a)redhat.com> AuthorDate: Wed Jun 24 14:02:29 2020 +0200 Committer: Heinz Mauelshagen <heinzm(a)redhat.com> CommitterDate: Wed Jun 24 14:02:31 2020 +0200 lv{resize,extend,reduce}: also check for 2-legged raid4 Users can also convert 2-legged raid1 to raid4 thus causing 'Bus error' on resize requests. Related: https://bugzilla.redhat.com/show_bug.cgi?id=1784351 --- lib/metadata/lv_manip.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/metadata/lv_manip.c b/lib/metadata/lv_manip.c index 142435bbb..1642b90a0 100644 --- a/lib/metadata/lv_manip.c +++ b/lib/metadata/lv_manip.c @@ -5090,7 +5090,7 @@ static int _lvresize_check(struct logical_volume *lv, return 0; } - if (seg && seg_is_any_raid5(seg) && seg->area_count < 3) { + if (seg && (seg_is_raid4(seg) || seg_is_any_raid5(seg)) && seg->area_count < 3) { log_error("Cannot resize %s LV %s. Convert to more stripes first.", lvseg_name(seg), display_lvname(lv)); return 0;

1 0

stable-2.02 - lv{resize, extend, reduce}: reject size change on 2-legged raid5*
by Heinz Mauelshagen 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=d17780c6b85a0f136e0ed… Commit: d17780c6b85a0f136e0ed395d5722d82bd8c7464 Parent: 1fb7a9d9e53cbde38250bb9ece72a25191899b78 Author: Heinz Mauelshagen <heinzm(a)redhat.com> AuthorDate: Wed Jun 24 13:52:53 2020 +0200 Committer: Heinz Mauelshagen <heinzm(a)redhat.com> CommitterDate: Wed Jun 24 13:57:13 2020 +0200 lv{resize,extend,reduce}: reject size change on 2-legged raid5* Reject size changing request in to avoid 'Bus error' and display hint to convert to more stripes. Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1784351 --- lib/metadata/lv_manip.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/lib/metadata/lv_manip.c b/lib/metadata/lv_manip.c index c8acb6ce8..d35eb5e0a 100644 --- a/lib/metadata/lv_manip.c +++ b/lib/metadata/lv_manip.c @@ -4773,6 +4773,7 @@ static int _lvresize_check(struct logical_volume *lv, struct lvresize_params *lp) { struct volume_group *vg = lv->vg; + struct lv_segment *seg = first_seg(lv); if (lv_is_external_origin(lv)) { /* @@ -4796,6 +4797,12 @@ static int _lvresize_check(struct logical_volume *lv, return 0; } + if (seg && seg_is_any_raid5(seg) && seg->area_count < 3) { + log_error("Cannot resize %s LV %s. Convert to more stripes first.", + lvseg_name(seg), display_lvname(lv)); + return 0; + } + if (lv_is_raid(lv) && lp->resize == LV_REDUCE) { unsigned attrs;

1 0

master - lv{resize, extend, reduce}: reject size change on 2-legged raid5*
by Heinz Mauelshagen 24 Jun '20

24 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=2cf0f90780bed64cb4062… Commit: 2cf0f90780bed64cb4062eb6dfa714ed03eecfb7 Parent: 3bd9d81b29fb8ba490d87b3557861bf00047855d Author: Heinz Mauelshagen <heinzm(a)redhat.com> AuthorDate: Wed Jun 24 13:52:53 2020 +0200 Committer: Heinz Mauelshagen <heinzm(a)redhat.com> CommitterDate: Wed Jun 24 13:52:56 2020 +0200 lv{resize,extend,reduce}: reject size change on 2-legged raid5* Reject size changing request in to avoid 'Bus error' and display hint to convert to more stripes. Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1784351 --- lib/metadata/lv_manip.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/lib/metadata/lv_manip.c b/lib/metadata/lv_manip.c index c1c86aa4c..142435bbb 100644 --- a/lib/metadata/lv_manip.c +++ b/lib/metadata/lv_manip.c @@ -5066,6 +5066,7 @@ static int _lvresize_check(struct logical_volume *lv, struct lvresize_params *lp) { struct volume_group *vg = lv->vg; + struct lv_segment *seg = first_seg(lv); if (lv_is_external_origin(lv)) { /* @@ -5089,6 +5090,12 @@ static int _lvresize_check(struct logical_volume *lv, return 0; } + if (seg && seg_is_any_raid5(seg) && seg->area_count < 3) { + log_error("Cannot resize %s LV %s. Convert to more stripes first.", + lvseg_name(seg), display_lvname(lv)); + return 0; + } + if (lv_is_raid(lv) && lp->resize == LV_REDUCE) { unsigned attrs;

1 0

stable-2.02 - scanning: optimize by checking text offset and checksum
by David Teigland 23 Jun '20

23 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=1fb7a9d9e53cbde38250b… Commit: 1fb7a9d9e53cbde38250bb9ece72a25191899b78 Parent: 7ea50a47d15dea016f252a5940c6aa5c0d598bb6 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Mon Jun 1 16:22:09 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Jun 23 11:32:32 2020 -0500 scanning: optimize by checking text offset and checksum stable backport of 0c1316cda876849d5d1375d40e8cdc08db37c2b5 which includes a number of extra supporting functions. In stable, the optimization is only applied to reporting and display commands, so this change applies only to those cases. After the VG lock is taken for vg_read, reread the mda_header from disk and compare the metadata text offset and checksum to what was seen during label scan. If it is unchanged, then the metadata has not changed since the label scan, and the metadata does not need to be reread under the lock for command processing. If it is changed, then reread the metadata from disk. This fixes a problem with the original optimization where lvm reuses cached data from the label_scan phase for vg_read. This works if the mda_header and metadata text are both read from cache, or both read from disk, but in some cases the mda_header could have been dropped from the cache and read from disk, while the metadata blocks remained in the cache and were not read from disk. If in addition to this, another concurrent command happened to update the metadata between the label_scan and vg_read, then the new mda_header from disk would refer to cached blocks that did not contain the new metadata text. This would cause the lvm command report an error about invalid metadata. --- lib/cache/lvmcache.c | 24 +++++++++ lib/cache/lvmcache.h | 4 ++ lib/device/bcache-utils.c | 15 ++++++ lib/device/bcache.h | 1 + lib/format_text/format-text.c | 16 +++++- lib/format_text/layout.h | 2 +- lib/format_text/text_label.c | 2 +- lib/label/label.c | 5 ++ lib/label/label.h | 1 + lib/metadata/metadata.c | 117 +++++++++++++++++++++++++++++++++++++++++- lib/metadata/metadata.h | 4 +- 11 files changed, 186 insertions(+), 5 deletions(-) diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c index c12ec2b0c..ed605dc0f 100644 --- a/lib/cache/lvmcache.c +++ b/lib/cache/lvmcache.c @@ -3064,3 +3064,27 @@ uint64_t lvmcache_max_metadata_size(void) return _max_metadata_size; } +void lvmcache_get_mdas(struct cmd_context *cmd, + const char *vgname, const char *vgid, + struct dm_list *mda_list) +{ + struct lvmcache_vginfo *vginfo; + struct lvmcache_info *info; + struct mda_list *mdal; + struct metadata_area *mda, *mda2; + + if (!(vginfo = lvmcache_vginfo_from_vgname(vgname, vgid))) { + log_error(INTERNAL_ERROR "lvmcache_get_mdas no vginfo %s", vgname); + return; + } + + dm_list_iterate_items(info, &vginfo->infos) { + dm_list_iterate_items_safe(mda, mda2, &info->mdas) { + if (!(mdal = dm_zalloc(sizeof(*mdal)))) + continue; + mdal->mda = mda; + dm_list_add(mda_list, &mdal->list); + } + } +} + diff --git a/lib/cache/lvmcache.h b/lib/cache/lvmcache.h index f43678507..541e8bee5 100644 --- a/lib/cache/lvmcache.h +++ b/lib/cache/lvmcache.h @@ -228,4 +228,8 @@ void lvmcache_drop_saved_vgid(const char *vgid); uint64_t lvmcache_max_metadata_size(void); void lvmcache_save_metadata_size(uint64_t val); +void lvmcache_get_mdas(struct cmd_context *cmd, + const char *vgname, const char *vgid, + struct dm_list *mda_list); + #endif diff --git a/lib/device/bcache-utils.c b/lib/device/bcache-utils.c index a533a66ee..2f0b01d13 100644 --- a/lib/device/bcache-utils.c +++ b/lib/device/bcache-utils.c @@ -79,6 +79,21 @@ bool bcache_read_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, return true; } +bool bcache_invalidate_bytes(struct bcache *cache, int fd, uint64_t start, size_t len) +{ + block_address bb, be; + bool result = true; + + byte_range_to_block_range(cache, start, len, &bb, &be); + + for (; bb != be; bb++) { + if (!bcache_invalidate(cache, fd, bb)) + result = false; + } + + return result; +} + //---------------------------------------------------------------- // Writing bytes and zeroing bytes are very similar, so we factor out diff --git a/lib/device/bcache.h b/lib/device/bcache.h index c5e6da1ad..e22755ed5 100644 --- a/lib/device/bcache.h +++ b/lib/device/bcache.h @@ -163,6 +163,7 @@ bool bcache_read_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, void *data); bool bcache_zero_bytes(struct bcache *cache, int fd, uint64_t start, size_t len); bool bcache_set_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, uint8_t val); +bool bcache_invalidate_bytes(struct bcache *cache, int fd, uint64_t start, size_t len); void bcache_set_last_byte(struct bcache *cache, int fd, uint64_t offset, int sector_size); void bcache_unset_last_byte(struct bcache *cache, int fd); diff --git a/lib/format_text/format-text.c b/lib/format_text/format-text.c index 026f93a13..225d6424c 100644 --- a/lib/format_text/format-text.c +++ b/lib/format_text/format-text.c @@ -1199,6 +1199,7 @@ static int _scan_file(const struct format_type *fmt, const char *vgname) } int read_metadata_location_summary(const struct format_type *fmt, + struct metadata_area *mda, struct mda_header *mdah, int primary_mda, struct device_area *dev_area, struct lvmcache_vgsummary *vgsummary, uint64_t *mda_free_sectors) { @@ -1251,6 +1252,19 @@ int read_metadata_location_summary(const struct format_type *fmt, return 0; } + /* + * This function is used to read the vg summary during label scan. + * Save the text start location and checksum during scan. After the VG + * lock is acquired in vg_read, we can reread the mda_header, and + * compare rlocn->offset,checksum to what was saved during scan. If + * unchanged, it means that the metadata was not changed between scan + * and the read. + */ + if (mda) { + mda->scan_text_offset = rlocn->offset; + mda->scan_text_checksum = rlocn->checksum; + } + /* We found a VG - now check the metadata */ if (rlocn->offset + rlocn->size > mdah->size) wrap = (uint32_t) ((rlocn->offset + rlocn->size) - mdah->size); @@ -1374,7 +1388,7 @@ static int _scan_raw(const struct format_type *fmt, const char *vgname __attribu continue; } - if (read_metadata_location_summary(fmt, mdah, 0, &rl->dev_area, &vgsummary, NULL)) { + if (read_metadata_location_summary(fmt, NULL, mdah, 0, &rl->dev_area, &vgsummary, NULL)) { vg = _vg_read_raw_area(&fid, vgsummary.vgname, &rl->dev_area, NULL, NULL, 0, 0); if (vg) { lvmcache_update_vg(vg, 0); diff --git a/lib/format_text/layout.h b/lib/format_text/layout.h index 2671bbf02..460195276 100644 --- a/lib/format_text/layout.h +++ b/lib/format_text/layout.h @@ -104,7 +104,7 @@ struct mda_context { #define MDA_SIZE_MIN (8 * (unsigned) lvm_getpagesize()) #define MDA_ORIGINAL_ALIGNMENT 512 /* Original alignment used for start of VG metadata content */ -int read_metadata_location_summary(const struct format_type *fmt, struct mda_header *mdah, int primary_mda, +int read_metadata_location_summary(const struct format_type *fmt, struct metadata_area *mda, struct mda_header *mdah, int primary_mda, struct device_area *dev_area, struct lvmcache_vgsummary *vgsummary, uint64_t *mda_free_sectors); diff --git a/lib/format_text/text_label.c b/lib/format_text/text_label.c index 7d10e065b..fc8294e3f 100644 --- a/lib/format_text/text_label.c +++ b/lib/format_text/text_label.c @@ -345,7 +345,7 @@ static int _read_mda_header_and_metadata(struct metadata_area *mda, void *baton) return 1; } - if (!read_metadata_location_summary(fmt, mdah, mda_is_primary(mda), &mdac->area, + if (!read_metadata_location_summary(fmt, mda, mdah, mda_is_primary(mda), &mdac->area, &vgsummary, &mdac->free_sectors)) { if (vgsummary.zero_offset) return 1; diff --git a/lib/label/label.c b/lib/label/label.c index 70b793441..8a4b66246 100644 --- a/lib/label/label.c +++ b/lib/label/label.c @@ -1418,6 +1418,11 @@ bool dev_write_bytes(struct device *dev, uint64_t start, size_t len, void *data) return true; } +bool dev_invalidate_bytes(struct device *dev, uint64_t start, size_t len) +{ + return bcache_invalidate_bytes(scan_bcache, dev->bcache_fd, start, len); +} + bool dev_write_zeros(struct device *dev, uint64_t start, size_t len) { if (test_mode()) diff --git a/lib/label/label.h b/lib/label/label.h index 42c9946cb..ea29c84ee 100644 --- a/lib/label/label.h +++ b/lib/label/label.h @@ -128,6 +128,7 @@ bool dev_read_bytes(struct device *dev, uint64_t start, size_t len, void *data); bool dev_write_bytes(struct device *dev, uint64_t start, size_t len, void *data); bool dev_write_zeros(struct device *dev, uint64_t start, size_t len); bool dev_set_bytes(struct device *dev, uint64_t start, size_t len, uint8_t val); +bool dev_invalidate_bytes(struct device *dev, uint64_t start, size_t len); void dev_set_last_byte(struct device *dev, uint64_t offset); void dev_unset_last_byte(struct device *dev); diff --git a/lib/metadata/metadata.c b/lib/metadata/metadata.c index 666ad7823..0bdbda69b 100644 --- a/lib/metadata/metadata.c +++ b/lib/metadata/metadata.c @@ -33,6 +33,8 @@ #include "lvmlockd.h" #include "time.h" #include "lvmnotify.h" +#include "format_text/format-text.h" +#include "format_text/layout.h" #include <math.h> #include <sys/param.h> @@ -3758,6 +3760,118 @@ out: return r; } +/* + * Reread an mda_header. If the text offset is the same as was seen and saved + * by label scan, it means the metadata is unchanged and we do not need to + * reread metadata. + * + * This is used to ensure that the metadata seen during scan still matches + * what's on disk. If the scan data still matches what's on disk we don't + * need to reread the metadata from disk. When we read the metadata from + * bcache it may come from the cache or from disk again if the cache has + * dropped it. + */ + +static bool _scan_text_mismatch(struct cmd_context *cmd, const char *vgname, const char *vgid) +{ + struct dm_list mda_list; + struct mda_list *mdal, *safe; + struct metadata_area *mda; + struct mda_context *mdac; + struct device_area *area; + struct mda_header *mdah; + struct raw_locn *rlocn; + struct device *dev; + bool ret = true; + + /* + * if cmd->can_use_one_scan, check one mda_header is unchanged, + * else check that all mda_headers are unchanged. + */ + + dm_list_init(&mda_list); + + lvmcache_get_mdas(cmd, vgname, vgid, &mda_list); + + dm_list_iterate_items(mdal, &mda_list) { + mda = mdal->mda; + + if (!mda->scan_text_offset) + continue; + + if (!mda_is_primary(mda)) + continue; + + if (!(dev = mda_get_device(mda))) { + log_debug("rescan for text mismatch - no mda dev"); + goto out; + } + + mdac = mda->metadata_locn; + area = &mdac->area; + + /* + * Invalidate mda_header in bcache so it will be reread from disk. + */ + if (!dev_invalidate_bytes(dev, 4096, 512)) { + log_debug("rescan for text mismatch - cannot invalidate"); + goto out; + } + + if (!(mdah = raw_read_mda_header(cmd->fmt, area, 1))) { + log_debug("rescan for text mismatch - no mda header"); + goto out; + } + + rlocn = mdah->raw_locns; + + if (rlocn->checksum != mda->scan_text_checksum) { + log_debug("rescan for text checksum mismatch on %s - now %x prev %x offset now %llu prev %llu", + dev_name(dev), + rlocn->checksum, mda->scan_text_checksum, + (unsigned long long)rlocn->offset, + (unsigned long long)mda->scan_text_offset); + } else if (rlocn->offset != mda->scan_text_offset) { + log_debug("rescan for text offset mismatch on %s - now %llu prev %llu checksum %x", + dev_name(dev), + (unsigned long long)rlocn->offset, + (unsigned long long)mda->scan_text_offset, + rlocn->checksum); + } else { + /* the common case where fields match and no rescan needed */ + ret = false; + } + + dm_pool_free(cmd->mem, mdah); + + /* For can_use_one_scan commands, return result from checking one mda. */ + if (cmd->can_use_one_scan) + goto out; + + /* For other commands, return mismatch immediately. */ + if (ret) + goto_out; + } + + if (ret) { + /* shouldn't happen */ + log_debug("rescan for text mismatch - no mdas"); + goto out; + } +out: + if (!ret) + log_debug("rescan skipped - unchanged offset %llu checksum %x", + (unsigned long long)mda->scan_text_offset, + mda->scan_text_checksum); + + dm_list_iterate_items_safe(mdal, safe, &mda_list) { + dm_list_del(&mdal->list); + free(mdal); + } + + return ret; +} + /* Caller sets consistent to 1 if it's safe for vg_read_internal to correct * inconsistent metadata on disk (i.e. the VG write lock is held). * This guarantees only consistent metadata is returned. @@ -3902,7 +4016,8 @@ static struct volume_group *_vg_read(struct cmd_context *cmd, * lock is taken prior to the label scan, and still held here, * we can also skip the rescan in that case. */ - if (!cmd->can_use_one_scan || lvmcache_scan_mismatch(cmd, vgname, vgid)) { + if (!cmd->can_use_one_scan || + lvmcache_scan_mismatch(cmd, vgname, vgid) || _scan_text_mismatch(cmd, vgname, vgid)) { /* the skip rescan special case is for clvmd vg_read_by_vgid */ /* FIXME: this is not a warn flag, pass this differently */ if (warn_flags & SKIP_RESCAN) diff --git a/lib/metadata/metadata.h b/lib/metadata/metadata.h index f8083e5a8..96bbb5690 100644 --- a/lib/metadata/metadata.h +++ b/lib/metadata/metadata.h @@ -173,6 +173,8 @@ struct metadata_area { struct metadata_area_ops *ops; void *metadata_locn; uint32_t status; + uint64_t scan_text_offset; /* rlocn->offset seen during scan */ + uint32_t scan_text_checksum; /* rlocn->checksum seen during scan */ }; struct metadata_area *mda_copy(struct dm_pool *mem, struct metadata_area *mda); @@ -234,7 +236,7 @@ struct name_list { struct mda_list { struct dm_list list; - struct device_area mda; + struct metadata_area *mda; }; struct peg_list {

1 0

master - man: lvmcache info about cachedevice usage
by David Teigland 22 Jun '20

22 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=3bd9d81b29fb8ba490d87… Commit: 3bd9d81b29fb8ba490d87b3557861bf00047855d Parent: ae5634a8be3eedb556325a4b81540896fa6cac16 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jun 11 17:01:01 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Mon Jun 22 11:24:02 2020 -0500 man: lvmcache info about cachedevice usage --- man/lvmcache.7_main | 30 ++++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/man/lvmcache.7_main b/man/lvmcache.7_main index 425904e4a..244ea1e48 100644 --- a/man/lvmcache.7_main +++ b/man/lvmcache.7_main @@ -34,8 +34,6 @@ LVM refers to this using the LV type \fBwritecache\fP. .SH USAGE -Both kinds of caching use similar lvm commands: - .B 1. Identify main LV that needs caching The main LV may already exist, and is located on larger, slower devices. @@ -133,6 +131,22 @@ attached. main vg -wi------- linear /dev/slow_hhd .fi +.SS Create a new LV with caching. + +A new LV can be created with caching attached at the time of creation +using the following command: + +.nf +$ lvcreate --type cache|writecache -n Name -L Size + --cachedevice /dev/fast_ssd vg /dev/slow_hhd +.fi + +The main LV is created with the specified Name and Size from the slow_hhd. +A hidden fast LV is created on the fast_ssd and is then attached to the +new main LV. If the fast_ssd is unused, the entire disk will be used as +the cache unless the --cachesize option is used to specify a size for the +fast LV. The --cachedevice option can be repeated to use multiple disks +for the fast LV. .SH OPTIONS @@ -162,6 +176,18 @@ that cannot be used directly. If a standard LV is passed with this option, lvm will first convert it to a cache pool by combining it with another LV to use for metadata. This option can be used with dm-cache. +.B --cachedevice +.I PV +.br + +This option can be used in place of --cachevol, in which case a cachevol +LV will be created using the specified device. This option can be +repeated to create a cachevol using multiple devices, or a tag name can be +specified in which case the cachevol will be created using any of the +devices with the given tag. If a named cache device is unused, the entire +device will be used to create the cachevol. To create a cachevol of a +specific size from the cache devices, include the --cachesize option. + \& .SS dm-cache block size

1 0

master - tests: cachevol-cachedevice
by David Teigland 22 Jun '20

22 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=ae5634a8be3eedb556325… Commit: ae5634a8be3eedb556325a4b81540896fa6cac16 Parent: 2aed2a41f7602e9168613a0c37d8dd557e7dba9b Author: David Teigland <teigland(a)redhat.com> AuthorDate: Fri Apr 10 16:59:16 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Mon Jun 22 11:23:58 2020 -0500 tests: cachevol-cachedevice --- test/shell/cachevol-cachedevice.sh | 212 +++++++++++++++++++++++++++++++++++++ 1 file changed, 212 insertions(+) diff --git a/test/shell/cachevol-cachedevice.sh b/test/shell/cachevol-cachedevice.sh new file mode 100644 index 000000000..11a37d9cd --- /dev/null +++ b/test/shell/cachevol-cachedevice.sh @@ -0,0 +1,212 @@ +#!/usr/bin/env bash + +# Copyright (C) 2018 Red Hat, Inc. All rights reserved. +# +# This copyrighted material is made available to anyone wishing to use, +# modify, copy, or redistribute it subject to the terms and conditions +# of the GNU General Public License v.2. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +SKIP_WITH_LVMPOLLD=1 + +. lib/inittest + +aux have_cache 1 10 0 || skip +aux have_writecache 1 0 0 || skip + +aux prepare_devs 4 64 + +vgcreate $SHARED $vg "$dev1" "$dev2" + +## cache + +# use existing cachevol +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvcreate --type cache -n $lv2 -L40M --cachevol $lv1 -y $vg "$dev2" +check lv_field $vg/$lv2 segtype cache +check lv_field $vg/${lv1}_cvol segtype linear -a +lvremove -y $vg/$lv2 + +# use entire cachedevice for cachevol +lvcreate --type cache -n $lv2 -L40M --cachedevice "$dev1" -y $vg "$dev2" +check lv_field $vg/$lv2 segtype cache +check lv_field $vg/${lv2}_cache_cvol segtype linear -a +lvremove -y $vg/$lv2 + +# use part of cachedevice for cachevol +lvcreate --type cache -n $lv2 -L20M --cachedevice "$dev1" --cachesize 16M -y $vg "$dev2" +check lv_field $vg/$lv2 segtype cache +check lv_field $vg/${lv2}_cache_cvol segtype linear -a +lvcreate --type cache -n $lv3 -L20M --cachedevice "$dev1" --cachesize 16M -y $vg "$dev2" +check lv_field $vg/$lv3 segtype cache +check lv_field $vg/${lv3}_cache_cvol segtype linear -a +lvremove -y $vg/$lv2 +lvremove -y $vg/$lv3 + +## writecache + +# use existing cachevol +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvcreate --type writecache -n $lv2 -L40M --cachevol $lv1 -y $vg "$dev2" +check lv_field $vg/$lv2 segtype writecache +check lv_field $vg/${lv1}_cvol segtype linear -a +lvremove -y $vg/$lv2 + +# use entire cachedevice for cachevol +lvcreate --type writecache -n $lv2 -L40M --cachedevice "$dev1" -y $vg "$dev2" +check lv_field $vg/$lv2 segtype writecache +check lv_field $vg/${lv2}_cache_cvol segtype linear -a +lvremove -y $vg/$lv2 + +# use part of cachedevice for cachevol +lvcreate --type writecache -n $lv2 -L20M --cachedevice "$dev1" --cachesize 16M -y $vg "$dev2" +check lv_field $vg/$lv2 segtype writecache +check lv_field $vg/${lv2}_cache_cvol segtype linear -a +lvcreate --type writecache -n $lv3 -L20M --cachedevice "$dev1" --cachesize 16M -y $vg "$dev2" +check lv_field $vg/$lv3 segtype writecache +check lv_field $vg/${lv3}_cache_cvol segtype linear -a +lvremove -y $vg/$lv2 +lvremove -y $vg/$lv3 + +## multiple cachedevs + +vgextend $vg "$dev3" "$dev4" + +lvcreate --type writecache -n $lv2 -L100M --cachedevice "$dev1" --cachedevice "$dev3" -y $vg "$dev2" "$dev4" +check lv_field $vg/${lv2}_cache_cvol lv_size "120.00m" +lvremove -y $vg/$lv2 + +lvcreate --type writecache -n $lv2 -L100M --cachedevice "$dev1" --cachedevice "$dev3" --cachesize 80M -y $vg "$dev2" "$dev4" +check lv_field $vg/${lv2}_cache_cvol lv_size "80.00m" +lvremove -y $vg/$lv2 + +pvchange --addtag slow "$dev2" +pvchange --addtag slow "$dev4" +pvchange --addtag fast "$dev1" +pvchange --addtag fast "$dev3" + +lvcreate --type writecache -n $lv2 -L100M --cachedevice @fast --cachesize 80M -y $vg @slow +check lv_field $vg/${lv2}_cache_cvol lv_size "80.00m" +lvremove -y $vg/$lv2 + +lvcreate --type cache -n $lv2 -L100M --cachedevice @fast --cachesize 80M -y $vg @slow +check lv_field $vg/${lv2}_cache_cvol lv_size "80.00m" +lvremove -y $vg/$lv2 + +## error cases + +# cachevol doesn't exist +not lvcreate --type cache -n $lv2 -l8 --cachevol asdf -y $vg "$dev2" +not lvs $vg/$lv1 +not lvs $vg/$lv2 + +# cachedevice doesn't exist +not lvcreate --type cache -n $lv2 -l8 --cachedevice asdf -y $vg "$dev2" +not lvs $vg/$lv1 +not lvs $vg/$lv2 + +# cachevol doesn't exist +not lvcreate --type writecache -n $lv2 -l8 --cachevol asdf -y $vg "$dev2" +not lvs $vg/$lv1 +not lvs $vg/$lv2 + +# cachedevice doesn't exist +not lvcreate --type writecache -n $lv2 -l8 --cachedevice asdf -y $vg "$dev2" +not lvs $vg/$lv1 +not lvs $vg/$lv2 + +# when cachedevice is already being used, cachesize is required to use a part of it +lvcreate -n asdf -l1 $vg "$dev1" +not lvcreate --type writecache -n $lv2 -l8 --cachedevice "$dev1" -y $vg "$dev2" +not lvcreate --type writecache -n $lv2 -l8 --cachedevice "$dev1" --cachedevice "$dev3" -y $vg "$dev2" +not lvs $vg/$lv1 +not lvs $vg/$lv2 +lvcreate --type writecache -n $lv2 -l8 --cachedevice "$dev1" --cachesize 8M -y $vg "$dev2" +lvs $vg/$lv2 +check lv_field $vg/${lv2}_cache_cvol lv_size "8.00m" +lvremove -y $vg/$lv2 + +vgremove -ff $vg + +# lvconvert single step cachevol creation and attachment +# . cache and writecache +# . one or two cachedevices +# . with or without --cachesize +# . using tags for devices + +vgcreate $SHARED $vg "$dev1" "$dev2" "$dev3" "$dev4" + +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvconvert -y --type cache --cachedevice "$dev2" $vg/$lv1 +check lv_field $vg/$lv1 segtype cache +check lv_field $vg/${lv1}_cache_cvol segtype linear -a +check lv_field $vg/${lv1}_cache_cvol lv_size "60.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvconvert -y --type cache --cachedevice "$dev2" --cachedevice "$dev3" $vg/$lv1 +check lv_field $vg/$lv1 segtype cache +check lv_field $vg/${lv1}_cache_cvol lv_size "120.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvconvert -y --type cache --cachedevice "$dev2" --cachedevice "$dev3" --cachesize 8M $vg/$lv1 +check lv_field $vg/$lv1 segtype cache +check lv_field $vg/${lv1}_cache_cvol lv_size "8.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvconvert -y --type writecache --cachedevice "$dev2" $vg/$lv1 +check lv_field $vg/$lv1 segtype writecache +check lv_field $vg/${lv1}_cache_cvol lv_size "60.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvconvert -y --type writecache --cachedevice "$dev2" --cachedevice "$dev3" $vg/$lv1 +check lv_field $vg/$lv1 segtype writecache +check lv_field $vg/${lv1}_cache_cvol lv_size "120.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +lvcreate -n $lv1 -l8 -an $vg "$dev1" +lvconvert -y --type writecache --cachedevice "$dev2" --cachedevice "$dev3" --cachesize 8M $vg/$lv1 +check lv_field $vg/$lv1 segtype writecache +check lv_field $vg/${lv1}_cache_cvol lv_size "8.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +pvchange --addtag slow "$dev1" +pvchange --addtag fast "$dev2" +pvchange --addtag fast "$dev3" + +lvcreate -n $lv1 -l8 -an $vg @slow +lvconvert -y --type cache --cachedevice @fast --cachesize 8M $vg/$lv1 +check lv_field $vg/$lv1 segtype cache +check lv_field $vg/${lv1}_cache_cvol lv_size "8.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +lvcreate -n $lv1 -l8 -an $vg @slow +lvconvert -y --type writecache --cachedevice @fast --cachesize 8M $vg/$lv1 +check lv_field $vg/$lv1 segtype writecache +check lv_field $vg/${lv1}_cache_cvol lv_size "8.00m" +lvchange -ay $vg/$lv1 +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +vgremove -ff $vg +

1 0

master - lvcreate: new cache or writecache lv with single command
by David Teigland 22 Jun '20

22 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=2aed2a41f7602e9168613… Commit: 2aed2a41f7602e9168613a0c37d8dd557e7dba9b Parent: 21b37964eb88d404998e37acae5530ec102a2116 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Fri Apr 10 13:17:37 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Jun 16 13:46:51 2020 -0500 lvcreate: new cache or writecache lv with single command To create a new cache or writecache LV with a single command: lvcreate --type cache|writecache -n Name -L Size --cachedevice PVfast VG [PVslow ...] - A new main linear|striped LV is created as usual, using the specified -n Name and -L Size, and using the optionally specified PVslow devices. - Then, a new cachevol LV is created internally, using PVfast specified by the cachedevice option. - Then, the cachevol is attached to the main LV, converting the main LV to type cache|writecache. Include --cachesize Size to specify the size of cache|writecache to create from the specified --cachedevice PVs, otherwise the entire cachedevice PV is used. The --cachedevice option can be repeated to create the cache from multiple devices, or the cachedevice option can contain a tag name specifying a set of PVs to allocate the cache from. To create a new cache or writecache LV with a single command using an existing cachevol LV: lvcreate --type cache|writecache -n Name -L Size --cachevol LVfast VG [PVslow ...] - A new main linear|striped LV is created as usual, using the specified -n Name and -L Size, and using the optionally specified PVslow devices. - Then, the cachevol LVfast is attached to the main LV, converting the main LV to type cache|writecache. In cases where more advanced types (for the main LV or cachevol LV) are needed, they should be created independently and then combined with lvconvert. Example ------- user creates a new VG with one slow device and one fast device: $ vgcreate vg /dev/slow1 /dev/fast1 user creates a new 8G main LV on /dev/slow1 that uses all of /dev/fast1 as a writecache: $ lvcreate --type writecache --cachedevice /dev/fast1 -n main -L 8G vg /dev/slow1 Example ------- user creates a new VG with two slow devs and two fast devs: $ vgcreate vg /dev/slow1 /dev/slow2 /dev/fast1 /dev/fast2 user creates a new 8G main LV on /dev/slow1 and /dev/slow2 that uses all of /dev/fast1 and /dev/fast2 as a writecache: $ lvcreate --type writecache --cachedevice /dev/fast1 --cachedevice /dev/fast2 -n main -L 8G vg /dev/slow1 /dev/slow2 Example ------- A user has several slow devices and several fast devices in their VG, the slow devs have tag @slow, the fast devs have tag @fast. user creates a new 8G main LV on the slow devs with a 2G writecache on the fast devs: $ lvcreate --type writecache -n main -L 8G --cachedevice @fast --cachesize 2G vg @slow --- lib/metadata/metadata-exported.h | 1 + tools/args.h | 2 +- tools/command-lines.in | 126 ++++++++++++++++------------- tools/command.c | 3 + tools/lvconvert.c | 166 ++++++++++++++++++++++----------------- tools/lvcreate.c | 153 +++++++++++++++++++++++++++++++++++- tools/lvmcmdline.c | 6 ++ tools/tools.h | 11 +++ 8 files changed, 341 insertions(+), 127 deletions(-) diff --git a/lib/metadata/metadata-exported.h b/lib/metadata/metadata-exported.h index 0d6be136b..0cc5f37a0 100644 --- a/lib/metadata/metadata-exported.h +++ b/lib/metadata/metadata-exported.h @@ -954,6 +954,7 @@ struct lvcreate_params { int thin_chunk_size_calc_policy; unsigned suppress_zero_warn : 1; unsigned needs_lockd_init : 1; + unsigned ignore_type : 1; const char *vg_name; /* only-used when VG is not yet opened (in /tools) */ const char *lv_name; /* all */ diff --git a/tools/args.h b/tools/args.h index c69a0ecce..3a7e5d488 100644 --- a/tools/args.h +++ b/tools/args.h @@ -126,7 +126,7 @@ arg(cachepool_ARG, '\0', "cachepool", lv_VAL, 0, 0, arg(cachevol_ARG, '\0', "cachevol", lv_VAL, 0, 0, "The name of a cache volume.\n") -arg(cachedevice_ARG, '\0', "cachedevice", pv_VAL, 0, 0, +arg(cachedevice_ARG, '\0', "cachedevice", pv_VAL, ARG_GROUPABLE, 0, "The name of a device to use for a cache.\n") arg(cachesize_ARG, '\0', "cachesize", sizemb_VAL, 0, 0, diff --git a/tools/command-lines.in b/tools/command-lines.in index 8d389b665..0051b77b5 100644 --- a/tools/command-lines.in +++ b/tools/command-lines.in @@ -1219,87 +1219,107 @@ lvcreate --type cache --size SizeMB --cachepool LV_cachepool VG OO: --cache, OO_LVCREATE_POOL, OO_LVCREATE_CACHE, OO_LVCREATE, --stripes Number, --stripesize SizeKB OP: PV ... -ID: lvcreate_cache_vol_with_new_origin -DESC: Create a cache LV, first creating a new origin LV, -DESC: then combining it with the existing cache pool named -DESC: by the --cachepool arg. +ID: lvcreate_and_attach_cachepool +DESC: Create a new LV, then attach the specified cachepool +DESC: which converts the new LV to type cache. # alternate form of lvcreate --type cache +# (omits the --type cache option which is inferred) lvcreate --size SizeMB --cachepool LV_cachepool VG OO: --type cache, --cache, OO_LVCREATE_CACHE, OO_LVCREATE, --stripes Number, --stripesize SizeKB OP: PV ... -ID: lvcreate_cache_vol_with_new_origin -DESC: Create a cache LV, first creating a new origin LV, -DESC: then combining it with the existing cache pool named -DESC: by the --cachepool arg (variant, infers --type cache). +ID: lvcreate_and_attach_cachepool_v2 +DESC: Create a new LV, then attach the specified cachepool +DESC: which converts the new LV to type cache +DESC: (variant, infers --type cache.) FLAGS: SECONDARY_SYNTAX # alternate form of lvcreate --type cache +# (moves cachepool from option arg to position arg, +# dropping the normal VG position arg) lvcreate --type cache --size SizeMB LV_cachepool OO: --cache, OO_LVCREATE_POOL, OO_LVCREATE_CACHE, OO_LVCREATE, --stripes Number, --stripesize SizeKB OP: PV ... -ID: lvcreate_cache_vol_with_new_origin -DESC: Create a cache LV, first creating a new origin LV, -DESC: then combining it with the existing cache pool named -DESC: in the first arg (variant, also use --cachepool). +ID: lvcreate_and_attach_cachepool_v3 +DESC: Create a new LV, then attach the specified cachepool +DESC: which converts the new LV to type cache. +DESC: (variant, also use --cachepool). FLAGS: SECONDARY_SYNTAX -# This is a ridiculously crazy command which nobody could -# understand. It should be be eliminated. It does two different -# things depending on whether LV in pos 1 is a cachepool LV -# or not. Both variations are unnecessary. -# -# 1. If LV is a cachepool, then it's an alternate form of -# an already complicated command above. -# -# # alternate form for lvcreate_cache_vol_with_new_origin -# lvcreate --cache --size SizeMB LV_cachepool -# OO: --type cache, --cache, OO_LVCREATE_CACHE, OO_LVCREATE, --stripes Number, --stripesize SizeKB -# OP: PV ... -# ID: lvcreate_cache_vol_with_new_origin -# DESC: Create a cache LV, first creating a new origin LV, -# DESC: then combining it with the existing cache pool named -# DESC: in the first arg (variant, infers --type cache, -# DESC: also use --cachepool). -# -# 2. If LV is not a cachepool, then it's a disguised lvconvert. -# -# # FIXME: this should be done by lvconvert, and this command removed -# lvcreate --type cache --size SizeMB LV -# OO: OO_LVCREATE_POOL, OO_LVCREATE_CACHE, OO_LVCREATE -# OP: PV ... -# ID: lvcreate_convert_to_cache_vol_with_cachepool -# DESC: Convert the specified LV to type cache after creating a new -# DESC: cache pool LV to use (use lvconvert). +# This command has two different meanings which ought to +# have separate command defs, but since the syntax is the +# same for both they have to share one command def with +# an ambiguous meaning. Which command is performed depends +# on whether the LV in the first arg position is a +# cachepool or not (we can't have two different command +# defs that differ only in the type of LV in the arg position +# because when parsing commands we don't know the LV type.) +# +# 1. An alternate form of lvcreate_and_attach_cachepool_v3 +# this syntax: lvcreate --cache --size SizeMB LV_cachepool +# is alternative for: lvcreate --type cache --size SizeMB LV_cachepool +# +# 2. An alternative to using lvconvert to convert LV to type cache, +# but in this case the cachepool is created internally and +# then attached to the LV arg. # # Note that stripes are accepted by the first and not by the # second, but it's not possible to validate this until after # the LV type is known. -# -# So, to define this syntax we have to combine both of -# those variants, each crazy on it's own, into one -# ridiculous command. -# def1: alternate form of lvcreate --type cache, or -# def2: it should be done by lvconvert. lvcreate --cache --size SizeMB LV OO: OO_LVCREATE_CACHE, OO_LVCREATE_POOL, OO_LVCREATE, --stripes Number, --stripesize SizeKB OP: PV ... -ID: lvcreate_cache_vol_with_new_origin_or_convert_to_cache_vol_with_cachepool -DESC: When LV is a cache pool, create a cache LV, -DESC: first creating a new origin LV, then combining it with -DESC: the existing cache pool named in the first arg -DESC: (variant, infers --type cache, also use --cachepool). -DESC: When LV is not a cache pool, convert the specified LV -DESC: to type cache after creating a new cache pool LV to use -DESC: (use lvconvert). +ID: lvcreate_new_plus_old_cachepool_or_lvconvert_old_plus_new_cachepool +DESC: When the LV arg is a cachepool, then create a new LV and +DESC: attach the cachepool arg to it. +DESC: (variant, use --type cache and --cachepool.) +DESC: When the LV arg is not a cachepool, then create a new cachepool +DESC: and attach it to the LV arg (alternative, use lvconvert.) FLAGS: SECONDARY_SYNTAX --- +# These all create a new origin LV, then forwards to lvconvert +# which combines it with a cachevol (which already exists or +# which needs to be created from cachedevice), converting +# the new LV to type cache or writecache. + +lvcreate --type cache --size SizeMB --cachevol LV VG +OO: OO_LVCREATE, OO_LVCREATE_CACHE, --stripes Number, --stripesize SizeKB +OP: PV ... +ID: lvcreate_and_attach_cachevol_for_cache +DESC: Create a new LV, then attach the specified cachevol +DESC: which converts the new LV to type cache. + +lvcreate --type cache --size SizeMB --cachedevice PV VG +OO: OO_LVCREATE, OO_LVCREATE_CACHE, --cachesize SizeMB, --stripes Number, --stripesize SizeKB +OP: PV ... +ID: lvcreate_and_attach_cachedevice_for_cache +DESC: Create a new LV, then attach a cachevol created from +DESC: the specified cache device, which converts the +DESC: new LV to type cache. + +lvcreate --type writecache --size SizeMB --cachevol LV VG +OO: OO_LVCREATE, --cachesettings String, --stripes Number, --stripesize SizeKB +OP: PV ... +ID: lvcreate_and_attach_cachevol_for_writecache +DESC: Create a new LV, then attach the specified cachevol +DESC: which converts the new LV to type writecache. + +lvcreate --type writecache --size SizeMB --cachedevice PV VG +OO: OO_LVCREATE, --cachesize SizeMB, --cachesettings String, --stripes Number, --stripesize SizeKB +OP: PV ... +ID: lvcreate_and_attach_cachedevice_for_writecache +DESC: Create a new LV, then attach a cachevol created from +DESC: the specified cache device, which converts the +DESC: new LV to type writecache. + +--- + lvdisplay OO: --aligned, --all, --binary, --colon, --columns, --configreport ConfigReport, --foreign, --history, --ignorelockingfailure, diff --git a/tools/command.c b/tools/command.c index 511dda13d..2d0184941 100644 --- a/tools/command.c +++ b/tools/command.c @@ -1420,6 +1420,9 @@ int define_commands(struct cmd_context *cmdtool, const char *run_name) if (line[0] == '\n') break; + if (!strcmp(line, "---") || !strcmp(line, "--")) + continue; + if ((n = strchr(line, '\n'))) *n = '\0'; diff --git a/tools/lvconvert.c b/tools/lvconvert.c index 76a9160f3..0155fdbf9 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -4248,18 +4248,25 @@ int lvconvert_to_pool_cmd(struct cmd_context *cmd, int argc, char **argv) NULL, NULL, &_lvconvert_to_pool_single); } +#define MAX_CACHEDEVS 8 + static int _lv_create_cachevol(struct cmd_context *cmd, struct volume_group *vg, struct logical_volume *lv, - const char *dev_name, struct logical_volume **cachevol_lv) { char cvname[NAME_LEN]; - struct device *dev_fast; struct dm_list *use_pvh; - uint64_t cache_size_sectors; - struct logical_volume *cachevol; struct pv_list *pvl; + char *dev_name; + struct device *dev_fast; + char *dev_argv[MAX_CACHEDEVS]; + int dev_argc = 0; + uint64_t cache_size_sectors = 0; + uint64_t full_size_sectors = 0; + uint64_t pv_size_sectors; + struct logical_volume *cachevol; + struct arg_value_group_list *group; struct lvcreate_params lp = { .activate = CHANGE_AN, .alloc = ALLOC_INHERIT, @@ -4275,48 +4282,86 @@ static int _lv_create_cachevol(struct cmd_context *cmd, .suppress_zero_warn = 1, }; - if (dm_snprintf(cvname, NAME_LEN, "%s_cache", lv->name) < 0) { - log_error("Failed to create cachevol LV name."); - return 0; - } + /* + * If cache size is not set, and all cachedevice's are unused, + * then the cache size is the sum of all cachedevice sizes. + */ + cache_size_sectors = arg_uint64_value(cmd, cachesize_ARG, 0); - if (!(dev_fast = dev_cache_get(cmd, dev_name, cmd->filter))) { - log_error("Device %s not found.", dev_name); - return 0; - } + dm_list_iterate_items(group, &cmd->arg_value_groups) { + if (!grouped_arg_is_set(group->arg_values, cachedevice_ARG)) + continue; - if (!(pvl = find_pv_in_vg(vg, dev_name))) { - log_error("PV %s not found in VG.", dev_name); - return 0; - } + if (!(dev_name = (char *)grouped_arg_str_value(group->arg_values, cachedevice_ARG, NULL))) + break; - /* - * If fast_dev is used in the VG, then require a cachesize to allocate - * from it. If fast_dev is not used in the VG, then prompt asking if - * the entire dev should be used. - */ - if (!(cache_size_sectors = arg_uint64_value(cmd, cachesize_ARG, 0))) { - if (pvl->pv->pe_alloc_count) { + if (dev_name[0] == '@') { + if (!cache_size_sectors) { + log_error("With tag as cachedevice, --cachesize is required."); + return 0; + } + goto add_dev_arg; + } + + if (!(dev_fast = dev_cache_get(cmd, dev_name, cmd->filter))) { + log_error("Device %s not found.", dev_name); + return 0; + } + + if (!(pvl = find_pv_in_vg(vg, dev_name))) { + log_error("PV %s not found in VG.", dev_name); + return 0; + } + + /* + * If the dev is used in the VG, then require a cachesize to allocate + * from it. If it is not used in the VG, then prompt asking if the + * entire dev should be used. + */ + if (!cache_size_sectors && pvl->pv->pe_alloc_count) { log_error("PV %s is in use, --cachesize is required.", dev_name); return 0; } - cache_size_sectors = (pvl->pv->pe_count * vg->extent_size); + if (!cache_size_sectors) { + pv_size_sectors = (pvl->pv->pe_count * vg->extent_size); - if (!arg_is_set(cmd, yes_ARG) && - yes_no_prompt("Use all %s from %s for cache? [y/n]: ", - display_size(cmd, cache_size_sectors), dev_name) == 'n') { - log_print("Use --cachesize SizeMB to use a part of the cachedevice."); - log_error("Conversion aborted."); + if (!arg_is_set(cmd, yes_ARG) && + yes_no_prompt("Use all %s from %s for cache? [y/n]: ", + display_size(cmd, pv_size_sectors), dev_name) == 'n') { + log_print("Use --cachesize SizeMB to use a part of the cachedevice."); + log_error("Conversion aborted."); + return 0; + } + full_size_sectors += pv_size_sectors; + } + add_dev_arg: + if (dev_argc >= MAX_CACHEDEVS) { + log_error("Cannot allocate from more than %u cache devices.", MAX_CACHEDEVS); return 0; } + + dev_argv[dev_argc++] = dev_name; + } + + if (!cache_size_sectors) + cache_size_sectors = full_size_sectors; + + if (!dev_argc) { + log_error("No cachedevice specified to create a cachevol."); + return 0; } - if (!(use_pvh = create_pv_list(cmd->mem, vg, 1, (char **)&dev_name, 1))) { + if (!(use_pvh = create_pv_list(cmd->mem, vg, dev_argc, dev_argv, 1))) { log_error("cachedevice not found in VG %s.", dev_name); return 0; } + if (dm_snprintf(cvname, NAME_LEN, "%s_cache", lv->name) < 0) { + log_error("Failed to create cachevol LV name."); + return 0; + } + lp.lv_name = cvname; lp.pvh = use_pvh; lp.extents = cache_size_sectors / vg->extent_size; @@ -4338,27 +4383,19 @@ static int _lv_create_cachevol(struct cmd_context *cmd, return 1; } -static int _lvconvert_cachevol_attach_single(struct cmd_context *cmd, - struct logical_volume *lv, - struct processing_handle *handle) +int lvconvert_cachevol_attach_single(struct cmd_context *cmd, + struct logical_volume *lv, + struct processing_handle *handle) { struct volume_group *vg = lv->vg; struct logical_volume *lv_fast; - const char *fast_name, *dev_name; - - fast_name = arg_str_value(cmd, cachevol_ARG, NULL); - dev_name = arg_str_value(cmd, cachedevice_ARG, NULL); - - if (!fast_name && !dev_name) - goto_bad; - - if (fast_name && dev_name) - goto_bad; + const char *fast_name; /* - * User specifies an existing cachevol to use. + * User specifies an existing cachevol to use or a cachedevice + * to create a cachevol from. */ - if (fast_name) { + if ((fast_name = arg_str_value(cmd, cachevol_ARG, NULL))) { if (!validate_lvname_param(cmd, &vg->name, &fast_name)) goto_bad; @@ -4385,13 +4422,8 @@ static int _lvconvert_cachevol_attach_single(struct cmd_context *cmd, if (!lockd_lv(cmd, lv_fast, "ex", 0)) goto_bad; - } - - /* - * User specifies a device and lvm creates a cachevol on it. - */ - if (dev_name) { - if (!_lv_create_cachevol(cmd, vg, lv, dev_name, &lv_fast)) + } else { + if (!_lv_create_cachevol(cmd, vg, lv, &lv_fast)) goto_bad; } @@ -5705,7 +5737,7 @@ bad: return 0; } -static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, +int lvconvert_writecache_attach_single(struct cmd_context *cmd, struct logical_volume *lv, struct processing_handle *handle) { @@ -5713,7 +5745,7 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, struct logical_volume *lv_wcorig; struct logical_volume *lv_fast; struct writecache_settings settings; - const char *fast_name, *dev_name; + const char *fast_name; uint32_t block_size_sectors = 0; char *lockd_fast_args = NULL; char *lockd_fast_name = NULL; @@ -5721,16 +5753,11 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, char cvol_name[NAME_LEN]; int is_active; - fast_name = arg_str_value(cmd, cachevol_ARG, NULL); - dev_name = arg_str_value(cmd, cachedevice_ARG, NULL); - - if (!fast_name && !dev_name) - goto_bad; - /* - * User specifies an existing cachevol to use. + * User specifies an existing cachevol to use or a cachedevice + * to create a cachevol from. */ - if (fast_name) { + if ((fast_name = arg_str_value(cmd, cachevol_ARG, NULL))) { if (!validate_lvname_param(cmd, &vg->name, &fast_name)) goto_bad; @@ -5765,13 +5792,8 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, log_error("Conversion aborted."); goto bad; } - } - - /* - * User specifies a device and lvm creates a cachevol on it. - */ - if (dev_name) { - if (!_lv_create_cachevol(cmd, vg, lv, dev_name, &lv_fast)) + } else { + if (!_lv_create_cachevol(cmd, vg, lv, &lv_fast)) goto_bad; } @@ -5808,7 +5830,7 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, /* Ensure the LV is not active elsewhere. */ if (!lockd_lv(cmd, lv, "ex", 0)) goto_bad; - if (!dev_name && !lockd_lv(cmd, lv_fast, "ex", 0)) + if (fast_name && !lockd_lv(cmd, lv_fast, "ex", 0)) goto_bad; if (!archive(vg)) @@ -5899,7 +5921,7 @@ int lvconvert_to_writecache_cmd(struct cmd_context *cmd, int argc, char **argv) cmd->cname->flags &= ~GET_VGNAME_FROM_OPTIONS; ret = process_each_lv(cmd, cmd->position_argc, cmd->position_argv, NULL, NULL, READ_FOR_UPDATE, handle, NULL, - &_lvconvert_writecache_attach_single); + &lvconvert_writecache_attach_single); destroy_processing_handle(cmd, handle); @@ -5922,7 +5944,7 @@ int lvconvert_to_cache_with_cachevol_cmd(struct cmd_context *cmd, int argc, char cmd->cname->flags &= ~GET_VGNAME_FROM_OPTIONS; ret = process_each_lv(cmd, cmd->position_argc, cmd->position_argv, NULL, NULL, READ_FOR_UPDATE, handle, NULL, - &_lvconvert_cachevol_attach_single); + &lvconvert_cachevol_attach_single); destroy_processing_handle(cmd, handle); diff --git a/tools/lvcreate.c b/tools/lvcreate.c index 5c978b3cc..3357a08c5 100644 --- a/tools/lvcreate.c +++ b/tools/lvcreate.c @@ -766,7 +766,9 @@ static int _lvcreate_params(struct cmd_context *cmd, * * Ordering of following type tests is IMPORTANT */ - if ((segtype_str = arg_str_value(cmd, type_ARG, NULL))) { + if (lp->ignore_type) { + segtype_str = SEG_TYPE_NAME_STRIPED; + } else if ((segtype_str = arg_str_value(cmd, type_ARG, NULL))) { lp->type = 1; if (!strcmp(segtype_str, "linear")) { segtype_str = "striped"; @@ -1799,3 +1801,152 @@ int lvcreate(struct cmd_context *cmd, int argc, char **argv) destroy_processing_handle(cmd, handle); return ret; } + +static int _lvcreate_and_attach_writecache_single(struct cmd_context *cmd, + const char *vg_name, struct volume_group *vg, struct processing_handle *handle) +{ + struct processing_params *pp = (struct processing_params *) handle->custom_handle; + struct lvcreate_params *lp = pp->lp; + struct logical_volume *lv; + int ret; + + ret = _lvcreate_single(cmd, vg_name, vg, handle); + + if (ret == ECMD_FAILED) + return ret; + + if (!(lv = find_lv(vg, lp->lv_name))) { + log_error("Failed to find LV %s to add writecache.", lp->lv_name); + return ECMD_FAILED; + } + + ret = lvconvert_writecache_attach_single(cmd, lv, handle); + + if (ret == ECMD_FAILED) { + log_error("Removing new LV after failing to add writecache."); + if (!deactivate_lv(cmd, lv)) + log_error("Failed to deactivate new LV %s.", display_lvname(lv)); + if (!lv_remove_with_dependencies(cmd, lv, 1, 0)) + log_error("Failed to remove new LV %s.", display_lvname(lv)); + return ECMD_FAILED; + } + + return ECMD_PROCESSED; +} + +int lvcreate_and_attach_writecache_cmd(struct cmd_context *cmd, int argc, char **argv) +{ + struct processing_handle *handle = NULL; + struct processing_params pp; + struct lvcreate_params lp = { + .major = -1, + .minor = -1, + }; + struct lvcreate_cmdline_params lcp = { 0 }; + int ret; + + /* + * Tell lvcreate to ignore --type since we are using lvcreate + * to create a linear LV and using lvconvert to add cache. + * (Would be better if lvcreate code was split up so we could + * call a specific function that just created a linear/striped LV.) + */ + lp.ignore_type = 1; + + if (!_lvcreate_params(cmd, argc, argv, &lp, &lcp)) { + stack; + return EINVALID_CMD_LINE; + } + + pp.lp = &lp; + pp.lcp = &lcp; + + if (!(handle = init_processing_handle(cmd, NULL))) { + log_error("Failed to initialize processing handle."); + return ECMD_FAILED; + } + + handle->custom_handle = &pp; + + ret = process_each_vg(cmd, 0, NULL, lp.vg_name, NULL, READ_FOR_UPDATE, 0, handle, + &_lvcreate_and_attach_writecache_single); + + _destroy_lvcreate_params(&lp); + destroy_processing_handle(cmd, handle); + return ret; +} + +static int _lvcreate_and_attach_cache_single(struct cmd_context *cmd, + const char *vg_name, struct volume_group *vg, struct processing_handle *handle) +{ + struct processing_params *pp = (struct processing_params *) handle->custom_handle; + struct lvcreate_params *lp = pp->lp; + struct logical_volume *lv; + int ret; + + ret = _lvcreate_single(cmd, vg_name, vg, handle); + + if (ret == ECMD_FAILED) + return ret; + + if (!(lv = find_lv(vg, lp->lv_name))) { + log_error("Failed to find LV %s to add cache.", lp->lv_name); + return ECMD_FAILED; + } + + ret = lvconvert_cachevol_attach_single(cmd, lv, handle); + + if (ret == ECMD_FAILED) { + log_error("Removing new LV after failing to add cache."); + if (!deactivate_lv(cmd, lv)) + log_error("Failed to deactivate new LV %s.", display_lvname(lv)); + if (!lv_remove_with_dependencies(cmd, lv, 1, 0)) + log_error("Failed to remove new LV %s.", display_lvname(lv)); + return ECMD_FAILED; + } + + return ECMD_PROCESSED; +} + +int lvcreate_and_attach_cache_cmd(struct cmd_context *cmd, int argc, char **argv) +{ + struct processing_handle *handle = NULL; + struct processing_params pp; + struct lvcreate_params lp = { + .major = -1, + .minor = -1, + }; + struct lvcreate_cmdline_params lcp = { 0 }; + int ret; + + /* + * Tell lvcreate to ignore --type since we are using lvcreate + * to create a linear LV and using lvconvert to add cache. + * (Would be better if lvcreate code was split up so we could + * call a specific function that just created a linear/striped LV.) + */ + lp.ignore_type = 1; + + if (!_lvcreate_params(cmd, argc, argv, &lp, &lcp)) { + stack; + return EINVALID_CMD_LINE; + } + + pp.lp = &lp; + pp.lcp = &lcp; + + if (!(handle = init_processing_handle(cmd, NULL))) { + log_error("Failed to initialize processing handle."); + return ECMD_FAILED; + } + + handle->custom_handle = &pp; + + ret = process_each_vg(cmd, 0, NULL, lp.vg_name, NULL, READ_FOR_UPDATE, 0, handle, + &_lvcreate_and_attach_cache_single); + + _destroy_lvcreate_params(&lp); + destroy_processing_handle(cmd, handle); + return ret; +} + diff --git a/tools/lvmcmdline.c b/tools/lvmcmdline.c index 9c345bd99..7cf4e3ff0 100644 --- a/tools/lvmcmdline.c +++ b/tools/lvmcmdline.c @@ -154,6 +154,12 @@ static const struct command_function _command_functions[CMD_COUNT] = { /* lvconvert for integrity */ { lvconvert_integrity_CMD, lvconvert_integrity_cmd }, + /* lvcreate */ + { lvcreate_and_attach_cachevol_for_cache_CMD, lvcreate_and_attach_cache_cmd }, + { lvcreate_and_attach_cachedevice_for_cache_CMD, lvcreate_and_attach_cache_cmd }, + { lvcreate_and_attach_cachevol_for_writecache_CMD, lvcreate_and_attach_writecache_cmd }, + { lvcreate_and_attach_cachedevice_for_writecache_CMD, lvcreate_and_attach_writecache_cmd }, + { pvscan_display_CMD, pvscan_display_cmd }, { pvscan_cache_CMD, pvscan_cache_cmd }, }; diff --git a/tools/tools.h b/tools/tools.h index 7f2434d06..c3d780d36 100644 --- a/tools/tools.h +++ b/tools/tools.h @@ -278,7 +278,18 @@ int lvconvert_to_vdopool_param_cmd(struct cmd_context *cmd, int argc, char **arg int lvconvert_integrity_cmd(struct cmd_context *cmd, int argc, char **argv); +int lvcreate_and_attach_writecache_cmd(struct cmd_context *cmd, int argc, char **argv); +int lvcreate_and_attach_cache_cmd(struct cmd_context *cmd, int argc, char **argv); + int pvscan_display_cmd(struct cmd_context *cmd, int argc, char **argv); int pvscan_cache_cmd(struct cmd_context *cmd, int argc, char **argv); + +int lvconvert_writecache_attach_single(struct cmd_context *cmd, + struct logical_volume *lv, + struct processing_handle *handle); +int lvconvert_cachevol_attach_single(struct cmd_context *cmd, + struct logical_volume *lv, + struct processing_handle *handle); + #endif

1 0

master - lvconvert: single step cachevol creation and attachment
by David Teigland 22 Jun '20

22 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=21b37964eb88d404998e3… Commit: 21b37964eb88d404998e37acae5530ec102a2116 Parent: 950d2d59c140c82fea35e56d34c92289562d4d6f Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Feb 5 13:42:36 2020 -0600 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Jun 16 13:46:51 2020 -0500 lvconvert: single step cachevol creation and attachment To add a cache or writecache to a main LV with a single command: lvconvert --type cache|writecache --cachedevice /dev/ssd vg/main A cachevol LV will be allocated from the specified cache device, then attached to the main LV. Include --cachesize to specify the size of cachevol to create, otherwise the entire cachedevice is used. The cachedevice option can be repeated to create a cachevol from multiple devices. Example ------- A user has an existing main LV that they want to speed up using a new ssd. user adds the new ssd to the VG: $ vgextend vg /dev/ssd user attaches the new ssd their main LV: $ lvconvert --type writecache --cachedevice /dev/ssd vg/main Example ------- A user has two existing main LVs that they want to speed up with a new ssd. user adds the new 16G ssd to the VG: $ vgextend vg /dev/ssd user attaches some of the new ssd to the first main LV, using half of the space: $ lvconvert --type writecache --cachedevice /dev/ssd --cachesize 8G vg/main1 user attaches some of the new ssd to the second main LV, using the other half of the space: $ lvconvert --type writecache --cachedevice /dev/ssd --cachesize 8G vg/main2 Example ------- A user has an existing main LV that they want to speed up using two new ssds. user adds the new two ssds the VG: $ vgextend vg /dev/ssd1 $ vgextend vg /dev/ssd2 user attaches both ssds their main LV: $ lvconvert --type writecache --cachedevice /dev/ssd1 --cachedevice /dev/ssd2 vg/main --- tools/args.h | 6 ++ tools/command-lines.in | 14 +++ tools/lvconvert.c | 250 +++++++++++++++++++++++++++++++++++++------------ tools/lvmcmdline.c | 2 + 4 files changed, 211 insertions(+), 61 deletions(-) diff --git a/tools/args.h b/tools/args.h index 5fae21abb..c69a0ecce 100644 --- a/tools/args.h +++ b/tools/args.h @@ -126,6 +126,12 @@ arg(cachepool_ARG, '\0', "cachepool", lv_VAL, 0, 0, arg(cachevol_ARG, '\0', "cachevol", lv_VAL, 0, 0, "The name of a cache volume.\n") +arg(cachedevice_ARG, '\0', "cachedevice", pv_VAL, 0, 0, + "The name of a device to use for a cache.\n") + +arg(cachesize_ARG, '\0', "cachesize", sizemb_VAL, 0, 0, + "The size of cache to use.\n") + arg(commandprofile_ARG, '\0', "commandprofile", string_VAL, 0, 0, "The command profile to use for command configuration.\n" "See \\fBlvm.conf\\fP(5) for more information about profiles.\n") diff --git a/tools/command-lines.in b/tools/command-lines.in index 98044a918..8d389b665 100644 --- a/tools/command-lines.in +++ b/tools/command-lines.in @@ -497,6 +497,20 @@ FLAGS: SECONDARY_SYNTAX --- +lvconvert --type writecache --cachedevice PV LV +OO: OO_LVCONVERT, --cachesize SizeMB, --cachesettings String +ID: lvconvert_to_writecache_with_device +DESC: Add a writecache to an LV, using a specified cache device. +RULE: all and lv_is_visible + +lvconvert --type cache --cachedevice PV LV +OO: OO_LVCONVERT, --cachesize SizeMB, --cachesettings String +ID: lvconvert_to_cache_with_device +DESC: Add a cache to an LV, using a specified cache device. +RULE: all and lv_is_visible + +--- + lvconvert --type thin-pool LV_linear_striped_raid_cache OO: --stripes_long Number, --stripesize SizeKB, --discards Discards, OO_LVCONVERT_POOL, OO_LVCONVERT diff --git a/tools/lvconvert.c b/tools/lvconvert.c index 94ea70fa5..76a9160f3 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -4248,51 +4248,159 @@ int lvconvert_to_pool_cmd(struct cmd_context *cmd, int argc, char **argv) NULL, NULL, &_lvconvert_to_pool_single); } +static int _lv_create_cachevol(struct cmd_context *cmd, + struct volume_group *vg, + struct logical_volume *lv, + const char *dev_name, + struct logical_volume **cachevol_lv) +{ + char cvname[NAME_LEN]; + struct device *dev_fast; + struct dm_list *use_pvh; + uint64_t cache_size_sectors; + struct logical_volume *cachevol; + struct pv_list *pvl; + struct lvcreate_params lp = { + .activate = CHANGE_AN, + .alloc = ALLOC_INHERIT, + .major = -1, + .minor = -1, + .permission = LVM_READ | LVM_WRITE, + .pvh = &vg->pvs, + .read_ahead = DM_READ_AHEAD_NONE, + .stripes = 1, + .vg_name = vg->name, + .zero = 0, + .wipe_signatures = 0, + .suppress_zero_warn = 1, + }; + + if (dm_snprintf(cvname, NAME_LEN, "%s_cache", lv->name) < 0) { + log_error("Failed to create cachevol LV name."); + return 0; + } + + if (!(dev_fast = dev_cache_get(cmd, dev_name, cmd->filter))) { + log_error("Device %s not found.", dev_name); + return 0; + } + + if (!(pvl = find_pv_in_vg(vg, dev_name))) { + log_error("PV %s not found in VG.", dev_name); + return 0; + } + + /* + * If fast_dev is used in the VG, then require a cachesize to allocate + * from it. If fast_dev is not used in the VG, then prompt asking if + * the entire dev should be used. + */ + if (!(cache_size_sectors = arg_uint64_value(cmd, cachesize_ARG, 0))) { + if (pvl->pv->pe_alloc_count) { + log_error("PV %s is in use, --cachesize is required.", dev_name); + return 0; + } + + cache_size_sectors = (pvl->pv->pe_count * vg->extent_size); + + if (!arg_is_set(cmd, yes_ARG) && + yes_no_prompt("Use all %s from %s for cache? [y/n]: ", + display_size(cmd, cache_size_sectors), dev_name) == 'n') { + log_print("Use --cachesize SizeMB to use a part of the cachedevice."); + log_error("Conversion aborted."); + return 0; + } + } + + if (!(use_pvh = create_pv_list(cmd->mem, vg, 1, (char **)&dev_name, 1))) { + log_error("cachedevice not found in VG %s.", dev_name); + return 0; + } + + lp.lv_name = cvname; + lp.pvh = use_pvh; + lp.extents = cache_size_sectors / vg->extent_size; + + log_print("Creating cachevol LV %s with size %s.", + cvname, display_size(cmd, cache_size_sectors)); + + dm_list_init(&lp.tags); + + if (!(lp.segtype = get_segtype_from_string(cmd, SEG_TYPE_NAME_STRIPED))) + return_0; + + if (!(cachevol = lv_create_single(vg, &lp))) { + log_error("Failed to create cachevol LV"); + return 0; + } + + *cachevol_lv = cachevol; + return 1; +} + static int _lvconvert_cachevol_attach_single(struct cmd_context *cmd, struct logical_volume *lv, struct processing_handle *handle) { struct volume_group *vg = lv->vg; - struct logical_volume *cachevol_lv; - const char *cachevol_name; + struct logical_volume *lv_fast; + const char *fast_name, *dev_name; - if (!(cachevol_name = arg_str_value(cmd, cachevol_ARG, NULL))) - goto_out; + fast_name = arg_str_value(cmd, cachevol_ARG, NULL); + dev_name = arg_str_value(cmd, cachedevice_ARG, NULL); - if (!validate_lvname_param(cmd, &vg->name, &cachevol_name)) - goto_out; + if (!fast_name && !dev_name) + goto_bad; - if (!(cachevol_lv = find_lv(vg, cachevol_name))) { - log_error("Cache single %s not found.", cachevol_name); - goto out; - } + if (fast_name && dev_name) + goto_bad; - if (lv_is_cache_vol(cachevol_lv)) { - log_error("LV %s is already used as a cachevol.", display_lvname(cachevol_lv)); - goto out; - } + /* + * User specifies an existing cachevol to use. + */ + if (fast_name) { + if (!validate_lvname_param(cmd, &vg->name, &fast_name)) + goto_bad; - /* Ensure the LV is not active elsewhere. */ - if (!lockd_lv(cmd, lv, "ex", 0)) - goto_out; + if (!(lv_fast = find_lv(vg, fast_name))) { + log_error("LV %s not found.", fast_name); + goto bad; + } - if (!dm_list_empty(&cachevol_lv->segs_using_this_lv)) { - log_error("LV %s is already in use.", display_lvname(cachevol_lv)); - goto out; + if (lv_is_cache_vol(lv_fast)) { + log_error("LV %s is already used as a cachevol.", display_lvname(lv_fast)); + goto bad; + } + + if (!dm_list_empty(&lv_fast->segs_using_this_lv)) { + log_error("LV %s is already in use.", display_lvname(lv_fast)); + goto bad; + } + + if (!arg_is_set(cmd, yes_ARG) && + yes_no_prompt("Erase all existing data on %s? [y/n]: ", display_lvname(lv_fast)) == 'n') { + log_error("Conversion aborted."); + goto bad; + } + + if (!lockd_lv(cmd, lv_fast, "ex", 0)) + goto_bad; } - if (!arg_is_set(cmd, yes_ARG) && - yes_no_prompt("Erase all existing data on %s? [y/n]: ", display_lvname(cachevol_lv)) == 'n') { - log_error("Conversion aborted."); - goto out; + /* + * User specifies a device and lvm creates a cachevol on it. + */ + if (dev_name) { + if (!_lv_create_cachevol(cmd, vg, lv, dev_name, &lv_fast)) + goto_bad; } /* Ensure the LV is not active elsewhere. */ - if (!lockd_lv(cmd, cachevol_lv, "ex", LDLV_PERSISTENT)) - goto_out; + if (!lockd_lv(cmd, lv, "ex", 0)) + goto_bad; - if (!wipe_cache_pool(cachevol_lv)) - goto_out; + if (!wipe_cache_pool(lv_fast)) + goto_bad; /* When the lv arg is a thinpool, redirect command to data sub lv. */ @@ -4302,17 +4410,17 @@ static int _lvconvert_cachevol_attach_single(struct cmd_context *cmd, } if (_raid_split_image_conversion(lv)) - goto_out; + goto_bad; /* Attach the cache to the main LV. */ - if (!_cache_vol_attach(cmd, lv, cachevol_lv)) - goto_out; + if (!_cache_vol_attach(cmd, lv, lv_fast)) + goto_bad; log_print_unless_silent("Logical volume %s is now cached.", display_lvname(lv)); return ECMD_PROCESSED; - out: + bad: return ECMD_FAILED; } @@ -5605,7 +5713,7 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, struct logical_volume *lv_wcorig; struct logical_volume *lv_fast; struct writecache_settings settings; - const char *fast_name; + const char *fast_name, *dev_name; uint32_t block_size_sectors = 0; char *lockd_fast_args = NULL; char *lockd_fast_name = NULL; @@ -5613,32 +5721,58 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, char cvol_name[NAME_LEN]; int is_active; - fast_name = arg_str_value(cmd, cachevol_ARG, ""); + fast_name = arg_str_value(cmd, cachevol_ARG, NULL); + dev_name = arg_str_value(cmd, cachedevice_ARG, NULL); - if (!(lv_fast = find_lv(vg, fast_name))) { - log_error("LV %s not found.", fast_name); - goto bad; - } + if (!fast_name && !dev_name) + goto_bad; - if (lv_fast == lv) { - log_error("Invalid cachevol LV."); - goto bad; - } + /* + * User specifies an existing cachevol to use. + */ + if (fast_name) { + if (!validate_lvname_param(cmd, &vg->name, &fast_name)) + goto_bad; - if (!seg_is_linear(first_seg(lv_fast))) { - log_error("LV %s must be linear to use as a writecache.", display_lvname(lv_fast)); - goto bad; - } + if (!(lv_fast = find_lv(vg, fast_name))) { + log_error("LV %s not found.", fast_name); + goto bad; + } - if (lv_is_cache_vol(lv_fast)) { - log_error("LV %s is already used as a cachevol.", display_lvname(lv_fast)); - goto bad; + if (lv_fast == lv) { + log_error("Invalid cachevol LV."); + goto bad; + } + + if (lv_is_cache_vol(lv_fast)) { + log_error("LV %s is already used as a cachevol.", display_lvname(lv_fast)); + goto bad; + } + + if (!seg_is_linear(first_seg(lv_fast))) { + log_error("LV %s must be linear to use as a writecache.", display_lvname(lv_fast)); + goto bad; + } + + /* fast LV shouldn't generally be active by itself, but just in case. */ + if (lv_is_active(lv_fast)) { + log_error("LV %s must be inactive to attach.", display_lvname(lv_fast)); + goto bad; + } + + if (!arg_is_set(cmd, yes_ARG) && + yes_no_prompt("Erase all existing data on %s? [y/n]: ", display_lvname(lv_fast)) == 'n') { + log_error("Conversion aborted."); + goto bad; + } } - /* fast LV shouldn't generally be active by itself, but just in case. */ - if (lv_info(cmd, lv_fast, 1, NULL, 0, 0)) { - log_error("LV %s must be inactive to attach.", display_lvname(lv_fast)); - goto bad; + /* + * User specifies a device and lvm creates a cachevol on it. + */ + if (dev_name) { + if (!_lv_create_cachevol(cmd, vg, lv, dev_name, &lv_fast)) + goto_bad; } is_active = lv_is_active(lv); @@ -5671,16 +5805,10 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, } } - if (!arg_is_set(cmd, yes_ARG) && - yes_no_prompt("Erase all existing data on %s? [y/n]: ", display_lvname(lv_fast)) == 'n') { - log_error("Conversion aborted."); - goto bad; - } - - /* Ensure the two LVs are not active elsewhere. */ + /* Ensure the LV is not active elsewhere. */ if (!lockd_lv(cmd, lv, "ex", 0)) goto_bad; - if (!lockd_lv(cmd, lv_fast, "ex", 0)) + if (!dev_name && !lockd_lv(cmd, lv_fast, "ex", 0)) goto_bad; if (!archive(vg)) diff --git a/tools/lvmcmdline.c b/tools/lvmcmdline.c index d87a8f053..9c345bd99 100644 --- a/tools/lvmcmdline.c +++ b/tools/lvmcmdline.c @@ -124,8 +124,10 @@ static const struct command_function _command_functions[CMD_COUNT] = { { lvconvert_to_cachepool_CMD, lvconvert_to_pool_cmd }, { lvconvert_to_thin_with_external_CMD, lvconvert_to_thin_with_external_cmd }, { lvconvert_to_cache_with_cachevol_CMD, lvconvert_to_cache_with_cachevol_cmd }, + { lvconvert_to_cache_with_device_CMD, lvconvert_to_cache_with_cachevol_cmd }, { lvconvert_to_cache_with_cachepool_CMD, lvconvert_to_cache_with_cachepool_cmd }, { lvconvert_to_writecache_CMD, lvconvert_to_writecache_cmd }, + { lvconvert_to_writecache_with_device_CMD, lvconvert_to_writecache_cmd }, { lvconvert_swap_pool_metadata_CMD, lvconvert_swap_pool_metadata_cmd }, { lvconvert_to_thinpool_or_swap_metadata_CMD, lvconvert_to_pool_or_swap_metadata_cmd }, { lvconvert_to_cachepool_or_swap_metadata_CMD, lvconvert_to_pool_or_swap_metadata_cmd },

1 0

master - integrity: wait for raid sync to complete
by David Teigland 16 Jun '20

16 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=950d2d59c140c82fea35e… Commit: 950d2d59c140c82fea35e56d34c92289562d4d6f Parent: 48872b0369af5ee048c947586d7da82d9769f5c3 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Tue Jun 16 12:29:41 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Jun 16 12:29:41 2020 -0500 integrity: wait for raid sync to complete --- test/shell/integrity-misc.sh | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/test/shell/integrity-misc.sh b/test/shell/integrity-misc.sh index 0d056890c..2dae25f59 100644 --- a/test/shell/integrity-misc.sh +++ b/test/shell/integrity-misc.sh @@ -95,7 +95,7 @@ _sync_percent() { get lv_field "$checklv" sync_percent | cut -d. -f1 } -_wait_recalc() { +_wait_sync() { local checklv=$1 for i in $(seq 1 10) ; do @@ -124,8 +124,9 @@ _wait_recalc() { # lvrename _prepare_vg lvcreate --type raid1 -m1 --raidintegrity y -n $lv1 -l 8 $vg -_wait_recalc $vg/${lv1}_rimage_0 -_wait_recalc $vg/${lv1}_rimage_1 +_wait_sync $vg/${lv1}_rimage_0 +_wait_sync $vg/${lv1}_rimage_1 +_wait_sync $vg/$lv1 _add_new_data_to_mnt umount $mnt lvrename $vg/$lv1 $vg/$lv2 @@ -141,8 +142,9 @@ vgremove -ff $vg # lv must be active _prepare_vg lvcreate --type raid1 -m1 --raidintegrity y -n $lv1 -l 8 $vg "$dev1" "$dev2" -_wait_recalc $vg/${lv1}_rimage_0 -_wait_recalc $vg/${lv1}_rimage_1 +_wait_sync $vg/${lv1}_rimage_0 +_wait_sync $vg/${lv1}_rimage_1 +_wait_sync $vg/$lv1 _add_new_data_to_mnt lvconvert --replace "$dev1" $vg/$lv1 "$dev3" lvs -a -o+devices $vg > out @@ -162,8 +164,9 @@ vgremove -ff $vg # same as prev but with bitmap mode _prepare_vg lvcreate --type raid1 -m1 --raidintegrity y --raidintegritymode bitmap -n $lv1 -l 8 $vg "$dev1" "$dev2" -_wait_recalc $vg/${lv1}_rimage_0 -_wait_recalc $vg/${lv1}_rimage_1 +_wait_sync $vg/${lv1}_rimage_0 +_wait_sync $vg/${lv1}_rimage_1 +_wait_sync $vg/$lv1 _add_new_data_to_mnt lvconvert --replace "$dev1" $vg/$lv1 "$dev3" lvs -a -o+devices $vg > out @@ -185,8 +188,9 @@ vgremove -ff $vg # (like lvconvert --replace does for a dev that's not missing). _prepare_vg lvcreate --type raid1 -m1 --raidintegrity y -n $lv1 -l 8 $vg "$dev1" "$dev2" -_wait_recalc $vg/${lv1}_rimage_0 -_wait_recalc $vg/${lv1}_rimage_1 +_wait_sync $vg/${lv1}_rimage_0 +_wait_sync $vg/${lv1}_rimage_1 +_wait_sync $vg/$lv1 _add_new_data_to_mnt aux disable_dev "$dev2" lvs -a -o+devices $vg > out @@ -213,8 +217,9 @@ vgremove -ff $vg _prepare_vg lvcreate --type raid1 -m1 --raidintegrity y -n $lv1 -l 8 $vg "$dev1" "$dev2" -_wait_recalc $vg/${lv1}_rimage_0 -_wait_recalc $vg/${lv1}_rimage_1 +_wait_sync $vg/${lv1}_rimage_0 +_wait_sync $vg/${lv1}_rimage_1 +_wait_sync $vg/$lv1 _add_new_data_to_mnt umount $mnt lvchange -an $vg/$lv1

1 0

master - integrity: avoid increasing logical block size of active LV
by David Teigland 16 Jun '20

16 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=48872b0369af5ee048c94… Commit: 48872b0369af5ee048c947586d7da82d9769f5c3 Parent: a014c4f3411f6b2f6c4c721a84253eed46cc3de6 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Tue Jun 16 11:59:59 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Tue Jun 16 12:27:22 2020 -0500 integrity: avoid increasing logical block size of active LV When adding integrity to an active LV, avoid choosing an integrity block size that would result in increasing the logical block size of the LV. --- lib/metadata/integrity_manip.c | 12 +++++++++--- test/shell/integrity-blocksize-2.sh | 39 +++++++++++++++++++------------------ test/shell/integrity-blocksize-3.sh | 39 +++++++++++++++++++------------------ test/shell/integrity-blocksize.sh | 20 +++++++++++++++---- test/shell/integrity-large.sh | 2 +- 5 files changed, 66 insertions(+), 46 deletions(-) diff --git a/lib/metadata/integrity_manip.c b/lib/metadata/integrity_manip.c index 790642dbb..334452711 100644 --- a/lib/metadata/integrity_manip.c +++ b/lib/metadata/integrity_manip.c @@ -278,7 +278,7 @@ int lv_remove_integrity_from_raid(struct logical_volume *lv) return 1; } -static int _set_integrity_block_size(struct cmd_context *cmd, struct logical_volume *lv, +static int _set_integrity_block_size(struct cmd_context *cmd, struct logical_volume *lv, int is_active, struct integrity_settings *settings, int lbs_4k, int lbs_512, int pbs_4k, int pbs_512) { @@ -375,7 +375,13 @@ static int _set_integrity_block_size(struct cmd_context *cmd, struct logical_vol } if (!settings->block_size) { - if (fs_block_size <= 4096) + if (is_active && lbs_512) { + /* increasing the lbs from 512 to 4k under an active LV could cause problems + for an application that expects a given io size/alignment is possible. */ + settings->block_size = 512; + if (fs_block_size > 512) + log_print("Limiting integrity block size to 512 because the LV is active."); + } else if (fs_block_size <= 4096) settings->block_size = fs_block_size; else settings->block_size = 4096; /* dm-integrity max is 4096 */ @@ -602,7 +608,7 @@ int lv_add_integrity_to_raid(struct logical_volume *lv, struct integrity_setting * integrity block size chosen based on device logical block size and * file system block size. */ - if (!_set_integrity_block_size(cmd, lv, settings, lbs_4k, lbs_512, pbs_4k, pbs_512)) { + if (!_set_integrity_block_size(cmd, lv, is_active, settings, lbs_4k, lbs_512, pbs_4k, pbs_512)) { if (!is_active && !deactivate_lv(cmd, lv)) stack; goto_bad; diff --git a/test/shell/integrity-blocksize-2.sh b/test/shell/integrity-blocksize-2.sh index a7bb71f9a..5e0fd9ad1 100644 --- a/test/shell/integrity-blocksize-2.sh +++ b/test/shell/integrity-blocksize-2.sh @@ -81,28 +81,29 @@ umount $mnt lvchange -an $vg/$lv1 lvremove $vg/$lv1 -# FIXME: the second xfs mount fails related to block size and converting active LV, bug 1847180 # add integrity while LV is active, fs unmounted -#lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg -#lvchange -an $vg/$lv1 -#lvchange -ay $vg/$lv1 -#mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" -#mount "$DM_DEV_DIR/$vg/$lv1" $mnt -#echo "hello world" > $mnt/hello -#umount $mnt -#lvchange -an $vg -#lvchange -ay $vg -#lvconvert --raidintegrity y $vg/$lv1 -#_wait_recalc $vg/${lv1}_rimage_0 -#_wait_recalc $vg/${lv1}_rimage_1 -#lvs -a -o+devices $vg -#mount "$DM_DEV_DIR/$vg/$lv1" $mnt -#cat $mnt/hello | grep "hello world" -#umount $mnt -#lvchange -an $vg/$lv1 -#lvremove $vg/$lv1 +# lvconvert will use ribs 512 to avoid increasing LBS from 512 to 4k on active LV +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvchange -ay $vg +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 # add integrity while LV is active, fs mounted +# lvconvert will use ribs 512 to avoid increasing LBS from 512 to 4k on active LV lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg lvchange -an $vg/$lv1 lvchange -ay $vg/$lv1 diff --git a/test/shell/integrity-blocksize-3.sh b/test/shell/integrity-blocksize-3.sh index 7170aa907..4aea97253 100644 --- a/test/shell/integrity-blocksize-3.sh +++ b/test/shell/integrity-blocksize-3.sh @@ -236,28 +236,29 @@ umount $mnt lvchange -an $vg/$lv1 lvremove $vg/$lv1 -# FIXME: second xfs mount fails related to block size and converting active LV, bug 1847180 # add integrity while LV is active, fs unmounted -#lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg -#lvchange -an $vg/$lv1 -#lvchange -ay $vg/$lv1 -#mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" -#mount "$DM_DEV_DIR/$vg/$lv1" $mnt -#echo "hello world" > $mnt/hello -#umount $mnt -#lvchange -an $vg -#lvchange -ay $vg -#lvconvert --raidintegrity y $vg/$lv1 -#_wait_recalc $vg/${lv1}_rimage_0 -#_wait_recalc $vg/${lv1}_rimage_1 -#lvs -a -o+devices $vg -#mount "$DM_DEV_DIR/$vg/$lv1" $mnt -#cat $mnt/hello | grep "hello world" -#umount $mnt -#lvchange -an $vg/$lv1 -#lvremove $vg/$lv1 +# lvconvert will use ribs 512 to avoid increasing LBS from 512 to 4k on active LV +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvchange -ay $vg +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 # add integrity while LV is active, fs mounted +# lvconvert will use ribs 512 to avoid increasing LBS from 512 to 4k on active LV lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg lvchange -an $vg/$lv1 lvchange -ay $vg/$lv1 diff --git a/test/shell/integrity-blocksize.sh b/test/shell/integrity-blocksize.sh index a829502d1..eb6a364f2 100644 --- a/test/shell/integrity-blocksize.sh +++ b/test/shell/integrity-blocksize.sh @@ -140,7 +140,7 @@ umount $mnt pvck --dump metadata $LOOP3 | grep 'block_size = 4096' lvremove -y $vg2/$lv1 -# lvconvert on dev512, ext4 1024, result 1024 +# lvconvert on dev512, ext4 1024, result 1024 (LV active when adding) lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 aux wipefs_a /dev/$vg1/$lv1 mkfs.ext4 -b 1024 "$DM_DEV_DIR/$vg1/$lv1" @@ -149,6 +149,20 @@ lvconvert --raidintegrity y $vg1/$lv1 blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"1024\" mount "$DM_DEV_DIR/$vg1/$lv1" $mnt umount $mnt +pvck --dump metadata $LOOP1 | grep 'block_size = 512' +lvremove -y $vg1/$lv1 + +# lvconvert on dev512, ext4 1024, result 1024 (LV inactive when adding) +lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 +aux wipefs_a /dev/$vg1/$lv1 +mkfs.ext4 -b 1024 "$DM_DEV_DIR/$vg1/$lv1" +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"1024\" +lvchange -an $vg1/$lv1 +lvconvert --raidintegrity y $vg1/$lv1 +lvchange -ay $vg1/$lv1 +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"1024\" +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +umount $mnt pvck --dump metadata $LOOP1 | grep 'block_size = 1024' lvremove -y $vg1/$lv1 @@ -176,15 +190,13 @@ umount $mnt pvck --dump metadata $LOOP1 | grep 'block_size = 512' lvremove -y $vg1/$lv1 -# FIXME: if lv is active while integrity is added, then xfs mount fails related to block size, bug 1847180 # lvconvert --bs 1024 on dev512, xfs 4096, result 1024 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 aux wipefs_a /dev/$vg1/$lv1 mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg1/$lv1" blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" -# TODO: also test adding integrity when the lv is active, -# and also when the lv is active and fs is mounted? lvchange -an $vg1/$lv1 +# lv needs to be inactive to increase LBS from 512 lvconvert --raidintegrity y --raidintegrityblocksize 1024 $vg1/$lv1 lvchange -ay $vg1/$lv1 blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" diff --git a/test/shell/integrity-large.sh b/test/shell/integrity-large.sh index 016d100d9..1df9e6b53 100644 --- a/test/shell/integrity-large.sh +++ b/test/shell/integrity-large.sh @@ -115,8 +115,8 @@ lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg lvchange -an $vg/$lv1 lvchange -ay $vg/$lv1 _add_data_to_lv +# lv needs to be inactive when adding integrity to increase LBS from 512 and get a ribs of 4k lvchange -an $vg/$lv1 -# FIXME: if lv remains active during convert, then xfs mount fails related to block size, bug 1847180 lvconvert --raidintegrity y $vg/$lv1 lvchange -ay $vg/$lv1 _wait_recalc $vg/${lv1}_rimage_0

1 0

master - tests: integrity and block size
by David Teigland 15 Jun '20

15 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=a014c4f3411f6b2f6c4c7… Commit: a014c4f3411f6b2f6c4c721a84253eed46cc3de6 Parent: 8e2938c963bb8226b72297647bef89895e5ae548 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Mon Jun 15 14:08:28 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Mon Jun 15 16:04:40 2020 -0500 tests: integrity and block size --- test/shell/integrity-blocksize-2.sh | 127 ++++++++++++++++ test/shell/integrity-blocksize-3.sh | 284 ++++++++++++++++++++++++++++++++++++ test/shell/integrity-blocksize.sh | 46 ++++-- test/shell/integrity-large.sh | 3 + 4 files changed, 445 insertions(+), 15 deletions(-) diff --git a/test/shell/integrity-blocksize-2.sh b/test/shell/integrity-blocksize-2.sh new file mode 100644 index 000000000..a7bb71f9a --- /dev/null +++ b/test/shell/integrity-blocksize-2.sh @@ -0,0 +1,127 @@ +#!/usr/bin/env bash + +# Copyright (C) 2018 Red Hat, Inc. All rights reserved. +# +# This copyrighted material is made available to anyone wishing to use, +# modify, copy, or redistribute it subject to the terms and conditions +# of the GNU General Public License v.2. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +SKIP_WITH_LVMPOLLD=1 + +. lib/inittest + +aux have_integrity 1 5 0 || skip + +mnt="mnt" +mkdir -p $mnt + +_sync_percent() { + local checklv=$1 + get lv_field "$checklv" sync_percent | cut -d. -f1 +} + +_wait_recalc() { + local checklv=$1 + + for i in $(seq 1 10) ; do + sync=$(_sync_percent "$checklv") + echo "sync_percent is $sync" + + if test "$sync" = "100"; then + return + fi + + sleep 1 + done + + # TODO: There is some strange bug, first leg of RAID with integrity + # enabled never gets in sync. I saw this in BB, but not when executing + # the commands manually + if test -z "$sync"; then + echo "TEST WARNING: Resync of dm-integrity device '$checklv' failed" + dmsetup status "$DM_DEV_DIR/mapper/${checklv/\//-}" + exit + fi + echo "timeout waiting for recalc" + return 1 +} + +# prepare_devs uses ramdisk backing which has 512 LBS and 4K PBS +# This should cause mkfs.xfs to use 4K sector size, +# and integrity to use 4K block size +aux prepare_devs 2 64 + +vgcreate $vg "$dev1" "$dev2" +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# add integrity while LV is inactive +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvconvert --raidintegrity y $vg/$lv1 +lvchange -ay $vg +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +# FIXME: the second xfs mount fails related to block size and converting active LV, bug 1847180 +# add integrity while LV is active, fs unmounted +#lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +#lvchange -an $vg/$lv1 +#lvchange -ay $vg/$lv1 +#mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +#mount "$DM_DEV_DIR/$vg/$lv1" $mnt +#echo "hello world" > $mnt/hello +#umount $mnt +#lvchange -an $vg +#lvchange -ay $vg +#lvconvert --raidintegrity y $vg/$lv1 +#_wait_recalc $vg/${lv1}_rimage_0 +#_wait_recalc $vg/${lv1}_rimage_1 +#lvs -a -o+devices $vg +#mount "$DM_DEV_DIR/$vg/$lv1" $mnt +#cat $mnt/hello | grep "hello world" +#umount $mnt +#lvchange -an $vg/$lv1 +#lvremove $vg/$lv1 + +# add integrity while LV is active, fs mounted +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +vgremove -ff $vg + diff --git a/test/shell/integrity-blocksize-3.sh b/test/shell/integrity-blocksize-3.sh new file mode 100644 index 000000000..7170aa907 --- /dev/null +++ b/test/shell/integrity-blocksize-3.sh @@ -0,0 +1,284 @@ +#!/usr/bin/env bash + +# Copyright (C) 2018 Red Hat, Inc. All rights reserved. +# +# This copyrighted material is made available to anyone wishing to use, +# modify, copy, or redistribute it subject to the terms and conditions +# of the GNU General Public License v.2. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +SKIP_WITH_LVMPOLLD=1 + +. lib/inittest + +aux have_integrity 1 5 0 || skip + +mnt="mnt" +mkdir -p $mnt + +_sync_percent() { + local checklv=$1 + get lv_field "$checklv" sync_percent | cut -d. -f1 +} + +_wait_recalc() { + local checklv=$1 + + for i in $(seq 1 10) ; do + sync=$(_sync_percent "$checklv") + echo "sync_percent is $sync" + + if test "$sync" = "100"; then + return + fi + + sleep 1 + done + + # TODO: There is some strange bug, first leg of RAID with integrity + # enabled never gets in sync. I saw this in BB, but not when executing + # the commands manually + if test -z "$sync"; then + echo "TEST WARNING: Resync of dm-integrity device '$checklv' failed" + dmsetup status "$DM_DEV_DIR/mapper/${checklv/\//-}" + exit + fi + echo "timeout waiting for recalc" + return 1 +} + +# scsi_debug devices with 512 LBS 512 PBS +aux prepare_scsi_debug_dev 256 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "512" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "512" +aux prepare_devs 2 64 + +vgcreate $vg "$dev1" "$dev2" +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# add integrity while LV is inactive +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvconvert --raidintegrity y $vg/$lv1 +lvchange -ay $vg +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +# add integrity while LV is active, fs unmounted +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvchange -ay $vg +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +# add integrity while LV is active, fs mounted +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +vgremove -ff $vg +aux cleanup_scsi_debug_dev +sleep 1 + +# scsi_debug devices with 4K LBS and 4K PBS +aux prepare_scsi_debug_dev 256 sector_size=4096 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "4096" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "4096" +aux prepare_devs 2 64 + +vgcreate $vg "$dev1" "$dev2" +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# add integrity while LV is inactive +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvconvert --raidintegrity y $vg/$lv1 +lvchange -ay $vg +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +# add integrity while LV is active, fs unmounted +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvchange -ay $vg +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +# add integrity while LV is active, fs mounted +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +vgremove -ff $vg +aux cleanup_scsi_debug_dev +sleep 1 + +# scsi_debug devices with 512 LBS and 4K PBS +aux prepare_scsi_debug_dev 256 sector_size=512 physblk_exp=3 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "512" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "4096" +aux prepare_devs 2 64 + +vgcreate $vg "$dev1" "$dev2" +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# add integrity while LV is inactive +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +umount $mnt +lvchange -an $vg +lvconvert --raidintegrity y $vg/$lv1 +lvchange -ay $vg +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +# FIXME: second xfs mount fails related to block size and converting active LV, bug 1847180 +# add integrity while LV is active, fs unmounted +#lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +#lvchange -an $vg/$lv1 +#lvchange -ay $vg/$lv1 +#mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +#mount "$DM_DEV_DIR/$vg/$lv1" $mnt +#echo "hello world" > $mnt/hello +#umount $mnt +#lvchange -an $vg +#lvchange -ay $vg +#lvconvert --raidintegrity y $vg/$lv1 +#_wait_recalc $vg/${lv1}_rimage_0 +#_wait_recalc $vg/${lv1}_rimage_1 +#lvs -a -o+devices $vg +#mount "$DM_DEV_DIR/$vg/$lv1" $mnt +#cat $mnt/hello | grep "hello world" +#umount $mnt +#lvchange -an $vg/$lv1 +#lvremove $vg/$lv1 + +# add integrity while LV is active, fs mounted +lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +echo "hello world" > $mnt/hello +lvconvert --raidintegrity y $vg/$lv1 +_wait_recalc $vg/${lv1}_rimage_0 +_wait_recalc $vg/${lv1}_rimage_1 +lvs -a -o+devices $vg +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvchange -ay $vg/$lv1 +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +cat $mnt/hello | grep "hello world" +umount $mnt +lvchange -an $vg/$lv1 +lvremove $vg/$lv1 + +vgremove -ff $vg +aux cleanup_scsi_debug_dev +sleep 1 + diff --git a/test/shell/integrity-blocksize.sh b/test/shell/integrity-blocksize.sh index 8c4b94d49..a829502d1 100644 --- a/test/shell/integrity-blocksize.sh +++ b/test/shell/integrity-blocksize.sh @@ -54,6 +54,18 @@ mkdir -p $mnt vgcreate $vg1 $LOOP1 $LOOP2 vgcreate $vg2 $LOOP3 $LOOP4 +# LOOP1/LOOP2 have LBS 512 and PBS 512 +# LOOP3/LOOP4 have LBS 4K and PBS 4K + +blockdev --getss $LOOP1 +blockdev --getpbsz $LOOP1 +blockdev --getss $LOOP2 +blockdev --getpbsz $LOOP2 +blockdev --getss $LOOP3 +blockdev --getpbsz $LOOP3 +blockdev --getss $LOOP4 +blockdev --getpbsz $LOOP4 + # lvcreate on dev512, result 512 lvcreate --type raid1 -m1 --raidintegrity y -l 8 -n $lv1 $vg1 pvck --dump metadata $LOOP1 | grep 'block_size = 512' @@ -164,18 +176,22 @@ umount $mnt pvck --dump metadata $LOOP1 | grep 'block_size = 512' lvremove -y $vg1/$lv1 -# FIXME: kernel error reported, disallow this combination? +# FIXME: if lv is active while integrity is added, then xfs mount fails related to block size, bug 1847180 # lvconvert --bs 1024 on dev512, xfs 4096, result 1024 -#lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 -#aux wipefs_a /dev/$vg1/$lv1 -#mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg1/$lv1" -#blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" -#lvconvert --raidintegrity y --raidintegrityblocksize 1024 $vg1/$lv1 -#blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" -#mount "$DM_DEV_DIR/$vg1/$lv1" $mnt -#umount $mnt -#pvck --dump metadata $LOOP1 | grep 'block_size = 1024' -#lvremove -y $vg1/$lv1 +lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 +aux wipefs_a /dev/$vg1/$lv1 +mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg1/$lv1" +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" +# TODO: also test adding integrity when the lv is active, +# and also when the lv is active and fs is mounted? +lvchange -an $vg1/$lv1 +lvconvert --raidintegrity y --raidintegrityblocksize 1024 $vg1/$lv1 +lvchange -ay $vg1/$lv1 +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +umount $mnt +pvck --dump metadata $LOOP1 | grep 'block_size = 1024' +lvremove -y $vg1/$lv1 # lvconvert --bs 512 on dev512, ext4 1024, result 512 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 @@ -196,10 +212,10 @@ mkfs.ext4 "$DM_DEV_DIR/$vg2/$lv1" not lvconvert --raidintegrity y --raidintegrityblocksize 512 $vg2/$lv1 lvremove -y $vg2/$lv1 -# FIXME: need to use scsi_debug to create devs with LBS 512 PBS 4k -# FIXME: lvconvert, fsunknown, LBS 512, PBS 4k: result 512 -# FIXME: lvconvert --bs 512, fsunknown, LBS 512, PBS 4k: result 512 -# FIXME: lvconvert --bs 4k, fsunknown, LBS 512, PBS 4k: result 4k +# TODO: need to use scsi_debug to create devs with LBS 512 PBS 4k +# TODO: lvconvert, fsunknown, LBS 512, PBS 4k: result 512 +# TODO: lvconvert --bs 512, fsunknown, LBS 512, PBS 4k: result 512 +# TODO: lvconvert --bs 4k, fsunknown, LBS 512, PBS 4k: result 4k # lvconvert on dev512, xfs 512, result 512, (detect fs with LV inactive) lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 diff --git a/test/shell/integrity-large.sh b/test/shell/integrity-large.sh index 5aba80e6a..016d100d9 100644 --- a/test/shell/integrity-large.sh +++ b/test/shell/integrity-large.sh @@ -115,7 +115,10 @@ lvcreate --type raid1 -m1 -n $lv1 -l 8 $vg lvchange -an $vg/$lv1 lvchange -ay $vg/$lv1 _add_data_to_lv +lvchange -an $vg/$lv1 +# FIXME: if lv remains active during convert, then xfs mount fails related to block size, bug 1847180 lvconvert --raidintegrity y $vg/$lv1 +lvchange -ay $vg/$lv1 _wait_recalc $vg/${lv1}_rimage_0 _wait_recalc $vg/${lv1}_rimage_1 lvs -a -o+devices $vg

1 0

master - improve get_fs_block_size string to number
by David Teigland 11 Jun '20

11 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=8e2938c963bb8226b7229… Commit: 8e2938c963bb8226b72297647bef89895e5ae548 Parent: 9f38e95a2f84f148dae1a8ec440adc29eb12d513 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jun 11 15:05:47 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Thu Jun 11 15:05:47 2020 -0500 improve get_fs_block_size string to number --- lib/device/dev-type.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/lib/device/dev-type.c b/lib/device/dev-type.c index e3fa9babb..896821de8 100644 --- a/lib/device/dev-type.c +++ b/lib/device/dev-type.c @@ -650,11 +650,9 @@ out: int get_fs_block_size(struct device *dev, uint32_t *fs_block_size) { char *block_size_str = NULL; - uint64_t block_size_val; if ((block_size_str = blkid_get_tag_value(NULL, "BLOCK_SIZE", dev_name(dev)))) { - block_size_val = strtoull(block_size_str, NULL, 10); - *fs_block_size = (uint32_t)block_size_val; + *fs_block_size = (uint32_t)atoi(block_size_str); free(block_size_str); log_debug("Found blkid BLOCK_SIZE %u for fs on %s", *fs_block_size, dev_name(dev)); return 1;

1 0

master - tests: fix typo in writecache-blocksize
by David Teigland 11 Jun '20

11 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=9f38e95a2f84f148dae1a… Commit: 9f38e95a2f84f148dae1a8ec440adc29eb12d513 Parent: f32e85ae519d9c278d7e76329438f976e91ac317 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jun 11 13:15:38 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Thu Jun 11 13:15:38 2020 -0500 tests: fix typo in writecache-blocksize --- test/shell/writecache-blocksize.sh | 1 - 1 file changed, 1 deletion(-) diff --git a/test/shell/writecache-blocksize.sh b/test/shell/writecache-blocksize.sh index 42c963c29..13001760a 100644 --- a/test/shell/writecache-blocksize.sh +++ b/test/shell/writecache-blocksize.sh @@ -264,7 +264,6 @@ blockdev --getpbsz "$dev2" # lbs 512, pbs 4k, xfs 4k, wc 4k vgcreate $SHARED $vg "$dev1" -vgcreate $SHARED $vg "$dev1" vgextend $vg "$dev2" lvcreate -n $lv1 -l 8 -an $vg "$dev1" lvcreate -n $lv2 -l 4 -an $vg "$dev2"

1 0

master - tests: expand integrity-blocksize
by David Teigland 11 Jun '20

11 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=f32e85ae519d9c278d7e7… Commit: f32e85ae519d9c278d7e76329438f976e91ac317 Parent: b528a9ce9060ed8d66466f7df86c0eafa7c94ec8 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jun 11 12:46:47 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Thu Jun 11 12:46:47 2020 -0500 tests: expand integrity-blocksize --- test/shell/integrity-blocksize.sh | 82 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 76 insertions(+), 6 deletions(-) diff --git a/test/shell/integrity-blocksize.sh b/test/shell/integrity-blocksize.sh index 444e3db4c..8c4b94d49 100644 --- a/test/shell/integrity-blocksize.sh +++ b/test/shell/integrity-blocksize.sh @@ -48,6 +48,9 @@ aux extend_filter "a|$LOOP4|" aux lvmconf 'devices/scan = "/dev"' +mnt="mnt" +mkdir -p $mnt + vgcreate $vg1 $LOOP1 $LOOP2 vgcreate $vg2 $LOOP3 $LOOP4 @@ -105,7 +108,11 @@ lvremove -y $vg2/$lv1 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 aux wipefs_a /dev/$vg1/$lv1 mkfs.xfs -f "$DM_DEV_DIR/$vg1/$lv1" +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"512\" lvconvert --raidintegrity y $vg1/$lv1 +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"512\" +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +umount $mnt pvck --dump metadata $LOOP1 | grep 'block_size = 512' lvremove -y $vg1/$lv1 @@ -113,7 +120,11 @@ lvremove -y $vg1/$lv1 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg2 aux wipefs_a /dev/$vg2/$lv1 mkfs.xfs -f "$DM_DEV_DIR/$vg2/$lv1" +blkid "$DM_DEV_DIR/$vg2/$lv1" | grep BLOCK_SIZE=\"4096\" lvconvert --raidintegrity y $vg2/$lv1 +blkid "$DM_DEV_DIR/$vg2/$lv1" | grep BLOCK_SIZE=\"4096\" +mount "$DM_DEV_DIR/$vg2/$lv1" $mnt +umount $mnt pvck --dump metadata $LOOP3 | grep 'block_size = 4096' lvremove -y $vg2/$lv1 @@ -121,7 +132,11 @@ lvremove -y $vg2/$lv1 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 aux wipefs_a /dev/$vg1/$lv1 mkfs.ext4 -b 1024 "$DM_DEV_DIR/$vg1/$lv1" +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"1024\" lvconvert --raidintegrity y $vg1/$lv1 +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"1024\" +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +umount $mnt pvck --dump metadata $LOOP1 | grep 'block_size = 1024' lvremove -y $vg1/$lv1 @@ -129,7 +144,11 @@ lvremove -y $vg1/$lv1 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg2 aux wipefs_a /dev/$vg2/$lv1 mkfs.ext4 "$DM_DEV_DIR/$vg2/$lv1" +blkid "$DM_DEV_DIR/$vg2/$lv1" | grep BLOCK_SIZE=\"4096\" lvconvert --raidintegrity y $vg2/$lv1 +blkid "$DM_DEV_DIR/$vg2/$lv1" | grep BLOCK_SIZE=\"4096\" +mount "$DM_DEV_DIR/$vg2/$lv1" $mnt +umount $mnt pvck --dump metadata $LOOP3 | grep 'block_size = 4096' lvremove -y $vg2/$lv1 @@ -137,23 +156,36 @@ lvremove -y $vg2/$lv1 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 aux wipefs_a /dev/$vg1/$lv1 mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg1/$lv1" +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" lvconvert --raidintegrity y --raidintegrityblocksize 512 $vg1/$lv1 +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +umount $mnt pvck --dump metadata $LOOP1 | grep 'block_size = 512' lvremove -y $vg1/$lv1 +# FIXME: kernel error reported, disallow this combination? # lvconvert --bs 1024 on dev512, xfs 4096, result 1024 -lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 -aux wipefs_a /dev/$vg1/$lv1 -mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg1/$lv1" -lvconvert --raidintegrity y --raidintegrityblocksize 1024 $vg1/$lv1 -pvck --dump metadata $LOOP1 | grep 'block_size = 1024' -lvremove -y $vg1/$lv1 +#lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 +#aux wipefs_a /dev/$vg1/$lv1 +#mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg1/$lv1" +#blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" +#lvconvert --raidintegrity y --raidintegrityblocksize 1024 $vg1/$lv1 +#blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"4096\" +#mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +#umount $mnt +#pvck --dump metadata $LOOP1 | grep 'block_size = 1024' +#lvremove -y $vg1/$lv1 # lvconvert --bs 512 on dev512, ext4 1024, result 512 lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 aux wipefs_a /dev/$vg1/$lv1 mkfs.ext4 -b 1024 "$DM_DEV_DIR/$vg1/$lv1" +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"1024\" lvconvert --raidintegrity y --raidintegrityblocksize 512 $vg1/$lv1 +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"1024\" +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +umount $mnt pvck --dump metadata $LOOP1 | grep 'block_size = 512' lvremove -y $vg1/$lv1 @@ -169,6 +201,44 @@ lvremove -y $vg2/$lv1 # FIXME: lvconvert --bs 512, fsunknown, LBS 512, PBS 4k: result 512 # FIXME: lvconvert --bs 4k, fsunknown, LBS 512, PBS 4k: result 4k +# lvconvert on dev512, xfs 512, result 512, (detect fs with LV inactive) +lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg1 +aux wipefs_a /dev/$vg1/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg1/$lv1" +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +echo "test" > $mnt/test +umount $mnt +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"512\" +lvchange -an $vg1/$lv1 +lvconvert --raidintegrity y $vg1/$lv1 +lvchange -ay $vg1/$lv1 +mount "$DM_DEV_DIR/$vg1/$lv1" $mnt +cat $mnt/test +umount $mnt +blkid "$DM_DEV_DIR/$vg1/$lv1" | grep BLOCK_SIZE=\"512\" +pvck --dump metadata $LOOP1 | grep 'block_size = 512' +lvchange -an $vg1/$lv1 +lvremove -y $vg1/$lv1 + +# lvconvert on dev4k, xfs 4096, result 4096 (detect fs with LV inactive) +lvcreate --type raid1 -m1 -l 8 -n $lv1 $vg2 +aux wipefs_a /dev/$vg2/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg2/$lv1" +mount "$DM_DEV_DIR/$vg2/$lv1" $mnt +echo "test" > $mnt/test +umount $mnt +blkid "$DM_DEV_DIR/$vg2/$lv1" | grep BLOCK_SIZE=\"4096\" +lvchange -an $vg2/$lv1 +lvconvert --raidintegrity y $vg2/$lv1 +lvchange -ay $vg2/$lv1 +mount "$DM_DEV_DIR/$vg2/$lv1" $mnt +cat $mnt/test +umount $mnt +blkid "$DM_DEV_DIR/$vg2/$lv1" | grep BLOCK_SIZE=\"4096\" +pvck --dump metadata $LOOP3 | grep 'block_size = 4096' +lvchange -an $vg2/$lv1 +lvremove -y $vg2/$lv1 + vgremove -ff $vg1 vgremove -ff $vg2

1 0

master - integrity: fix block size check when inactive
by David Teigland 11 Jun '20

11 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=b528a9ce9060ed8d66466… Commit: b528a9ce9060ed8d66466f7df86c0eafa7c94ec8 Parent: 9fbad5bb0fdc7d9a9dca8539e4cd217c5ef1fede Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jun 11 12:43:52 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Thu Jun 11 12:43:52 2020 -0500 integrity: fix block size check when inactive Checking fs block size requires the LV to be active. --- lib/metadata/integrity_manip.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/lib/metadata/integrity_manip.c b/lib/metadata/integrity_manip.c index 7942be0d6..790642dbb 100644 --- a/lib/metadata/integrity_manip.c +++ b/lib/metadata/integrity_manip.c @@ -587,13 +587,33 @@ int lv_add_integrity_to_raid(struct logical_volume *lv, struct integrity_setting } } + if (!is_active) { + /* checking block size of fs on the lv requires the lv to be active */ + if (!activate_lv(cmd, lv)) { + log_error("Failed to activate LV to check block size %s", display_lvname(lv)); + goto bad; + } + if (!sync_local_dev_names(cmd)) + stack; + } + /* * Set settings->block_size which will be copied to segment settings below. * integrity block size chosen based on device logical block size and * file system block size. */ - if (!_set_integrity_block_size(cmd, lv, settings, lbs_4k, lbs_512, pbs_4k, pbs_512)) + if (!_set_integrity_block_size(cmd, lv, settings, lbs_4k, lbs_512, pbs_4k, pbs_512)) { + if (!is_active && !deactivate_lv(cmd, lv)) + stack; goto_bad; + } + + if (!is_active) { + if (!deactivate_lv(cmd, lv)) { + log_error("Failed to deactivate LV after checking block size %s", display_lvname(lv)); + goto bad; + } + } /* * For each rimage, move its segments to a new rimage_iorig and give

1 0

master - fix libblkid BLOCK_SIZE check
by David Teigland 11 Jun '20

11 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=9fbad5bb0fdc7d9a9dca8… Commit: 9fbad5bb0fdc7d9a9dca8539e4cd217c5ef1fede Parent: 6ea3654868e3727b9197113f973e1c7edeed38b2 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Thu Jun 11 12:43:07 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Thu Jun 11 12:43:07 2020 -0500 fix libblkid BLOCK_SIZE check --- lib/device/dev-type.c | 36 ++++++++++++------------------------ 1 file changed, 12 insertions(+), 24 deletions(-) diff --git a/lib/device/dev-type.c b/lib/device/dev-type.c index deb5d6a0f..e3fa9babb 100644 --- a/lib/device/dev-type.c +++ b/lib/device/dev-type.c @@ -649,37 +649,25 @@ out: #ifdef BLKID_WIPING_SUPPORT int get_fs_block_size(struct device *dev, uint32_t *fs_block_size) { - blkid_probe probe = NULL; - const char *block_size_str = NULL; + char *block_size_str = NULL; uint64_t block_size_val; - int r = 0; - *fs_block_size = 0; - - if (!(probe = blkid_new_probe_from_filename(dev_name(dev)))) { - log_error("Failed to create a new blkid probe for device %s.", dev_name(dev)); - goto out; + if ((block_size_str = blkid_get_tag_value(NULL, "BLOCK_SIZE", dev_name(dev)))) { + block_size_val = strtoull(block_size_str, NULL, 10); + *fs_block_size = (uint32_t)block_size_val; + free(block_size_str); + log_debug("Found blkid BLOCK_SIZE %u for fs on %s", *fs_block_size, dev_name(dev)); + return 1; + } else { + log_debug("No blkid BLOCK_SIZE for fs on %s", dev_name(dev)); + *fs_block_size = 0; + return 0; } - - blkid_probe_enable_partitions(probe, 1); - - (void) blkid_probe_lookup_value(probe, "BLOCK_SIZE", &block_size_str, NULL); - - if (!block_size_str) - goto out; - - block_size_val = strtoull(block_size_str, NULL, 10); - - *fs_block_size = (uint32_t)block_size_val; - r = 1; -out: - if (probe) - blkid_free_probe(probe); - return r; } #else int get_fs_block_size(struct device *dev, uint32_t *fs_block_size) { + log_debug("Disabled blkid BLOCK_SIZE for fs."); *fs_block_size = 0; return 0; }

1 0

master - tests: writecache tests
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=6ea3654868e3727b91971… Commit: 6ea3654868e3727b9197113f973e1c7edeed38b2 Parent: ba27b9ee2a67d189a56827774001436556cae8a5 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Jun 10 16:08:28 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 16:09:36 2020 -0500 tests: writecache tests backport updates from later commits --- test/shell/writecache-large.sh | 153 ++++++++++++++++++++ test/shell/writecache-split.sh | 1 - test/shell/writecache.sh | 315 +++++++++++++++++++++++++++-------------- 3 files changed, 360 insertions(+), 109 deletions(-) diff --git a/test/shell/writecache-large.sh b/test/shell/writecache-large.sh new file mode 100644 index 000000000..b52eaf6ab --- /dev/null +++ b/test/shell/writecache-large.sh @@ -0,0 +1,153 @@ +#!/usr/bin/env bash + +# Copyright (C) 2018 Red Hat, Inc. All rights reserved. +# +# This copyrighted material is made available to anyone wishing to use, +# modify, copy, or redistribute it subject to the terms and conditions +# of the GNU General Public License v.2. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +# Test writecache usage + +SKIP_WITH_LVMPOLLD=1 + +. lib/inittest + +aux have_writecache 1 0 0 || skip +which mkfs.xfs || skip + +# scsi_debug devices with 512 LBS 512 PBS +aux prepare_scsi_debug_dev 1200 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "512" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "512" + +aux prepare_devs 2 600 +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +mnt="mnt" +mkdir -p $mnt + +for i in `seq 1 16384`; do echo -n "A" >> fileA; done +for i in `seq 1 16384`; do echo -n "B" >> fileB; done +for i in `seq 1 16384`; do echo -n "C" >> fileC; done + +# generate random data +dd if=/dev/urandom of=randA bs=512K count=2 +dd if=/dev/urandom of=randB bs=512K count=3 +dd if=/dev/urandom of=randC bs=512K count=4 + +_add_new_data_to_mnt() { + mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" + + mount "$DM_DEV_DIR/$vg/$lv1" $mnt + + # add original data + cp randA $mnt + cp randB $mnt + cp randC $mnt + mkdir $mnt/1 + cp fileA $mnt/1 + cp fileB $mnt/1 + cp fileC $mnt/1 + mkdir $mnt/2 + cp fileA $mnt/2 + cp fileB $mnt/2 + cp fileC $mnt/2 + sync +} + +_add_more_data_to_mnt() { + mkdir $mnt/more + cp fileA $mnt/more + cp fileB $mnt/more + cp fileC $mnt/more + cp randA $mnt/more + cp randB $mnt/more + cp randC $mnt/more + sync +} + +_verify_data_on_mnt() { + diff randA $mnt/randA + diff randB $mnt/randB + diff randC $mnt/randC + diff fileA $mnt/1/fileA + diff fileB $mnt/1/fileB + diff fileC $mnt/1/fileC + diff fileA $mnt/2/fileA + diff fileB $mnt/2/fileB + diff fileC $mnt/2/fileC +} + +_verify_more_data_on_mnt() { + diff randA $mnt/more/randA + diff randB $mnt/more/randB + diff randC $mnt/more/randC + diff fileA $mnt/more/fileA + diff fileB $mnt/more/fileB + diff fileC $mnt/more/fileC +} + +_verify_data_on_lv() { + lvchange -ay $vg/$lv1 + mount "$DM_DEV_DIR/$vg/$lv1" $mnt + _verify_data_on_mnt + rm $mnt/randA + rm $mnt/randB + rm $mnt/randC + rm -rf $mnt/1 + rm -rf $mnt/2 + umount $mnt + lvchange -an $vg/$lv1 +} + +vgcreate $SHARED $vg "$dev1" +vgextend $vg "$dev2" + +# Use a large enough size so that the cleaner will not +# finish immediately when detaching, and will require +# a secondary check from command top level. + +lvcreate -n $lv1 -L 560M -an $vg "$dev1" +lvcreate -n $lv2 -L 500M -an $vg "$dev2" + +lvchange -ay $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" + +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +dmsetup table $vg-$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" + +_add_new_data_to_mnt +_add_more_data_to_mnt +_verify_data_on_mnt + +dd if=/dev/zero of=$mnt/big1 bs=1M count=100 oflag=sync +dd if=/dev/zero of=$mnt/big2 bs=1M count=100 oflag=sync +dd if=/dev/zero of=$mnt/big3 bs=1M count=100 oflag=sync +dd if=/dev/zero of=$mnt/big4 bs=1M count=100 oflag=sync + +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +dmsetup table $vg-$lv1 +_verify_data_on_mnt +_verify_more_data_on_mnt +dd if=$mnt/big4 of=/dev/null bs=1M count=100 +umount $mnt +lvchange -an $vg/$lv1 +_verify_data_on_lv +lvchange -an $vg/$lv2 +lvremove $vg/$lv1 +lvremove $vg/$lv2 + +vgremove -ff $vg + diff --git a/test/shell/writecache-split.sh b/test/shell/writecache-split.sh index 9553ade0c..e615e2a13 100644 --- a/test/shell/writecache-split.sh +++ b/test/shell/writecache-split.sh @@ -84,7 +84,6 @@ lvconvert --splitcache $vg/$lv1 lvs -o segtype $vg/$lv1 | grep linear lvs -o segtype $vg/$lv2 | grep linear -lvchange -ay $vg/$lv1 mount_umount $lv1 lvchange -an $vg/$lv1 diff --git a/test/shell/writecache.sh b/test/shell/writecache.sh index 8852e93f4..39ef31930 100644 --- a/test/shell/writecache.sh +++ b/test/shell/writecache.sh @@ -19,152 +19,251 @@ SKIP_WITH_LVMPOLLD=1 aux have_writecache 1 0 0 || skip which mkfs.xfs || skip -mount_dir="mnt" -mkdir -p $mount_dir +# scsi_debug devices with 512 LBS 512 PBS +aux prepare_scsi_debug_dev 256 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "512" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "512" +aux prepare_devs 2 64 + +# scsi_debug devices with 512 LBS and 4K PBS +#aux prepare_scsi_debug_dev 256 sector_size=512 physblk_exp=3 +#check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "512" +#check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "4096" +#aux prepare_devs 2 64 + +# loop devs with 512 LBS and 512 PBS +#dd if=/dev/zero of=loopa bs=$((1024*1024)) count=64 2> /dev/null +#dd if=/dev/zero of=loopb bs=$((1024*1024)) count=64 2> /dev/null +#LOOP1=$(losetup -f loopa --show) +#LOOP2=$(losetup -f loopb --show) +#aux extend_filter "a|$LOOP1|" +#aux extend_filter "a|$LOOP2|" +#aux lvmconf 'devices/scan = "/dev"' +#dev1=$LOOP1 +#dev2=$LOOP2 + +# loop devs with 4096 LBS and 4096 PBS +#dd if=/dev/zero of=loopa bs=$((1024*1024)) count=64 2> /dev/null +#dd if=/dev/zero of=loopb bs=$((1024*1024)) count=64 2> /dev/null +#LOOP1=$(losetup -f loopa --sector-size 4096 --show) +#LOOP2=$(losetup -f loopb --sector-size 4096 --show) +#aux extend_filter "a|$LOOP1|" +#aux extend_filter "a|$LOOP2|" +#aux lvmconf 'devices/scan = "/dev"' +#dev1=$LOOP1 +#dev2=$LOOP2 + +# the default is brd ram devs with 512 LBS 4K PBS +# aux prepare_devs 2 64 + +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + + +mnt="mnt" +mkdir -p $mnt + +for i in `seq 1 16384`; do echo -n "A" >> fileA; done +for i in `seq 1 16384`; do echo -n "B" >> fileB; done +for i in `seq 1 16384`; do echo -n "C" >> fileC; done # generate random data -dd if=/dev/urandom of=pattern1 bs=512K count=1 +dd if=/dev/urandom of=randA bs=512K count=2 +dd if=/dev/urandom of=randB bs=512K count=3 +dd if=/dev/urandom of=randC bs=512K count=4 + +_add_new_data_to_mnt() { + mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" + + mount "$DM_DEV_DIR/$vg/$lv1" $mnt + + # add original data + cp randA $mnt + cp randB $mnt + cp randC $mnt + mkdir $mnt/1 + cp fileA $mnt/1 + cp fileB $mnt/1 + cp fileC $mnt/1 + mkdir $mnt/2 + cp fileA $mnt/2 + cp fileB $mnt/2 + cp fileC $mnt/2 + sync +} + +_add_more_data_to_mnt() { + mkdir $mnt/more + cp fileA $mnt/more + cp fileB $mnt/more + cp fileC $mnt/more + cp randA $mnt/more + cp randB $mnt/more + cp randC $mnt/more + sync +} + +_verify_data_on_mnt() { + diff randA $mnt/randA + diff randB $mnt/randB + diff randC $mnt/randC + diff fileA $mnt/1/fileA + diff fileB $mnt/1/fileB + diff fileC $mnt/1/fileC + diff fileA $mnt/2/fileA + diff fileB $mnt/2/fileB + diff fileC $mnt/2/fileC +} + +_verify_more_data_on_mnt() { + diff randA $mnt/more/randA + diff randB $mnt/more/randB + diff randC $mnt/more/randC + diff fileA $mnt/more/fileA + diff fileB $mnt/more/fileB + diff fileC $mnt/more/fileC +} + +_verify_data_on_lv() { + lvchange -ay $vg/$lv1 + mount "$DM_DEV_DIR/$vg/$lv1" $mnt + _verify_data_on_mnt + rm $mnt/randA + rm $mnt/randB + rm $mnt/randC + rm -rf $mnt/1 + rm -rf $mnt/2 + umount $mnt + lvchange -an $vg/$lv1 +} -aux prepare_devs 2 64 vgcreate $SHARED $vg "$dev1" - vgextend $vg "$dev2" -lvcreate -n $lv1 -l 8 -an $vg "$dev1" - -lvcreate -n $lv2 -l 4 -an $vg "$dev2" +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" -# test1: create fs on LV before writecache is attached +# Test attach while inactive, detach while inactive +# create fs on LV before writecache is attached +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" lvchange -ay $vg/$lv1 - -mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg/$lv1" - -mount "$DM_DEV_DIR/$vg/$lv1" $mount_dir - -cp pattern1 $mount_dir/pattern1 - -umount $mount_dir +_add_new_data_to_mnt +umount $mnt lvchange -an $vg/$lv1 - lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 - check lv_field $vg/$lv1 segtype writecache - lvs -a $vg/${lv2}_cvol --noheadings -o segtype >out grep linear out - lvchange -ay $vg/$lv1 - -mount "$DM_DEV_DIR/$vg/$lv1" $mount_dir - -diff pattern1 $mount_dir/pattern1 - -cp pattern1 $mount_dir/pattern1b - -ls -l $mount_dir - -umount $mount_dir - +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +_add_more_data_to_mnt +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt lvchange -an $vg/$lv1 - lvconvert --splitcache $vg/$lv1 - check lv_field $vg/$lv1 segtype linear check lv_field $vg/$lv2 segtype linear - lvchange -ay $vg/$lv1 -lvchange -ay $vg/$lv2 - -mount "$DM_DEV_DIR/$vg/$lv1" $mount_dir - -ls -l $mount_dir - -diff pattern1 $mount_dir/pattern1 -diff pattern1 $mount_dir/pattern1b - -umount $mount_dir +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" lvchange -an $vg/$lv1 +_verify_data_on_lv lvchange -an $vg/$lv2 +lvremove $vg/$lv1 +lvremove $vg/$lv2 -# test2: create fs on LV after writecache is attached +# Test attach while inactive, detach while inactive +# create fs on LV after writecache is attached +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 - check lv_field $vg/$lv1 segtype writecache - lvs -a $vg/${lv2}_cvol --noheadings -o segtype >out grep linear out - lvchange -ay $vg/$lv1 - -mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg/$lv1" - -mount "$DM_DEV_DIR/$vg/$lv1" $mount_dir - -cp pattern1 $mount_dir/pattern1 -ls -l $mount_dir - -umount $mount_dir +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_new_data_to_mnt +umount $mnt lvchange -an $vg/$lv1 - lvconvert --splitcache $vg/$lv1 - -check lv_field $vg/$lv1 segtype linear -check lv_field $vg/$lv2 segtype linear - lvchange -ay $vg/$lv1 -lvchange -ay $vg/$lv2 - -mount "$DM_DEV_DIR/$vg/$lv1" $mount_dir - -ls -l $mount_dir - -diff pattern1 $mount_dir/pattern1 - -umount $mount_dir +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +mount "$DM_DEV_DIR/$vg/$lv1" $mnt +_add_more_data_to_mnt +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt lvchange -an $vg/$lv1 -lvchange -an $vg/$lv2 - - -# test3: attach writecache to an active LV - -lvchange -ay $vg/$lv1 - -mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg/$lv1" - -mount "$DM_DEV_DIR/$vg/$lv1" $mount_dir - -cp pattern1 $mount_dir/pattern1 -ls -l $mount_dir - -# TODO BZ 1808012 - can not convert active volume to writecache: -not lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 - -if false; then -check lv_field $vg/$lv1 segtype writecache - -lvs -a $vg/${lv2}_cvol --noheadings -o segtype >out -grep linear out - -cp pattern1 $mount_dir/pattern1.after +_verify_data_on_lv +lvremove $vg/$lv1 +lvremove $vg/$lv2 -diff pattern1 $mount_dir/pattern1 -diff pattern1 $mount_dir/pattern1.after +# Test attach while active, detach while active -umount $mount_dir -lvchange -an $vg/$lv1 +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" lvchange -ay $vg/$lv1 -mount "$DM_DEV_DIR/$vg/$lv1" $mount_dir - -diff pattern1 $mount_dir/pattern1 -diff pattern1 $mount_dir/pattern1.after -fi - -umount $mount_dir +_add_new_data_to_mnt +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_more_data_to_mnt +_verify_data_on_mnt +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt lvchange -an $vg/$lv1 +lvchange -an $vg/$lv2 +_verify_data_on_lv lvremove $vg/$lv1 +lvremove $vg/$lv2 +# FIXME: test depends on unpushed commit +# that enables two stage flush using cleaner +# +# Test attach while active, detach while active, +# skip cleaner so flush message is used instead +# +# lvcreate -n $lv1 -l 8 -an $vg "$dev1" +# lvcreate -n $lv2 -l 4 -an $vg "$dev2" +# lvchange -ay $vg/$lv1 +# _add_new_data_to_mnt +# lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +# blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +# blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +# _add_more_data_to_mnt +# _verify_data_on_mnt +# lvconvert --splitcache --cachesettings cleaner=0 $vg/$lv1 +# check lv_field $vg/$lv1 segtype linear +# check lv_field $vg/$lv2 segtype linear +# blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +# blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +# _verify_data_on_mnt +# _verify_more_data_on_mnt +# umount $mnt +# lvchange -an $vg/$lv1 +# lvchange -an $vg/$lv2 +# _verify_data_on_lv +# lvremove $vg/$lv1 +# lvremove $vg/$lv2 + vgremove -ff $vg - +

1 0

master - writecache: activate to check block size
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=ba27b9ee2a67d189a5682… Commit: ba27b9ee2a67d189a56827774001436556cae8a5 Parent: 38eaa1035b13ba1633d0002fa53071d5b7098ef9 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Jun 10 15:58:25 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 15:58:25 2020 -0500 writecache: activate to check block size backport fixes from later commit --- tools/lvconvert.c | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) diff --git a/tools/lvconvert.c b/tools/lvconvert.c index b25fa1704..94ea70fa5 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -5352,7 +5352,7 @@ static int _lvconvert_detach_writecache(struct cmd_context *cmd, backup(lv->vg); - log_print_unless_silent("Logical volume %s write cache has been detached.", + log_print_unless_silent("Logical volume %s writecache has been detached.", display_lvname(lv)); return 1; } @@ -5499,14 +5499,17 @@ static int _set_writecache_block_size(struct cmd_context *cmd, goto_bad; } - if (dm_snprintf(pathname, sizeof(pathname), "%s%s/%s", cmd->dev_dir, + if (dm_snprintf(pathname, sizeof(pathname), "%s/%s/%s", cmd->dev_dir, lv->vg->name, lv->name) < 0) { log_error("Path name too long to get LV block size %s", display_lvname(lv)); goto_bad; } + if (!sync_local_dev_names(cmd)) + stack; + if (!(fs_dev = dev_cache_get(cmd, pathname, NULL))) { - log_error("Device for LV not found to check block size %s", display_lvname(lv)); + log_error("Device for LV not found to check block size %s", pathname); goto_bad; } @@ -5608,6 +5611,7 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, char *lockd_fast_name = NULL; struct id lockd_fast_id; char cvol_name[NAME_LEN]; + int is_active; fast_name = arg_str_value(cmd, cachevol_ARG, ""); @@ -5637,6 +5641,8 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, goto bad; } + is_active = lv_is_active(lv); + memset(&settings, 0, sizeof(settings)); if (!get_writecache_settings(cmd, &settings, &block_size_sectors)) { @@ -5644,8 +5650,26 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, goto bad; } - if (!_set_writecache_block_size(cmd, lv, &block_size_sectors)) + if (!is_active) { + /* checking block size of fs on the lv requires the lv to be active */ + if (!activate_lv(cmd, lv)) { + log_error("Failed to activate LV to check block size %s", display_lvname(lv)); + goto bad; + } + } + + if (!_set_writecache_block_size(cmd, lv, &block_size_sectors)) { + if (!is_active && !deactivate_lv(cmd, lv)) + stack; goto_bad; + } + + if (!is_active) { + if (!deactivate_lv(cmd, lv)) { + log_error("Failed to deactivate LV after checking block size %s", display_lvname(lv)); + goto bad; + } + } if (!arg_is_set(cmd, yes_ARG) && yes_no_prompt("Erase all existing data on %s? [y/n]: ", display_lvname(lv_fast)) == 'n') { @@ -5723,7 +5747,7 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, log_error("Failed to unlock fast LV %s/%s", vg->name, lockd_fast_name); } - log_print_unless_silent("Logical volume %s now has write cache.", + log_print_unless_silent("Logical volume %s now has writecache.", display_lvname(lv)); return ECMD_PROCESSED; bad:

1 0

master - writecache: allow snapshot of LV with writecache
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=38eaa1035b13ba1633d00… Commit: 38eaa1035b13ba1633d0002fa53071d5b7098ef9 Parent: 712c9efbf6104a863b610a006e72d7da8336fa7e Author: David Teigland <teigland(a)redhat.com> AuthorDate: Mon Apr 13 15:58:28 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:18:00 2020 -0500 writecache: allow snapshot of LV with writecache --- lib/metadata/snapshot_manip.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/lib/metadata/snapshot_manip.c b/lib/metadata/snapshot_manip.c index 3faea0eb8..0f48e62e8 100644 --- a/lib/metadata/snapshot_manip.c +++ b/lib/metadata/snapshot_manip.c @@ -389,8 +389,6 @@ int validate_snapshot_origin(const struct logical_volume *origin_lv) err = "raid subvolumes"; } else if (lv_is_raid(origin_lv) && lv_raid_has_integrity((struct logical_volume *)origin_lv)) { err = "raid with integrity"; - } else if (lv_is_writecache(origin_lv)) { - err = "writecache"; } if (err) {

1 0

master - fix bad result from _cache_min_metadata_size
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=712c9efbf6104a863b610… Commit: 712c9efbf6104a863b610a006e72d7da8336fa7e Parent: 48c1a295a294fefa0886885f13604f134ceaf406 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Fri Apr 10 16:57:12 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:17:34 2020 -0500 fix bad result from _cache_min_metadata_size fixes regression from switching to use _cache_min_metadata_size (commit c08704cee7e34a96fdaa453faf900683283e8691) which returns a bogus value when the cachevol size is 8MB. --- lib/metadata/cache_manip.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/lib/metadata/cache_manip.c b/lib/metadata/cache_manip.c index 49b385052..a786e8bac 100644 --- a/lib/metadata/cache_manip.c +++ b/lib/metadata/cache_manip.c @@ -1094,6 +1094,10 @@ int cache_vol_set_params(struct cmd_context *cmd, if (!meta_size) { meta_size = _cache_min_metadata_size(pool_lv->size, chunk_size); + /* fix bad value from _cache_min_metadata_size */ + if (meta_size > (pool_lv->size / 2)) + meta_size = pool_lv->size / 2; + if (meta_size < min_meta_size) meta_size = min_meta_size;

1 0

master - tests: writecache-blocksize
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=48c1a295a294fefa08868… Commit: 48c1a295a294fefa0886885f13604f134ceaf406 Parent: a7b2fc8f5791747ff3326997a07743eeebbd3ef7 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Apr 8 15:33:30 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:16:31 2020 -0500 tests: writecache-blocksize --- test/shell/writecache-blocksize.sh | 343 +++++++++++++++++++++++++++++++++++++ 1 file changed, 343 insertions(+) diff --git a/test/shell/writecache-blocksize.sh b/test/shell/writecache-blocksize.sh new file mode 100644 index 000000000..42c963c29 --- /dev/null +++ b/test/shell/writecache-blocksize.sh @@ -0,0 +1,343 @@ +#!/usr/bin/env bash + +# Copyright (C) 2018 Red Hat, Inc. All rights reserved. +# +# This copyrighted material is made available to anyone wishing to use, +# modify, copy, or redistribute it subject to the terms and conditions +# of the GNU General Public License v.2. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +# Test writecache usage + +SKIP_WITH_LVMPOLLD=1 + +. lib/inittest + +aux have_writecache 1 0 0 || skip +which mkfs.xfs || skip + +# Tests with fs block sizes require a libblkid version that shows BLOCK_SIZE +aux prepare_devs 1 +vgcreate $vg "$dev1" +lvcreate -n $lv1 -l8 $vg +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" +blkid "$DM_DEV_DIR/$vg/$lv1" | grep BLOCK_SIZE || skip +lvchange -an $vg +vgremove -ff $vg +aux cleanup_scsi_debug_dev + +mnt="mnt" +mkdir -p $mnt + +for i in `seq 1 16384`; do echo -n "A" >> fileA; done +for i in `seq 1 16384`; do echo -n "B" >> fileB; done +for i in `seq 1 16384`; do echo -n "C" >> fileC; done + +# generate random data +dd if=/dev/urandom of=randA bs=512K count=2 +dd if=/dev/urandom of=randB bs=512K count=3 +dd if=/dev/urandom of=randC bs=512K count=4 + +_add_new_data_to_mnt() { + mount "$DM_DEV_DIR/$vg/$lv1" $mnt + + # add original data + cp randA $mnt + cp randB $mnt + cp randC $mnt + mkdir $mnt/1 + cp fileA $mnt/1 + cp fileB $mnt/1 + cp fileC $mnt/1 + mkdir $mnt/2 + cp fileA $mnt/2 + cp fileB $mnt/2 + cp fileC $mnt/2 + sync +} + +_add_more_data_to_mnt() { + mkdir $mnt/more + cp fileA $mnt/more + cp fileB $mnt/more + cp fileC $mnt/more + cp randA $mnt/more + cp randB $mnt/more + cp randC $mnt/more + sync +} + +_verify_data_on_mnt() { + diff randA $mnt/randA + diff randB $mnt/randB + diff randC $mnt/randC + diff fileA $mnt/1/fileA + diff fileB $mnt/1/fileB + diff fileC $mnt/1/fileC + diff fileA $mnt/2/fileA + diff fileB $mnt/2/fileB + diff fileC $mnt/2/fileC +} + +_verify_more_data_on_mnt() { + diff randA $mnt/more/randA + diff randB $mnt/more/randB + diff randC $mnt/more/randC + diff fileA $mnt/more/fileA + diff fileB $mnt/more/fileB + diff fileC $mnt/more/fileC +} + +_verify_data_on_lv() { + lvchange -ay $vg/$lv1 + mount "$DM_DEV_DIR/$vg/$lv1" $mnt + _verify_data_on_mnt + rm $mnt/randA + rm $mnt/randB + rm $mnt/randC + rm -rf $mnt/1 + rm -rf $mnt/2 + umount $mnt + lvchange -an $vg/$lv1 +} + +# the default is brd ram devs with 512 LBS 4K PBS +aux prepare_devs 2 64 + +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# lbs 512, pbs 4k, xfs 4k, wc 4k +vgcreate $SHARED $vg "$dev1" +vgextend $vg "$dev2" +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" |tee out +grep sectsz=4096 out +_add_new_data_to_mnt +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" |tee out +grep 4096 out +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_more_data_to_mnt +_verify_data_on_mnt +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt +lvchange -an $vg/$lv1 +lvchange -an $vg/$lv2 +_verify_data_on_lv +lvremove $vg/$lv1 +lvremove $vg/$lv2 +vgremove $vg + +# lbs 512, pbs 4k, xfs -s 512, wc 512 +vgcreate $SHARED $vg "$dev1" +vgextend $vg "$dev2" +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" +lvchange -ay $vg/$lv1 +mkfs.xfs -f -s size=512 "$DM_DEV_DIR/$vg/$lv1" |tee out +grep sectsz=512 out +_add_new_data_to_mnt +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" |tee out +grep 512 out +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_more_data_to_mnt +_verify_data_on_mnt +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt +lvchange -an $vg/$lv1 +lvchange -an $vg/$lv2 +_verify_data_on_lv +lvremove $vg/$lv1 +lvremove $vg/$lv2 +vgremove $vg + +aux cleanup_scsi_debug_dev +sleep 1 + + +# scsi_debug devices with 512 LBS 512 PBS +aux prepare_scsi_debug_dev 256 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "512" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "512" +aux prepare_devs 2 64 + +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# lbs 512, pbs 512, xfs 512, wc 512 +vgcreate $SHARED $vg "$dev1" +vgextend $vg "$dev2" +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" |tee out +grep sectsz=512 out +_add_new_data_to_mnt +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" |tee out +grep 512 out +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_more_data_to_mnt +_verify_data_on_mnt +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt +lvchange -an $vg/$lv1 +lvchange -an $vg/$lv2 +_verify_data_on_lv +lvremove $vg/$lv1 +lvremove $vg/$lv2 +vgremove $vg + +# lbs 512, pbs 512, xfs -s 4096, wc 4096 +vgcreate $SHARED $vg "$dev1" +vgextend $vg "$dev2" +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" +lvchange -ay $vg/$lv1 +mkfs.xfs -s size=4096 -f "$DM_DEV_DIR/$vg/$lv1" |tee out +grep sectsz=4096 out +_add_new_data_to_mnt +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" |tee out +grep 4096 out +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_more_data_to_mnt +_verify_data_on_mnt +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt +lvchange -an $vg/$lv1 +lvchange -an $vg/$lv2 +_verify_data_on_lv +lvremove $vg/$lv1 +lvremove $vg/$lv2 +vgremove $vg + +aux cleanup_scsi_debug_dev +sleep 1 + + +# scsi_debug devices with 512 LBS and 4K PBS +aux prepare_scsi_debug_dev 256 sector_size=512 physblk_exp=3 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "512" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "4096" +aux prepare_devs 2 64 + +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# lbs 512, pbs 4k, xfs 4k, wc 4k +vgcreate $SHARED $vg "$dev1" +vgcreate $SHARED $vg "$dev1" +vgextend $vg "$dev2" +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" |tee out +grep sectsz=4096 out +_add_new_data_to_mnt +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" |tee out +grep 4096 out +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_more_data_to_mnt +_verify_data_on_mnt +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt +lvchange -an $vg/$lv1 +lvchange -an $vg/$lv2 +_verify_data_on_lv +lvremove $vg/$lv1 +lvremove $vg/$lv2 +vgremove $vg + +aux cleanup_scsi_debug_dev +sleep 1 + + +# scsi_debug devices with 4K LBS and 4K PBS +aux prepare_scsi_debug_dev 256 sector_size=4096 +check sysfs "$(< SCSI_DEBUG_DEV)" queue/logical_block_size "4096" +check sysfs "$(< SCSI_DEBUG_DEV)" queue/physical_block_size "4096" +aux prepare_devs 2 64 + +blockdev --getss "$dev1" +blockdev --getpbsz "$dev1" +blockdev --getss "$dev2" +blockdev --getpbsz "$dev2" + +# lbs 4k, pbs 4k, xfs 4k, wc 4k +vgcreate $SHARED $vg "$dev1" +vgextend $vg "$dev2" +lvcreate -n $lv1 -l 8 -an $vg "$dev1" +lvcreate -n $lv2 -l 4 -an $vg "$dev2" +lvchange -ay $vg/$lv1 +mkfs.xfs -f "$DM_DEV_DIR/$vg/$lv1" |tee out +grep sectsz=4096 out +_add_new_data_to_mnt +lvconvert --yes --type writecache --cachevol $lv2 $vg/$lv1 +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" |tee out +grep 4096 out +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_add_more_data_to_mnt +_verify_data_on_mnt +lvconvert --splitcache $vg/$lv1 +check lv_field $vg/$lv1 segtype linear +check lv_field $vg/$lv2 segtype linear +blockdev --getss "$DM_DEV_DIR/$vg/$lv1" +blockdev --getpbsz "$DM_DEV_DIR/$vg/$lv1" +_verify_data_on_mnt +_verify_more_data_on_mnt +umount $mnt +lvchange -an $vg/$lv1 +lvchange -an $vg/$lv2 +_verify_data_on_lv +lvremove $vg/$lv1 +lvremove $vg/$lv2 +vgremove $vg + +aux cleanup_scsi_debug_dev + +

1 0

master - writecache: add settings cleaner and max_age
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=a7b2fc8f5791747ff3326… Commit: a7b2fc8f5791747ff3326997a07743eeebbd3ef7 Parent: d15c466f9557004fa003b8986b82deca25cc5aaf Author: David Teigland <teigland(a)redhat.com> AuthorDate: Tue Mar 31 14:14:50 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:15:50 2020 -0500 writecache: add settings cleaner and max_age available in dm-writecache 1.2 --- device_mapper/all.h | 4 ++++ device_mapper/libdm-deptree.c | 12 ++++++++++ lib/metadata/writecache_manip.c | 8 +++++++ lib/report/report.c | 2 +- lib/writecache/writecache.c | 49 +++++++++++++++++++++++++++++++++++++++++ tools/lvchange.c | 10 +++++++++ tools/toollib.c | 14 ++++++++++++ 7 files changed, 98 insertions(+), 1 deletion(-) diff --git a/device_mapper/all.h b/device_mapper/all.h index f00b6a5dc..c3c6219e3 100644 --- a/device_mapper/all.h +++ b/device_mapper/all.h @@ -951,6 +951,8 @@ struct writecache_settings { uint64_t autocommit_time; /* in milliseconds */ uint32_t fua; uint32_t nofua; + uint32_t cleaner; + uint32_t max_age; /* * Allow an unrecognized key and its val to be passed to the kernel for @@ -970,6 +972,8 @@ struct writecache_settings { unsigned autocommit_time_set:1; unsigned fua_set:1; unsigned nofua_set:1; + unsigned cleaner_set:1; + unsigned max_age_set:1; }; int dm_tree_node_add_writecache_target(struct dm_tree_node *node, diff --git a/device_mapper/libdm-deptree.c b/device_mapper/libdm-deptree.c index 9ba24cbbf..2722a2c3b 100644 --- a/device_mapper/libdm-deptree.c +++ b/device_mapper/libdm-deptree.c @@ -2670,6 +2670,10 @@ static int _writecache_emit_segment_line(struct dm_task *dmt, count += 1; if (seg->writecache_settings.nofua_set) count += 1; + if (seg->writecache_settings.cleaner_set && seg->writecache_settings.cleaner) + count += 1; + if (seg->writecache_settings.max_age_set) + count += 2; if (seg->writecache_settings.new_key) count += 2; @@ -2713,6 +2717,14 @@ static int _writecache_emit_segment_line(struct dm_task *dmt, EMIT_PARAMS(pos, " nofua"); } + if (seg->writecache_settings.cleaner_set && seg->writecache_settings.cleaner) { + EMIT_PARAMS(pos, " cleaner"); + } + + if (seg->writecache_settings.max_age_set) { + EMIT_PARAMS(pos, " max_age %u", seg->writecache_settings.max_age); + } + if (seg->writecache_settings.new_key) { EMIT_PARAMS(pos, " %s %s", seg->writecache_settings.new_key, diff --git a/lib/metadata/writecache_manip.c b/lib/metadata/writecache_manip.c index e24bcb76b..7ad8c75e7 100644 --- a/lib/metadata/writecache_manip.c +++ b/lib/metadata/writecache_manip.c @@ -454,6 +454,14 @@ int writecache_settings_to_str_list(struct writecache_settings *settings, struct if (!_writecache_setting_str_list_add("nofua", (uint64_t)settings->nofua, NULL, result, mem)) errors++; + if (settings->cleaner_set && settings->cleaner) + if (!_writecache_setting_str_list_add("cleaner", (uint64_t)settings->cleaner, NULL, result, mem)) + errors++; + + if (settings->max_age_set) + if (!_writecache_setting_str_list_add("max_age", (uint64_t)settings->max_age, NULL, result, mem)) + errors++; + if (settings->new_key && settings->new_val) if (!_writecache_setting_str_list_add(settings->new_key, 0, settings->new_val, result, mem)) errors++; diff --git a/lib/report/report.c b/lib/report/report.c index 268bed61b..74ec74cf7 100644 --- a/lib/report/report.c +++ b/lib/report/report.c @@ -1434,7 +1434,7 @@ static int _cache_settings_disp(struct dm_report *rh, struct dm_pool *mem, if (!(result = str_list_create(mem))) return_0; - if (!writecache_settings_to_str_list(&seg->writecache_settings, result, mem)) + if (!writecache_settings_to_str_list((struct writecache_settings *)&seg->writecache_settings, result, mem)) return_0; return _field_set_string_list(rh, field, result, private, 0, NULL); diff --git a/lib/writecache/writecache.c b/lib/writecache/writecache.c index 130922a54..c7aea286d 100644 --- a/lib/writecache/writecache.c +++ b/lib/writecache/writecache.c @@ -26,6 +26,9 @@ #include "lib/metadata/lv_alloc.h" #include "lib/config/defaults.h" +static int _writecache_cleaner_supported; +static int _writecache_max_age_supported; + #define SEG_LOG_ERROR(t, p...) \ log_error(t " segment %s of logical volume %s.", ## p, \ dm_config_parent_name(sn), seg->lv->name), 0; @@ -120,6 +123,18 @@ static int _writecache_text_import(struct lv_segment *seg, seg->writecache_settings.nofua_set = 1; } + if (dm_config_has_node(sn, "cleaner")) { + if (!dm_config_get_uint32(sn, "cleaner", &seg->writecache_settings.cleaner)) + return SEG_LOG_ERROR("Unknown writecache_setting in"); + seg->writecache_settings.cleaner_set = 1; + } + + if (dm_config_has_node(sn, "max_age")) { + if (!dm_config_get_uint32(sn, "max_age", &seg->writecache_settings.max_age)) + return SEG_LOG_ERROR("Unknown writecache_setting in"); + seg->writecache_settings.max_age_set = 1; + } + if (dm_config_has_node(sn, "writecache_setting_key")) { const char *key; const char *val; @@ -184,6 +199,14 @@ static int _writecache_text_export(const struct lv_segment *seg, outf(f, "nofua = %u", seg->writecache_settings.nofua); } + if (seg->writecache_settings.cleaner_set && seg->writecache_settings.cleaner) { + outf(f, "cleaner = %u", seg->writecache_settings.cleaner); + } + + if (seg->writecache_settings.max_age_set) { + outf(f, "max_age = %u", seg->writecache_settings.max_age); + } + if (seg->writecache_settings.new_key && seg->writecache_settings.new_val) { outf(f, "writecache_setting_key = \"%s\"", seg->writecache_settings.new_key); @@ -208,6 +231,7 @@ static int _target_present(struct cmd_context *cmd, { static int _writecache_checked = 0; static int _writecache_present = 0; + uint32_t maj, min, patchlevel; if (!activation()) return 0; @@ -215,6 +239,19 @@ static int _target_present(struct cmd_context *cmd, if (!_writecache_checked) { _writecache_checked = 1; _writecache_present = target_present(cmd, TARGET_NAME_WRITECACHE, 1); + + if (!target_version(TARGET_NAME_WRITECACHE, &maj, &min, &patchlevel)) + return_0; + + if (maj < 1) { + log_error("writecache target version older than minimum 1.0.0"); + return 0; + } + + if (min >= 2) { + _writecache_cleaner_supported = 1; + _writecache_max_age_supported = 1; + } } return _writecache_present; @@ -257,6 +294,18 @@ static int _writecache_add_target_line(struct dev_manager *dm, return 0; } + if (!_writecache_cleaner_supported && seg->writecache_settings.cleaner_set && seg->writecache_settings.cleaner) { + log_warn("WARNING: ignoring writecache setting \"cleaner\" which is not supported by kernel for LV %s.", seg->lv->name); + seg->writecache_settings.cleaner = 0; + seg->writecache_settings.cleaner_set = 0; + } + + if (!_writecache_max_age_supported && seg->writecache_settings.max_age_set) { + log_warn("WARNING: ignoring writecache setting \"max_age\" which is not supported by kernel for LV %s.", seg->lv->name); + seg->writecache_settings.max_age = 0; + seg->writecache_settings.max_age_set = 0; + } + if ((pmem = lv_on_pmem(seg->writecache)) < 0) return_0; diff --git a/tools/lvchange.c b/tools/lvchange.c index ba24e8239..c0adadf8d 100644 --- a/tools/lvchange.c +++ b/tools/lvchange.c @@ -658,6 +658,16 @@ static int _lvchange_writecache(struct cmd_context *cmd, seg->writecache_settings.nofua = settings.nofua; set_count++; } + if (settings.cleaner_set) { + seg->writecache_settings.cleaner_set = settings.cleaner_set; + seg->writecache_settings.cleaner = settings.cleaner; + set_count++; + } + if (settings.max_age_set) { + seg->writecache_settings.max_age_set = settings.max_age_set; + seg->writecache_settings.max_age = settings.max_age; + set_count++; + } if (!set_count) { /* diff --git a/tools/toollib.c b/tools/toollib.c index 94e6e6c44..eb0de5501 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -1262,6 +1262,20 @@ static int _get_one_writecache_setting(struct cmd_context *cmd, struct writecach return 1; } + if (!strncmp(key, "cleaner", strlen("cleaner"))) { + if (sscanf(val, "%u", &settings->cleaner) != 1) + goto_bad; + settings->cleaner_set = 1; + return 1; + } + + if (!strncmp(key, "max_age", strlen("max_age"))) { + if (sscanf(val, "%u", &settings->max_age) != 1) + goto_bad; + settings->max_age_set = 1; + return 1; + } + if (settings->new_key) { log_error("Setting %s is not recognized. Only one unrecognized setting is allowed.", key); return 0;

1 0

master - writecache: attach while active using fs block size
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=d15c466f9557004fa003b… Commit: d15c466f9557004fa003b8986b82deca25cc5aaf Parent: 1ee42f13915d852008b1e7b777edee766413ef89 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Mon Mar 30 16:25:15 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:15:34 2020 -0500 writecache: attach while active using fs block size Use libblkid to detect sector/block size of the fs on the LV. Use this to choose a compatible writecache block size. Enable attaching writecache to an active LV. --- tools/lvconvert.c | 177 ++++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 164 insertions(+), 13 deletions(-) diff --git a/tools/lvconvert.c b/tools/lvconvert.c index 757e708ff..b25fa1704 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -5433,7 +5433,166 @@ static struct logical_volume *_lv_writecache_create(struct cmd_context *cmd, return lv_wcorig; } -#define DEFAULT_WRITECACHE_BLOCK_SIZE_SECTORS 8 /* 4K */ +/* + * Currently only supports writecache block sizes 512 and 4096. + * This could be expanded later. + */ +static int _set_writecache_block_size(struct cmd_context *cmd, + struct logical_volume *lv, + uint32_t *block_size_sectors) +{ + char pathname[PATH_MAX]; + struct device *fs_dev; + struct dm_list pvs; + struct pv_list *pvl; + uint32_t fs_block_size = 0; + uint32_t block_size_setting = 0; + uint32_t block_size = 0; + int lbs_unknown = 0, lbs_4k = 0, lbs_512 = 0; + int pbs_unknown = 0, pbs_4k = 0, pbs_512 = 0; + int rv; + + /* This is set if the user specified a writecache block size on the command line. */ + if (*block_size_sectors) + block_size_setting = *block_size_sectors * 512; + + dm_list_init(&pvs); + + if (!get_pv_list_for_lv(cmd->mem, lv, &pvs)) { + log_error("Failed to build list of PVs for %s.", display_lvname(lv)); + goto_bad; + } + + dm_list_iterate_items(pvl, &pvs) { + unsigned int pbs = 0; + unsigned int lbs = 0; + + if (!dev_get_direct_block_sizes(pvl->pv->dev, &pbs, &lbs)) { + lbs_unknown++; + pbs_unknown++; + continue; + } + + if (lbs == 4096) + lbs_4k++; + else if (lbs == 512) + lbs_512++; + else + lbs_unknown++; + + if (pbs == 4096) + pbs_4k++; + else if (pbs == 512) + pbs_512++; + else + pbs_unknown++; + } + + if (lbs_4k && lbs_512) { + log_error("Writecache requires consistent logical block size for LV devices."); + goto_bad; + } + + if (lbs_4k && block_size_setting && (block_size_setting < 4096)) { + log_error("Writecache block size %u not allowed with device logical block size 4096.", + block_size_setting); + goto_bad; + } + + if (dm_snprintf(pathname, sizeof(pathname), "%s%s/%s", cmd->dev_dir, + lv->vg->name, lv->name) < 0) { + log_error("Path name too long to get LV block size %s", display_lvname(lv)); + goto_bad; + } + + if (!(fs_dev = dev_cache_get(cmd, pathname, NULL))) { + log_error("Device for LV not found to check block size %s", display_lvname(lv)); + goto_bad; + } + + /* + * get_fs_block_size() returns the libblkid BLOCK_SIZE value, + * where libblkid has fs-specific code to set BLOCK_SIZE to the + * value we need here. + * + * The term "block size" here may not equate directly to what the fs + * calls the block size, e.g. xfs calls this the sector size (and + * something different the block size); while ext4 does call this + * value the block size, but it's possible values are not the same + * as xfs's, and do not seem to relate directly to the device LBS. + * + * With 512 LBS and 4K PBS, mkfs.xfs will use xfs sector size 4K. + */ + rv = get_fs_block_size(fs_dev, &fs_block_size); + if (!rv || !fs_block_size) { + if (lbs_4k && pbs_4k && !pbs_512) { + block_size = 4096; + } else if (lbs_512 && pbs_512 && !pbs_4k) { + block_size = 512; + } else if (lbs_512 && pbs_4k) { + if (block_size_setting == 4096) + block_size = 4096; + else + block_size = 512; + } else { + block_size = 512; + } + + if (block_size_setting && (block_size_setting != block_size)) { + log_error("Cannot use writecache block size %u with unknown file system block size, logical block size %u, physical block size %u.", + block_size_setting, lbs_4k ? 4096 : 512, pbs_4k ? 4096 : 512); + goto bad; + } + + if (block_size != 512) { + log_warn("WARNING: unable to detect a file system block size on %s", display_lvname(lv)); + log_warn("WARNING: using a writecache block size larger than the file system block size may corrupt the file system."); + if (!arg_is_set(cmd, yes_ARG) && + yes_no_prompt("Use writecache block size %u? [y/n]: ", block_size) == 'n') { + log_error("Conversion aborted."); + goto bad; + } + } + + log_print("Using writecache block size %u for unknown file system block size, logical block size %u, physical block size %u.", + block_size, lbs_4k ? 4096 : 512, pbs_4k ? 4096 : 512); + goto out; + } + + if (!block_size_setting) { + /* User did not specify a block size, so choose according to fs block size. */ + if (fs_block_size == 4096) + block_size = 4096; + else if (fs_block_size == 512) + block_size = 512; + else if (fs_block_size > 4096) + block_size = 4096; + else if (fs_block_size < 4096) + block_size = 512; + else + goto_bad; + } else { + if (block_size_setting <= fs_block_size) + block_size = block_size_setting; + else { + log_error("Writecache block size %u cannot be larger than file system block size %u.", + block_size_setting, fs_block_size); + goto_bad; + } + } + +out: + if (block_size == 512) + *block_size_sectors = 1; + else if (block_size == 4096) + *block_size_sectors = 8; + else + goto_bad; + + return 1; +bad: + return 0; +} static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, struct logical_volume *lv, @@ -5444,7 +5603,7 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, struct logical_volume *lv_fast; struct writecache_settings settings; const char *fast_name; - uint32_t block_size_sectors; + uint32_t block_size_sectors = 0; char *lockd_fast_args = NULL; char *lockd_fast_name = NULL; struct id lockd_fast_id; @@ -5472,16 +5631,6 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, goto bad; } - /* - * To permit this we need to check the block size of the fs using lv - * (recently in libblkid) so that we can use a matching writecache - * block size. We also want to do that if the lv is inactive. - */ - if (lv_is_active(lv)) { - log_error("LV %s must be inactive to attach writecache.", display_lvname(lv)); - goto bad; - } - /* fast LV shouldn't generally be active by itself, but just in case. */ if (lv_info(cmd, lv_fast, 1, NULL, 0, 0)) { log_error("LV %s must be inactive to attach.", display_lvname(lv_fast)); @@ -5489,13 +5638,15 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, } memset(&settings, 0, sizeof(settings)); - block_size_sectors = DEFAULT_WRITECACHE_BLOCK_SIZE_SECTORS; if (!get_writecache_settings(cmd, &settings, &block_size_sectors)) { log_error("Invalid writecache settings."); goto bad; } + if (!_set_writecache_block_size(cmd, lv, &block_size_sectors)) + goto_bad; + if (!arg_is_set(cmd, yes_ARG) && yes_no_prompt("Erase all existing data on %s? [y/n]: ", display_lvname(lv_fast)) == 'n') { log_error("Conversion aborted.");

1 0

master - writecache: cachesettings in lvchange and lvs
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=1ee42f13915d852008b1e… Commit: 1ee42f13915d852008b1e7b777edee766413ef89 Parent: ce772bfab976d89f6a35a442434d1a49ceb634c7 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Feb 26 14:47:29 2020 -0600 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:14:00 2020 -0500 writecache: cachesettings in lvchange and lvs lvchange --cachesettings lvs -o+cache_settings --- lib/metadata/metadata-exported.h | 1 + lib/metadata/writecache_manip.c | 70 ++++++++++++++++++ lib/report/report.c | 10 +++ tools/command-lines.in | 2 +- tools/lvchange.c | 75 +++++++++++++++++++ tools/lvconvert.c | 153 +-------------------------------------- tools/toollib.c | 150 ++++++++++++++++++++++++++++++++++++++ tools/toollib.h | 3 + 8 files changed, 311 insertions(+), 153 deletions(-) diff --git a/lib/metadata/metadata-exported.h b/lib/metadata/metadata-exported.h index 9de088437..0d6be136b 100644 --- a/lib/metadata/metadata-exported.h +++ b/lib/metadata/metadata-exported.h @@ -1096,6 +1096,7 @@ int lv_is_cow(const struct logical_volume *lv); int lv_is_cache_origin(const struct logical_volume *lv); int lv_is_writecache_origin(const struct logical_volume *lv); int lv_is_writecache_cachevol(const struct logical_volume *lv); +int writecache_settings_to_str_list(struct writecache_settings *settings, struct dm_list *result, struct dm_pool *mem); int lv_is_integrity_origin(const struct logical_volume *lv); diff --git a/lib/metadata/writecache_manip.c b/lib/metadata/writecache_manip.c index 4f09e69cf..e24bcb76b 100644 --- a/lib/metadata/writecache_manip.c +++ b/lib/metadata/writecache_manip.c @@ -22,6 +22,7 @@ #include "lib/metadata/lv_alloc.h" #include "lib/activate/activate.h" #include "lib/config/defaults.h" +#include "lib/datastruct/str_list.h" int lv_is_writecache_origin(const struct logical_volume *lv) { @@ -394,3 +395,72 @@ int lv_detach_writecache_cachevol(struct logical_volume *lv, int noflush) return _lv_detach_writecache_cachevol_inactive(lv, noflush); } +static int _writecache_setting_str_list_add(const char *field, uint64_t val, char *val_str, struct dm_list *result, struct dm_pool *mem) +{ + char buf[128]; + char *list_item; + int len; + + if (val_str) { + if (dm_snprintf(buf, sizeof(buf), "%s=%s", field, val_str) < 0) + return_0; + } else { + if (dm_snprintf(buf, sizeof(buf), "%s=%llu", field, (unsigned long long)val) < 0) + return_0; + } + + len = strlen(buf) + 1; + + if (!(list_item = dm_pool_zalloc(mem, len))) + return_0; + + memcpy(list_item, buf, len); + + if (!str_list_add_no_dup_check(mem, result, list_item)) + return_0; + + return 1; +} + +int writecache_settings_to_str_list(struct writecache_settings *settings, struct dm_list *result, struct dm_pool *mem) +{ + int errors = 0; + + if (settings->high_watermark_set) + if (!_writecache_setting_str_list_add("high_watermark", settings->high_watermark, NULL, result, mem)) + errors++; + + if (settings->low_watermark_set) + if (!_writecache_setting_str_list_add("low_watermark", settings->low_watermark, NULL, result, mem)) + errors++; + + if (settings->writeback_jobs_set) + if (!_writecache_setting_str_list_add("writeback_jobs", settings->writeback_jobs, NULL, result, mem)) + errors++; + + if (settings->autocommit_blocks_set) + if (!_writecache_setting_str_list_add("autocommit_blocks", settings->autocommit_blocks, NULL, result, mem)) + errors++; + + if (settings->autocommit_time_set) + if (!_writecache_setting_str_list_add("autocommit_time", settings->autocommit_time, NULL, result, mem)) + errors++; + + if (settings->fua_set) + if (!_writecache_setting_str_list_add("fua", (uint64_t)settings->fua, NULL, result, mem)) + errors++; + + if (settings->nofua_set) + if (!_writecache_setting_str_list_add("nofua", (uint64_t)settings->nofua, NULL, result, mem)) + errors++; + + if (settings->new_key && settings->new_val) + if (!_writecache_setting_str_list_add(settings->new_key, 0, settings->new_val, result, mem)) + errors++; + + if (errors) + log_warn("Failed to create list of writecache settings."); + + return 1; +} + diff --git a/lib/report/report.c b/lib/report/report.c index e1c630576..268bed61b 100644 --- a/lib/report/report.c +++ b/lib/report/report.c @@ -1430,6 +1430,16 @@ static int _cache_settings_disp(struct dm_report *rh, struct dm_pool *mem, struct _str_list_append_baton baton; struct dm_list dummy_list; /* dummy list to display "nothing" */ + if (seg_is_writecache(seg)) { + if (!(result = str_list_create(mem))) + return_0; + + if (!writecache_settings_to_str_list(&seg->writecache_settings, result, mem)) + return_0; + + return _field_set_string_list(rh, field, result, private, 0, NULL); + } + if (seg_is_cache(seg) && lv_is_cache_vol(seg->pool_lv)) setting_seg = seg; diff --git a/tools/command-lines.in b/tools/command-lines.in index ed3d0413a..98044a918 100644 --- a/tools/command-lines.in +++ b/tools/command-lines.in @@ -247,7 +247,7 @@ RULE: --profile not --detachprofile RULE: --metadataprofile not --detachprofile RULE: --minrecoveryrate --maxrecoveryrate and LV_raid RULE: --writebehind --writemostly and LV_raid1 -RULE: --cachemode --cachepolicy --cachesettings and LV_cache LV_cachepool +RULE: --cachemode --cachepolicy --cachesettings and LV_cache LV_cachepool LV_writecache RULE: --errorwhenfull --discards --zero and LV_thinpool RULE: --permission not lv_is_external_origin lv_is_raid_metadata lv_is_raid_image LV_thinpool RULE: --alloc --contiguous --metadataprofile --permission --persistent --profile --readahead not lv_is_thick_origin diff --git a/tools/lvchange.c b/tools/lvchange.c index 2d5bb32be..ba24e8239 100644 --- a/tools/lvchange.c +++ b/tools/lvchange.c @@ -606,6 +606,78 @@ static int _lvchange_persistent(struct cmd_context *cmd, return 1; } +static int _lvchange_writecache(struct cmd_context *cmd, + struct logical_volume *lv, + uint32_t *mr) +{ + struct writecache_settings settings = { 0 }; + uint32_t block_size_sectors = 0; + struct lv_segment *seg = first_seg(lv); + int set_count = 0; + + if (!get_writecache_settings(cmd, &settings, &block_size_sectors)) + return_0; + + if (block_size_sectors && (seg->writecache_block_size != (block_size_sectors * 512))) { + log_error("Cannot change existing block size %u bytes.", seg->writecache_block_size); + return 0; + } + + if (settings.high_watermark_set) { + seg->writecache_settings.high_watermark_set = settings.high_watermark_set; + seg->writecache_settings.high_watermark = settings.high_watermark; + set_count++; + } + if (settings.low_watermark_set) { + seg->writecache_settings.low_watermark_set = settings.low_watermark_set; + seg->writecache_settings.low_watermark = settings.low_watermark; + set_count++; + } + if (settings.writeback_jobs_set) { + seg->writecache_settings.writeback_jobs_set = settings.writeback_jobs_set; + seg->writecache_settings.writeback_jobs = settings.writeback_jobs; + set_count++; + } + if (settings.autocommit_blocks_set) { + seg->writecache_settings.autocommit_blocks_set = settings.autocommit_blocks_set; + seg->writecache_settings.autocommit_blocks = settings.autocommit_blocks; + set_count++; + } + if (settings.autocommit_time_set) { + seg->writecache_settings.autocommit_time_set = settings.autocommit_time_set; + seg->writecache_settings.autocommit_time = settings.autocommit_time; + set_count++; + } + if (settings.fua_set) { + seg->writecache_settings.fua_set = settings.fua_set; + seg->writecache_settings.fua = settings.fua; + set_count++; + } + if (settings.nofua_set) { + seg->writecache_settings.nofua_set = settings.nofua_set; + seg->writecache_settings.nofua = settings.nofua; + set_count++; + } + + if (!set_count) { + /* + * Empty settings can be used to clear all current settings, + * lvchange --cachesettings "" vg/lv + */ + if (!arg_count(cmd, yes_ARG) && + yes_no_prompt("Clear all writecache settings? ") == 'n') { + log_print("No settings changed."); + return 1; + } + memset(&seg->writecache_settings, 0, sizeof(struct writecache_settings)); + } + + /* Request caller to commit and reload metadata */ + *mr |= MR_RELOAD; + + return 1; +} + static int _lvchange_cache(struct cmd_context *cmd, struct logical_volume *lv, uint32_t *mr) @@ -619,6 +691,9 @@ static int _lvchange_cache(struct cmd_context *cmd, int r = 0, is_clean; uint32_t chunk_size = 0; /* FYI: lvchange does NOT support its change */ + if (lv_is_writecache(lv)) + return _lvchange_writecache(cmd, lv, mr); + seg = first_seg(lv); if (seg_is_cache(seg) && lv_is_cache_vol(seg->pool_lv)) diff --git a/tools/lvconvert.c b/tools/lvconvert.c index 7935eb74e..757e708ff 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -5389,157 +5389,6 @@ static int _writecache_zero(struct cmd_context *cmd, struct logical_volume *lv) return ret; } -static int _get_one_writecache_setting(struct cmd_context *cmd, struct writecache_settings *settings, - char *key, char *val, uint32_t *block_size_sectors) -{ - /* special case: block_size is not a setting but is set with the --cachesettings option */ - if (!strncmp(key, "block_size", strlen("block_size"))) { - uint32_t block_size = 0; - if (sscanf(val, "%u", &block_size) != 1) - goto_bad; - if (block_size == 512) - *block_size_sectors = 1; - else if (block_size == 4096) - *block_size_sectors = 8; - else - goto_bad; - return 1; - } - - if (!strncmp(key, "high_watermark", strlen("high_watermark"))) { - if (sscanf(val, "%llu", (unsigned long long *)&settings->high_watermark) != 1) - goto_bad; - if (settings->high_watermark > 100) - goto_bad; - settings->high_watermark_set = 1; - return 1; - } - - if (!strncmp(key, "low_watermark", strlen("low_watermark"))) { - if (sscanf(val, "%llu", (unsigned long long *)&settings->low_watermark) != 1) - goto_bad; - if (settings->low_watermark > 100) - goto_bad; - settings->low_watermark_set = 1; - return 1; - } - - if (!strncmp(key, "writeback_jobs", strlen("writeback_jobs"))) { - if (sscanf(val, "%llu", (unsigned long long *)&settings->writeback_jobs) != 1) - goto_bad; - settings->writeback_jobs_set = 1; - return 1; - } - - if (!strncmp(key, "autocommit_blocks", strlen("autocommit_blocks"))) { - if (sscanf(val, "%llu", (unsigned long long *)&settings->autocommit_blocks) != 1) - goto_bad; - settings->autocommit_blocks_set = 1; - return 1; - } - - if (!strncmp(key, "autocommit_time", strlen("autocommit_time"))) { - if (sscanf(val, "%llu", (unsigned long long *)&settings->autocommit_time) != 1) - goto_bad; - settings->autocommit_time_set = 1; - return 1; - } - - if (!strncmp(key, "fua", strlen("fua"))) { - if (settings->nofua_set) { - log_error("Setting fua and nofua cannot both be set."); - return 0; - } - if (sscanf(val, "%u", &settings->fua) != 1) - goto_bad; - settings->fua_set = 1; - return 1; - } - - if (!strncmp(key, "nofua", strlen("nofua"))) { - if (settings->fua_set) { - log_error("Setting fua and nofua cannot both be set."); - return 0; - } - if (sscanf(val, "%u", &settings->nofua) != 1) - goto_bad; - settings->nofua_set = 1; - return 1; - } - - if (settings->new_key) { - log_error("Setting %s is not recognized. Only one unrecognized setting is allowed.", key); - return 0; - } - - log_warn("Unrecognized writecache setting \"%s\" may cause activation failure.", key); - if (yes_no_prompt("Use unrecognized writecache setting? [y/n]: ") == 'n') { - log_error("Aborting writecache conversion."); - return 0; - } - - log_warn("Using unrecognized writecache setting: %s = %s.", key, val); - - settings->new_key = dm_pool_strdup(cmd->mem, key); - settings->new_val = dm_pool_strdup(cmd->mem, val); - return 1; - - bad: - log_error("Invalid setting: %s", key); - return 0; -} - -static int _get_writecache_settings(struct cmd_context *cmd, struct writecache_settings *settings, - uint32_t *block_size_sectors) -{ - struct arg_value_group_list *group; - const char *str; - char key[64]; - char val[64]; - int num; - int pos; - - /* - * "grouped" means that multiple --cachesettings options can be used. - * Each option is also allowed to contain multiple key = val pairs. - */ - - dm_list_iterate_items(group, &cmd->arg_value_groups) { - if (!grouped_arg_is_set(group->arg_values, cachesettings_ARG)) - continue; - - if (!(str = grouped_arg_str_value(group->arg_values, cachesettings_ARG, NULL))) - break; - - pos = 0; - - while (pos < strlen(str)) { - /* scan for "key1=val1 key2 = val2 key3= val3" */ - - memset(key, 0, sizeof(key)); - memset(val, 0, sizeof(val)); - - if (sscanf(str + pos, " %63[^=]=%63s %n", key, val, &num) != 2) { - log_error("Invalid setting at: %s", str+pos); - return 0; - } - - pos += num; - - if (!_get_one_writecache_setting(cmd, settings, key, val, block_size_sectors)) - return_0; - } - } - - if (settings->high_watermark_set && settings->low_watermark_set && - (settings->high_watermark <= settings->low_watermark)) { - log_error("High watermark must be greater than low watermark."); - return 0; - } - - return 1; -} - static struct logical_volume *_lv_writecache_create(struct cmd_context *cmd, struct logical_volume *lv, struct logical_volume *lv_fast, @@ -5642,7 +5491,7 @@ static int _lvconvert_writecache_attach_single(struct cmd_context *cmd, memset(&settings, 0, sizeof(settings)); block_size_sectors = DEFAULT_WRITECACHE_BLOCK_SIZE_SECTORS; - if (!_get_writecache_settings(cmd, &settings, &block_size_sectors)) { + if (!get_writecache_settings(cmd, &settings, &block_size_sectors)) { log_error("Invalid writecache settings."); goto bad; } diff --git a/tools/toollib.c b/tools/toollib.c index 89b637407..94e6e6c44 100644 --- a/tools/toollib.c +++ b/tools/toollib.c @@ -1184,6 +1184,156 @@ out: return ok; } +static int _get_one_writecache_setting(struct cmd_context *cmd, struct writecache_settings *settings, + char *key, char *val, uint32_t *block_size_sectors) +{ + /* special case: block_size is not a setting but is set with the --cachesettings option */ + if (!strncmp(key, "block_size", strlen("block_size"))) { + uint32_t block_size = 0; + if (sscanf(val, "%u", &block_size) != 1) + goto_bad; + if (block_size == 512) + *block_size_sectors = 1; + else if (block_size == 4096) + *block_size_sectors = 8; + else + goto_bad; + return 1; + } + + if (!strncmp(key, "high_watermark", strlen("high_watermark"))) { + if (sscanf(val, "%llu", (unsigned long long *)&settings->high_watermark) != 1) + goto_bad; + if (settings->high_watermark > 100) + goto_bad; + settings->high_watermark_set = 1; + return 1; + } + + if (!strncmp(key, "low_watermark", strlen("low_watermark"))) { + if (sscanf(val, "%llu", (unsigned long long *)&settings->low_watermark) != 1) + goto_bad; + if (settings->low_watermark > 100) + goto_bad; + settings->low_watermark_set = 1; + return 1; + } + + if (!strncmp(key, "writeback_jobs", strlen("writeback_jobs"))) { + if (sscanf(val, "%llu", (unsigned long long *)&settings->writeback_jobs) != 1) + goto_bad; + settings->writeback_jobs_set = 1; + return 1; + } + + if (!strncmp(key, "autocommit_blocks", strlen("autocommit_blocks"))) { + if (sscanf(val, "%llu", (unsigned long long *)&settings->autocommit_blocks) != 1) + goto_bad; + settings->autocommit_blocks_set = 1; + return 1; + } + + if (!strncmp(key, "autocommit_time", strlen("autocommit_time"))) { + if (sscanf(val, "%llu", (unsigned long long *)&settings->autocommit_time) != 1) + goto_bad; + settings->autocommit_time_set = 1; + return 1; + } + + if (!strncmp(key, "fua", strlen("fua"))) { + if (settings->nofua_set) { + log_error("Setting fua and nofua cannot both be set."); + return 0; + } + if (sscanf(val, "%u", &settings->fua) != 1) + goto_bad; + settings->fua_set = 1; + return 1; + } + + if (!strncmp(key, "nofua", strlen("nofua"))) { + if (settings->fua_set) { + log_error("Setting fua and nofua cannot both be set."); + return 0; + } + if (sscanf(val, "%u", &settings->nofua) != 1) + goto_bad; + settings->nofua_set = 1; + return 1; + } + + if (settings->new_key) { + log_error("Setting %s is not recognized. Only one unrecognized setting is allowed.", key); + return 0; + } + + log_warn("Unrecognized writecache setting \"%s\" may cause activation failure.", key); + if (yes_no_prompt("Use unrecognized writecache setting? [y/n]: ") == 'n') { + log_error("Aborting writecache conversion."); + return 0; + } + + log_warn("Using unrecognized writecache setting: %s = %s.", key, val); + + settings->new_key = dm_pool_strdup(cmd->mem, key); + settings->new_val = dm_pool_strdup(cmd->mem, val); + return 1; + + bad: + log_error("Invalid setting: %s", key); + return 0; +} + +int get_writecache_settings(struct cmd_context *cmd, struct writecache_settings *settings, + uint32_t *block_size_sectors) +{ + struct arg_value_group_list *group; + const char *str; + char key[64]; + char val[64]; + int num; + int pos; + + /* + * "grouped" means that multiple --cachesettings options can be used. + * Each option is also allowed to contain multiple key = val pairs. + */ + + dm_list_iterate_items(group, &cmd->arg_value_groups) { + if (!grouped_arg_is_set(group->arg_values, cachesettings_ARG)) + continue; + + if (!(str = grouped_arg_str_value(group->arg_values, cachesettings_ARG, NULL))) + break; + + pos = 0; + + while (pos < strlen(str)) { + /* scan for "key1=val1 key2 = val2 key3= val3" */ + + memset(key, 0, sizeof(key)); + memset(val, 0, sizeof(val)); + + if (sscanf(str + pos, " %63[^=]=%63s %n", key, val, &num) != 2) { + log_error("Invalid setting at: %s", str+pos); + return 0; + } + + pos += num; + + if (!_get_one_writecache_setting(cmd, settings, key, val, block_size_sectors)) + return_0; + } + } + + if (settings->high_watermark_set && settings->low_watermark_set && + (settings->high_watermark <= settings->low_watermark)) { + log_error("High watermark must be greater than low watermark."); + return 0; + } + + return 1; +} /* FIXME move to lib */ static int _pv_change_tag(struct physical_volume *pv, const char *tag, int addtag) diff --git a/tools/toollib.h b/tools/toollib.h index 53a5e5b4f..f3a60fbc4 100644 --- a/tools/toollib.h +++ b/tools/toollib.h @@ -217,6 +217,9 @@ int get_cache_params(struct cmd_context *cmd, const char **name, struct dm_config_tree **settings); +int get_writecache_settings(struct cmd_context *cmd, struct writecache_settings *settings, + uint32_t *block_size_sectors); + int change_tag(struct cmd_context *cmd, struct volume_group *vg, struct logical_volume *lv, struct physical_volume *pv, int arg);

1 0

master - writecache: show error in lv_health_status and lv_attr
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=ce772bfab976d89f6a35a… Commit: ce772bfab976d89f6a35a442434d1a49ceb634c7 Parent: 240062a18365a7f6725ebcf1b035a6e0a3b12803 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Tue Feb 25 16:20:05 2020 -0600 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:13:48 2020 -0500 writecache: show error in lv_health_status and lv_attr lv_attr is 'E' and lv_health_status is 'error' when dm-writecache status reports error. --- lib/metadata/lv.c | 3 +++ lib/report/report.c | 6 ++++++ man/lvs.8_end | 4 ++++ 3 files changed, 13 insertions(+) diff --git a/lib/metadata/lv.c b/lib/metadata/lv.c index 4ee58b419..fac47e530 100644 --- a/lib/metadata/lv.c +++ b/lib/metadata/lv.c @@ -1412,6 +1412,9 @@ char *lv_attr_dup_with_info_and_seg_status(struct dm_pool *mem, const struct lv_ } else if (lvdm->seg_status.type == SEG_STATUS_THIN) { if (lvdm->seg_status.thin->fail) repstr[8] = 'F'; + } else if (lvdm->seg_status.type == SEG_STATUS_WRITECACHE) { + if (lvdm->seg_status.writecache->error) + repstr[8] = 'E'; } else if (lvdm->seg_status.type == SEG_STATUS_UNKNOWN) repstr[8] = 'X'; /* Unknown */ diff --git a/lib/report/report.c b/lib/report/report.c index 170df6995..e1c630576 100644 --- a/lib/report/report.c +++ b/lib/report/report.c @@ -3802,6 +3802,12 @@ static int _lvhealthstatus_disp(struct dm_report *rh, struct dm_pool *mem, health = "failed"; else if (lvdm->seg_status.cache->read_only) health = "metadata_read_only"; + } else if (lv_is_writecache(lv) && (lvdm->seg_status.type != SEG_STATUS_NONE)) { + if (lvdm->seg_status.type != SEG_STATUS_WRITECACHE) + return _field_set_value(field, GET_FIRST_RESERVED_NAME(health_undef), + GET_FIELD_RESERVED_VALUE(health_undef)); + if (lvdm->seg_status.writecache->error) + health = "error"; } else if (lv_is_thin_pool(lv) && (lvdm->seg_status.type != SEG_STATUS_NONE)) { if (lvdm->seg_status.type != SEG_STATUS_THIN_POOL) return _field_set_value(field, GET_FIRST_RESERVED_NAME(health_undef), diff --git a/man/lvs.8_end b/man/lvs.8_end index 6efc9cb4f..5a4ecc83c 100644 --- a/man/lvs.8_end +++ b/man/lvs.8_end @@ -74,5 +74,9 @@ Related to Thin Logical Volumes: (F)ailed. .br (F)ailed is set when related thin pool enters Failed state and no further I/O is permitted at all. +.IP +Related to writecache logical volumes: (E)rror. +.br +(E)rror is set dm-writecache reports an error. .IP 10 3 s(k)ip activation: this volume is flagged to be skipped during activation.

1 0

master - writecache: remove from an active lv
by David Teigland 10 Jun '20

10 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=240062a18365a7f6725eb… Commit: 240062a18365a7f6725ebcf1b035a6e0a3b12803 Parent: 8806f2d5ed4792042b246b930fb44f24b9ee45c2 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Mon Feb 24 13:52:12 2020 -0600 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 10 12:13:31 2020 -0500 writecache: remove from an active lv --- lib/metadata/lv_manip.c | 17 ++- lib/metadata/metadata-exported.h | 3 +- lib/metadata/writecache_manip.c | 288 +++++++++++++++++++++++++++++++++------ test/shell/writecache-split.sh | 35 +++-- tools/lvconvert.c | 42 ++---- 5 files changed, 294 insertions(+), 91 deletions(-) diff --git a/lib/metadata/lv_manip.c b/lib/metadata/lv_manip.c index 1311f70bd..c1c86aa4c 100644 --- a/lib/metadata/lv_manip.c +++ b/lib/metadata/lv_manip.c @@ -6568,7 +6568,20 @@ int lv_remove_single(struct cmd_context *cmd, struct logical_volume *lv, } } - if (lv_is_used_cache_pool(lv) || lv_is_cache_vol(lv)) { + if (lv_is_cache_vol(lv)) { + if ((cache_seg = get_only_segment_using_this_lv(lv))) { + /* When used with cache, lvremove on cachevol also removes the cache! */ + if (seg_is_cache(cache_seg)) { + if (!lv_cache_remove(cache_seg->lv)) + return_0; + } else if (seg_is_writecache(cache_seg)) { + log_error("Detach cachevol before removing."); + return 0; + } + } + } + + if (lv_is_used_cache_pool(lv)) { /* Cache pool removal drops cache layer * If the cache pool is not linked, we can simply remove it. */ if (!(cache_seg = get_only_segment_using_this_lv(lv))) @@ -6832,7 +6845,7 @@ static int _lv_update_and_reload(struct logical_volume *lv, int origin_only) } if (!(origin_only ? suspend_lv_origin(vg->cmd, lock_lv) : suspend_lv(vg->cmd, lock_lv))) { - log_error("Failed to lock logical volume %s.", + log_error("Failed to suspend logical volume %s.", display_lvname(lock_lv)); vg_revert(vg); } else if (!(r = vg_commit(vg))) diff --git a/lib/metadata/metadata-exported.h b/lib/metadata/metadata-exported.h index 083f74a28..9de088437 100644 --- a/lib/metadata/metadata-exported.h +++ b/lib/metadata/metadata-exported.h @@ -89,8 +89,7 @@ #define PARTIAL_LV UINT64_C(0x0000000001000000) /* LV - derived flag, not written out in metadata*/ -//#define POSTORDER_FLAG UINT64_C(0x0000000002000000) /* Not real flags, reserved for -//#define POSTORDER_OPEN_FLAG UINT64_C(0x0000000004000000) temporary use inside vg_read_internal. */ +#define WRITECACHE_ORIGIN UINT64_C(0x0000000002000000) #define INTEGRITY_METADATA UINT64_C(0x0000000004000000) /* LV - Internal use only */ #define VIRTUAL_ORIGIN UINT64_C(0x0000000008000000) /* LV - internal use only */ diff --git a/lib/metadata/writecache_manip.c b/lib/metadata/writecache_manip.c index 31d069edb..4f09e69cf 100644 --- a/lib/metadata/writecache_manip.c +++ b/lib/metadata/writecache_manip.c @@ -19,6 +19,7 @@ #include "lib/commands/toolcontext.h" #include "lib/display/display.h" #include "lib/metadata/segtype.h" +#include "lib/metadata/lv_alloc.h" #include "lib/activate/activate.h" #include "lib/config/defaults.h" @@ -26,6 +27,15 @@ int lv_is_writecache_origin(const struct logical_volume *lv) { struct lv_segment *seg; + /* + * This flag is needed when removing writecache from an origin + * in which case the lv connections have been destroyed and + * identifying a writecache origin by these connections doesn't + * work. + */ + if (lv->status & WRITECACHE_ORIGIN) + return 1; + /* Make sure there's exactly one segment in segs_using_this_lv! */ if (dm_list_empty(&lv->segs_using_this_lv) || (dm_list_size(&lv->segs_using_this_lv) > 1)) @@ -48,46 +58,6 @@ int lv_is_writecache_cachevol(const struct logical_volume *lv) return 0; } -static int _lv_writecache_detach(struct cmd_context *cmd, struct logical_volume *lv, - struct logical_volume *lv_fast) -{ - struct lv_segment *seg = first_seg(lv); - struct logical_volume *origin; - - if (!seg_is_writecache(seg)) { - log_error("LV %s segment is not writecache.", display_lvname(lv)); - return 0; - } - - if (!seg->writecache) { - log_error("LV %s writecache segment has no writecache.", display_lvname(lv)); - return 0; - } - - if (!(origin = seg_lv(seg, 0))) { - log_error("LV %s writecache segment has no origin", display_lvname(lv)); - return 0; - } - - if (!remove_seg_from_segs_using_this_lv(seg->writecache, seg)) - return_0; - - lv_set_visible(seg->writecache); - - lv->status &= ~WRITECACHE; - seg->writecache = NULL; - - lv_fast->status &= ~LV_CACHE_VOL; - - if (!remove_layer_from_lv(lv, origin)) - return_0; - - if (!lv_remove(origin)) - return_0; - - return 1; -} - static int _get_writecache_kernel_error(struct cmd_context *cmd, struct logical_volume *lv, uint32_t *kernel_error) @@ -131,13 +101,64 @@ fail: return 0; } -int lv_detach_writecache_cachevol(struct logical_volume *lv, int noflush) +static void _rename_detached_cvol(struct cmd_context *cmd, struct logical_volume *lv_fast) +{ + struct volume_group *vg = lv_fast->vg; + char cvol_name[NAME_LEN]; + char *suffix, *cvol_name_dup; + + /* + * Rename lv_fast back to its original name, without the _cvol + * suffix that was added when lv_fast was attached for caching. + * If the name is in use, generate new lvol%d. + * Failing to rename is not really a problem, so we intentionally + * do not consider some things here as errors. + */ + if (!dm_strncpy(cvol_name, lv_fast->name, sizeof(cvol_name)) || + !(suffix = strstr(cvol_name, "_cvol"))) { + log_debug("LV %s has no suffix for cachevol (skipping rename).", + display_lvname(lv_fast)); + return; + } + + *suffix = 0; + if (lv_name_is_used_in_vg(vg, cvol_name, NULL) && + !generate_lv_name(vg, "lvol%d", cvol_name, sizeof(cvol_name))) { + log_warn("Failed to generate new unique name for unused LV %s", lv_fast->name); + return; + } + + if (!(cvol_name_dup = dm_pool_strdup(vg->vgmem, cvol_name))) { + stack; + return; + } + + lv_fast->name = cvol_name_dup; +} + +static int _lv_detach_writecache_cachevol_inactive(struct logical_volume *lv, int noflush) { struct cmd_context *cmd = lv->vg->cmd; + struct volume_group *vg = lv->vg; struct logical_volume *lv_fast; + struct logical_volume *lv_wcorig; + struct lv_segment *seg = first_seg(lv); uint32_t kernel_error = 0; - lv_fast = first_seg(lv)->writecache; + if (!seg_is_writecache(seg)) { + log_error("LV %s segment is not writecache.", display_lvname(lv)); + return 0; + } + + if (!(lv_fast = seg->writecache)) { + log_error("LV %s writecache segment has no writecache.", display_lvname(lv)); + return 0; + } + + if (!(lv_wcorig = seg_lv(seg, 0))) { + log_error("LV %s writecache segment has no origin", display_lvname(lv)); + return 0; + } if (noflush) goto detach; @@ -157,6 +178,8 @@ int lv_detach_writecache_cachevol(struct logical_volume *lv, int noflush) if (!sync_local_dev_names(cmd)) { log_error("Failed to sync local devices before detaching writecache."); + if (!deactivate_lv(cmd, lv)) + log_error("Failed to deactivate %s.", display_lvname(lv)); return 0; } @@ -176,7 +199,8 @@ int lv_detach_writecache_cachevol(struct logical_volume *lv, int noflush) if (kernel_error) { log_error("Failed to flush writecache (error %u) for %s.", kernel_error, display_lvname(lv)); - deactivate_lv(cmd, lv); + if (!deactivate_lv(cmd, lv)) + log_error("Failed to deactivate %s.", display_lvname(lv)); return 0; } @@ -188,11 +212,185 @@ int lv_detach_writecache_cachevol(struct logical_volume *lv, int noflush) lv->status &= ~LV_TEMPORARY; detach: - if (!_lv_writecache_detach(cmd, lv, lv_fast)) { - log_error("Failed to detach writecache from %s", display_lvname(lv)); + if (!remove_seg_from_segs_using_this_lv(lv_fast, seg)) + return_0; + + lv->status &= ~WRITECACHE; + seg->writecache = NULL; + + if (!remove_layer_from_lv(lv, lv_wcorig)) + return_0; + + if (!lv_remove(lv_wcorig)) + return_0; + + lv_set_visible(lv_fast); + lv_fast->status &= ~LV_CACHE_VOL; + + _rename_detached_cvol(cmd, lv_fast); + + if (!vg_write(vg) || !vg_commit(vg)) + return_0; + + return 1; +} + +static int _lv_detach_writecache_cachevol_active(struct logical_volume *lv, int noflush) +{ + struct cmd_context *cmd = lv->vg->cmd; + struct volume_group *vg = lv->vg; + struct logical_volume *lv_fast; + struct logical_volume *lv_wcorig; + struct logical_volume *lv_old; + struct lv_segment *seg = first_seg(lv); + uint32_t kernel_error = 0; + + if (!seg_is_writecache(seg)) { + log_error("LV %s segment is not writecache.", display_lvname(lv)); + return 0; + } + + if (!(lv_fast = seg->writecache)) { + log_error("LV %s writecache segment has no writecache.", display_lvname(lv)); + return 0; + } + + if (!(lv_wcorig = seg_lv(seg, 0))) { + log_error("LV %s writecache segment has no origin", display_lvname(lv)); + return 0; + } + + if (noflush) + goto detach; + + if (!lv_writecache_message(lv, "flush_on_suspend")) { + log_error("Failed to set flush_on_suspend in writecache detach %s.", display_lvname(lv)); + return 0; + } + + detach: + if (!remove_seg_from_segs_using_this_lv(lv_fast, seg)) { + log_error("Failed to remove seg in writecache detach."); + return 0; + } + + lv->status &= ~WRITECACHE; + seg->writecache = NULL; + + if (!remove_layer_from_lv(lv, lv_wcorig)) { + log_error("Failed to remove lv layer in writecache detach."); + return 0; + } + + /* + * vg_write(), suspend_lv(), vg_commit(), resume_lv(). + * usually done by lv_update_and_reload for an active lv, + * but in this case we need to check for writecache errors + * after suspend. + */ + + if (!vg_write(vg)) { + log_error("Failed to write VG in writecache detach."); + return 0; + } + + /* + * The version of LV before removal of writecache. When need to + * check for kernel errors based on the old version of LV which + * is still present in the kernel. + */ + if (!(lv_old = (struct logical_volume *)lv_committed(lv))) { + log_error("Failed to get lv_committed in writecache detach."); + return 0; + } + + /* + * suspend does not use 'lv' as we know it here, but grabs the + * old (precommitted) version of 'lv' using lv_committed(), + * which is from vg->vg_comitted. + */ + log_debug("Suspending writecache to detach %s", display_lvname(lv)); + + if (!suspend_lv(cmd, lv)) { + log_error("Failed to suspend LV in writecache detach."); + vg_revert(vg); + return 0; + } + + log_debug("Checking writecache errors to detach."); + + if (!_get_writecache_kernel_error(cmd, lv_old, &kernel_error)) { + log_error("Failed to get writecache error status for %s.", display_lvname(lv_old)); + return 0; + } + + if (kernel_error) { + log_error("Failed to flush writecache (error %u) for %s.", kernel_error, display_lvname(lv)); + return 0; + } + + if (!vg_commit(vg)) { + log_error("Failed to commit VG in writecache detach."); + return 0; + } + + /* + * Since vg_commit has happened, vg->vg_committed is now the + * newest copy of lv, so resume uses the 'lv' that we know + * here. + */ + log_debug("Resuming after writecache detached %s", display_lvname(lv)); + + if (!resume_lv(cmd, lv)) { + log_error("Failed to resume LV in writecache detach."); + return 0; + } + + log_debug("Deactivating previous cachevol %s", display_lvname(lv_fast)); + + if (!deactivate_lv(cmd, lv_fast)) + log_error("Failed to deactivate previous cachevol in writecache detach."); + + /* + * Needed for lv_is_writecache_origin to know lv_wcorig was + * a writecache origin, which is needed so that the -real + * dm uuid suffix is applied, which is needed for deactivate to + * work. This is a hacky roundabout way of setting the -real + * uuid suffix (it would be nice to have a deactivate command + * that accepts a dm uuid.) + */ + lv_wcorig->status |= WRITECACHE_ORIGIN; + + log_debug("Deactivating previous wcorig %s", display_lvname(lv_wcorig)); + + if (!lv_deactivate(cmd, NULL, lv_wcorig)) + log_error("Failed to deactivate previous wcorig LV in writecache detach."); + + log_debug("Removing previous wcorig %s", display_lvname(lv_wcorig)); + + if (!lv_remove(lv_wcorig)) { + log_error("Failed to remove previous wcorig LV in writecache detach."); + return 0; + } + + lv_set_visible(lv_fast); + lv_fast->status &= ~LV_CACHE_VOL; + + _rename_detached_cvol(cmd, lv_fast); + + if (!vg_write(vg) || !vg_commit(vg)) { + log_error("Failed to write and commit VG in writecache detach."); return 0; } return 1; } +int lv_detach_writecache_cachevol(struct logical_volume *lv, int noflush) +{ + if (lv_is_active(lv)) + return _lv_detach_writecache_cachevol_active(lv, noflush); + else + return _lv_detach_writecache_cachevol_inactive(lv, noflush); +} + diff --git a/test/shell/writecache-split.sh b/test/shell/writecache-split.sh index 0f2dc4729..9553ade0c 100644 --- a/test/shell/writecache-split.sh +++ b/test/shell/writecache-split.sh @@ -20,29 +20,21 @@ mkfs_mount_umount() { lvt=$1 - lvchange -ay $vg/$lvt - mkfs.xfs -f -s size=4096 "$DM_DEV_DIR/$vg/$lvt" mount "$DM_DEV_DIR/$vg/$lvt" "$mount_dir" cp pattern1 "$mount_dir/pattern1" dd if=/dev/zero of="$mount_dir/zeros2M" bs=1M count=32 conv=fdatasync umount "$mount_dir" - - lvchange -an $vg/$lvt } mount_umount() { lvt=$1 - lvchange -ay $vg/$lvt - mount "$DM_DEV_DIR/$vg/$lvt" "$mount_dir" diff pattern1 "$mount_dir/pattern1" dd if="$mount_dir/zeros2M" of=/dev/null bs=1M count=32 umount "$mount_dir" - - lvchange -an $vg/$lvt } aux have_writecache 1 0 0 || skip @@ -62,18 +54,39 @@ lvcreate -n $lv1 -l 16 -an $vg "$dev1" "$dev4" lvcreate -n $lv2 -l 4 -an $vg "$dev2" # -# split when no devs are missing +# split while inactive +# + +lvconvert -y --type writecache --cachevol $lv2 $vg/$lv1 + +lvchange -ay $vg/$lv1 +mkfs_mount_umount $lv1 +lvchange -an $vg/$lv1 + +lvconvert --splitcache $vg/$lv1 +lvs -o segtype $vg/$lv1 | grep linear +lvs -o segtype $vg/$lv2 | grep linear + +lvchange -ay $vg/$lv1 +mount_umount $lv1 +lvchange -an $vg/$lv1 + +# +# split while active # lvconvert -y --type writecache --cachevol $lv2 $vg/$lv1 +lvchange -ay $vg/$lv1 mkfs_mount_umount $lv1 lvconvert --splitcache $vg/$lv1 lvs -o segtype $vg/$lv1 | grep linear lvs -o segtype $vg/$lv2 | grep linear +lvchange -ay $vg/$lv1 mount_umount $lv1 +lvchange -an $vg/$lv1 # # split while cachevol is missing @@ -81,7 +94,9 @@ mount_umount $lv1 lvconvert -y --type writecache --cachevol $lv2 $vg/$lv1 +lvchange -ay $vg/$lv1 mkfs_mount_umount $lv1 +lvchange -an $vg/$lv1 aux disable_dev "$dev2" @@ -108,7 +123,9 @@ lvcreate -n $lv2 -l 14 -an $vg "$dev2" "$dev3" lvconvert -y --type writecache --cachevol $lv2 $vg/$lv1 +lvchange -ay $vg/$lv1 mkfs_mount_umount $lv1 +lvchange -an $vg/$lv1 aux disable_dev "$dev3" diff --git a/tools/lvconvert.c b/tools/lvconvert.c index 76e00f0a2..7935eb74e 100644 --- a/tools/lvconvert.c +++ b/tools/lvconvert.c @@ -5311,19 +5311,8 @@ static int _lvconvert_detach_writecache(struct cmd_context *cmd, struct logical_volume *lv, struct logical_volume *lv_fast) { - char cvol_name[NAME_LEN]; - char *c; int noflush = 0; - /* - * LV must be inactive externally before detaching cache. - */ - - if (lv_info(cmd, lv, 1, NULL, 0, 0)) { - log_error("LV %s must be inactive to detach writecache.", display_lvname(lv)); - return 0; - } - if (!archive(lv->vg)) return_0; @@ -5347,31 +5336,18 @@ static int _lvconvert_detach_writecache(struct cmd_context *cmd, noflush = 1; } - if (!lv_detach_writecache_cachevol(lv, noflush)) - return_0; - /* - * Rename lv_fast back to its original name, without the _cvol - * suffix that was added when lv_fast was attached for caching. + * TODO: send a message to writecache in the kernel to start writing + * back cache data to the origin. Then release the vg lock and monitor + * the progress of that writeback. When it's complete we can reacquire + * the vg lock, rescan the vg (ensure it hasn't changed), and do the + * detach which should be quick since the writeback is complete. If + * this command is canceled while monitoring writeback, it should just + * be rerun. The LV will continue to have the writecache until this + * command is run to completion. */ - if (!dm_strncpy(cvol_name, lv_fast->name, sizeof(cvol_name)) || - !(c = strstr(cvol_name, "_cvol"))) { - log_debug("LV %s has no suffix for cachevol (skipping rename).", - display_lvname(lv_fast)); - } else { - *c = 0; - /* If the name is in use, generate new lvol%d */ - if (lv_name_is_used_in_vg(lv->vg, cvol_name, NULL) && - !generate_lv_name(lv->vg, "lvol%d", cvol_name, sizeof(cvol_name))) { - log_error("Failed to generate unique name for unused logical volume."); - return 0; - } - if (!lv_rename_update(cmd, lv_fast, cvol_name, 0)) - return_0; - } - - if (!vg_write(lv->vg) || !vg_commit(lv->vg)) + if (!lv_detach_writecache_cachevol(lv, noflush)) return_0; backup(lv->vg);

1 0

master - blkdeactivate: add missing VDO_AVAILABLE check in deactivate_vdo
by Peter Rajnoha 08 Jun '20

08 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=8806f2d5ed4792042b246… Commit: 8806f2d5ed4792042b246b930fb44f24b9ee45c2 Parent: fa9eb76a5dc8d76a1f06a44337f909c75df1fee9 Author: Peter Rajnoha <prajnoha(a)redhat.com> AuthorDate: Mon Jun 8 15:41:35 2020 +0200 Committer: Peter Rajnoha <prajnoha(a)redhat.com> CommitterDate: Mon Jun 8 15:41:35 2020 +0200 blkdeactivate: add missing VDO_AVAILABLE check in deactivate_vdo --- scripts/blkdeactivate.sh.in | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/scripts/blkdeactivate.sh.in b/scripts/blkdeactivate.sh.in index 57b3e58bf..7c517b87b 100644 --- a/scripts/blkdeactivate.sh.in +++ b/scripts/blkdeactivate.sh.in @@ -330,6 +330,12 @@ deactivate_vdo() { test -b "$DEV_DIR/mapper/$xname" || return 0 test -z "${SKIP_DEVICE_LIST["$kname"]}" || return 1 + # Skip VDO device deactivation if VDO tools missing. + test "$VDO_AVAILABLE" -eq 0 && { + add_device_to_skip_list + return 1 + } + deactivate_holders "$DEV_DIR/mapper/$xname" || return 1 echo -n " [VDO]: deactivating VDO volume $xname... "

1 0

master - improve info about vgck updatemetadata
by David Teigland 03 Jun '20

03 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=fa9eb76a5dc8d76a1f06a… Commit: fa9eb76a5dc8d76a1f06a44337f909c75df1fee9 Parent: b59127a8386a407407a0361b9bcad028ce31a733 Author: David Teigland <teigland(a)redhat.com> AuthorDate: Wed Jun 3 12:38:27 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Wed Jun 3 12:38:27 2020 -0500 improve info about vgck updatemetadata Add man page info about this option, and add log messages pointing to this option. --- lib/cache/lvmcache.c | 4 ++++ lib/metadata/metadata.c | 4 +++- tools/args.h | 11 ++++++++++- 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/lib/cache/lvmcache.c b/lib/cache/lvmcache.c index 6cb5ff0d8..b1d05fb07 100644 --- a/lib/cache/lvmcache.c +++ b/lib/cache/lvmcache.c @@ -84,6 +84,7 @@ static DM_LIST_INIT(_unused_duplicates); static DM_LIST_INIT(_prev_unused_duplicate_devs); static int _vgs_locked = 0; static int _found_duplicate_vgnames = 0; +static int _outdated_warning = 0; int lvmcache_init(struct cmd_context *cmd) { @@ -1776,6 +1777,9 @@ int lvmcache_update_vg_from_read(struct volume_group *vg, unsigned precommitted) log_warn("WARNING: outdated PV %s seqno %u has been removed in current VG %s seqno %u.", dev_name(info->dev), info->summary_seqno, vg->name, vginfo->seqno); + if (!_outdated_warning++) + log_warn("See vgck --updatemetadata to clear outdated metadata."); + _drop_vginfo(info, vginfo); /* remove from vginfo->infos */ dm_list_add(&vginfo->outdated_infos, &info->list); } diff --git a/lib/metadata/metadata.c b/lib/metadata/metadata.c index 4b8dce902..c0d42066d 100644 --- a/lib/metadata/metadata.c +++ b/lib/metadata/metadata.c @@ -4875,8 +4875,10 @@ static struct volume_group *_vg_read(struct cmd_context *cmd, } } - if (found_old_metadata) + if (found_old_metadata) { log_warn("WARNING: Inconsistent metadata found for VG %s.", vgname); + log_warn("See vgck --updatemetadata to correct inconsistency."); + } vg = NULL; diff --git a/tools/args.h b/tools/args.h index d1f604b0c..5fae21abb 100644 --- a/tools/args.h +++ b/tools/args.h @@ -1428,7 +1428,16 @@ arg(thin_ARG, 'T', "thin", 0, 0, 0, "See \\fBlvmthin\\fP(7) for more information about LVM thin provisioning.\n") arg(updatemetadata_ARG, '\0', "updatemetadata", 0, 0, 0, - "Update VG metadata to correct problems.\n") + "Update VG metadata to correct problems.\n" + "If VG metadata was updated while a PV was missing, and the PV\n" + "reappears with an old version of metadata, then this option\n" + "(or any other command that writes metadata) will update the\n" + "metadata on the previously missing PV. If a PV was removed\n" + "from a VG while it was missing, and the PV reappears, using\n" + "this option will clear the outdated metadata from the previously\n" + "missing PV. If metadata text is damaged on one PV, using this\n" + "option will replace the damaged metadata text. For more severe\n" + "damage, e.g. with headers, see \\fBpvck\\fP(8).\n") arg(uuid_ARG, 'u', "uuid", 0, 0, 0, "#pvchange\n"

1 0

master - Change dev->bcache_fd default value from 0 to -1
by David Teigland 01 Jun '20

01 Jun '20

Gitweb: https://sourceware.org/git/?p=lvm2.git;a=commitdiff;h=b59127a8386a407407a03… Commit: b59127a8386a407407a0361b9bcad028ce31a733 Parent: d14a8040d4a2b264130cdb730cead935b0bf19f0 Author: Zhao Heming <heming.zhao(a)suse.com> AuthorDate: Mon Jun 1 12:22:15 2020 -0500 Committer: David Teigland <teigland(a)redhat.com> CommitterDate: Mon Jun 1 12:22:15 2020 -0500 Change dev->bcache_fd default value from 0 to -1 This fix can avoid bcache_fd will mistakenly open/close in later. Signed-off-by: Zhao Heming <heming.zhao(a)suse.com> --- lib/device/dev-cache.c | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/device/dev-cache.c b/lib/device/dev-cache.c index 6af559cab..c3f7c49be 100644 --- a/lib/device/dev-cache.c +++ b/lib/device/dev-cache.c @@ -65,6 +65,7 @@ static int _insert(const char *path, const struct stat *info, static void _dev_init(struct device *dev) { dev->fd = -1; + dev->bcache_fd = -1; dev->read_ahead = -1; dev->ext.enabled = 0;

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

lvm2-commits June 2020