wipe_lv: use BLKZEROOUT when possible

Since BLKZEROOUT ioctl should be supposedly fastest
way how to clear block device start using this ioctl
for zeroing a device. Commonly we do zero typically
small portion of a device (8KiB) - however since we now
also started to zero metadata devices, in the case
of i.e. thin-pool metadata this can go upto ~16GiB
and here the performance starts to be noticable.

wipe_lv: interruptible wiping

Since we now block signals and wiping may take unexpectedly long
time - support breaking command while wipe is in progress.

wipe_lv: drop label_scan_invalidate on error path

Since dev_set_bytes() now closes  dev on error path itself,
remove this unneeded call now (introduced few commits back
in history thus removing comment from WHATS_NEW)

bcache: use flexible arrays

Cleanup, allocate whole struct with a single malloc call.

bcache: support interrupts when waiting on IO

Since lvm2 normally block signals during protected
phase where it does not want to be interrupted.
Support interruptible processing when allowed
in section between sigint_allow() ... sigint_restore())
and let the 'io_getenvents()'  finish with EINTR.

bcache: fix busy loop with too many errors

When bcache tries to write data to a faulty device,
it may get out of caching blocks and then just busy-loops
on a CPU - so this check protects this by checking
if there is already max_io (~64) errored blocks.

bcache: fix waiting problem for completed IO

Call _wait_all() which does check whether there is still
some pending IO before sleep. Otherwise it may happen
our submitted IO operations have been already dispatched
and this call then endlessly waits for IO which are all done.
This can be reproduced when device returns quickly errors
on write requests.

configure: use our ordered list of python names

Since it seems it's prefered now to use python3 in path name,
prefer this name as first in the list.

configure: update with latest AM_PATH_PYTHON

World has moved towards python3.9.
Although we still don't like path ordering.

configure: check for BLKZEROOUT support

lvconvert: move log message to fix segfault

log message was printing lv name from released vg

improve message for invalid device arg in process_each_pv

Multiple commands process pvs by name using process_each_pv()
and will now have an improved error message for a device
that's excluded by filters.

improve message for invalid device arg

for pvcreate, pvremove, vgcreate, vgextend.

devices: support printing the filter that rejects a device

Use of this new message function needs to be added
to various commands to improve the output.

tests: enable writecache test that uses cleaner

writecache: use two step detach

When detaching a writecache, use the cleaner setting
by default to writeback data prior to suspending the
lv to detach the writecache.  This avoids potentially
blocking for a long period with the device suspended.

Detaching a writecache first sets the cleaner option, waits
for a short period of time (less than a second), and checks
if the writecache has quickly become clean.  If so, the
writecache is detached immediately.  This optimizes the case
where little writeback is needed.

If the writecache does not quickly become clean, then the
detach command leaves the writecache attached with the
cleaner option set.  This leaves the LV in the same state
as if the user had set the cleaner option directly with
lvchange --cachesettings cleaner=1 LV.

After leaving the LV with the cleaner option set, the
detach command will wait and watch the writeback progress,
and will finally detach the writecache when the writeback
is finished.  The detach command does not need to wait
during the writeback phase, and can be canceled, in which
case the LV will remain with the writecache attached and
the cleaner option set.  When the user runs the detach
command again it will complete the detach.

To detach a writecache directly, without using the cleaner
step (which has been the approach previously), add the
option --cachesettings cleaner=0 to the detach command.

pvcreate/pvremove: reimplement device checks

Reorganize checking the device args for pvcreate/pvremove
to prepare for future changes.  There should be no change
in behavior.  Stop the inverted use of process_each_pv,
which pulled in a lot of unnecessary processing, and call
the check functions on each device directly.

test: grep -q may fail and it does

The script runs with pipefail, grep -q exits immediately sending SIGPIPE
to lvm segtype which fails whole pipe.

lvmlockd vdo: add support

lvmlockd handling for vdo lv and vdo pool is like
thin lv and thin pool.

lvmlockd vdo: disallow use of shared lock on LV

vdo cannot be active on multiple hosts concurrently

tests: thin-flags

debug: remove stacktrace on regular path

Here _insert is expected to also fail, so just regular 'return 0'.

debug: update debug message

active: fix compilation without devmapper

Better support for compilation without device-mapper.

thin: remove unneeded code test

Since we detect already transaction if before starting
to build dm tree - this extra check is a duplicate
that would only capture very tiny 'race' and we later
validate transaction_id with suspended snapshot origin.

thin: validate thin-pool state before sending messages

Alhtough lvm2 does validation on its side, ensure DM code
is not sending messages to failed thin pool.

thin: use lv_status_thin and lv_status_thin_pool

Introduce structures lv_status_thin_pool and
lv_status_thin  (pair to lv_status_cache, lv_status_vdo)

Convert lv_thin_percent() -> lv_thin_status()
and  lv_thin_pool_percent() + lv_thin_pool_transaction_id() ->
lv_thin_pool_status().

This way a function user can see not only percentages, but also
other important status info about thin-pool.

TODO:
This patch tries to not change too many other things,
but pool_below_threshold() now uses new thin-pool info to return
failure if thin-pool cannot be actually modified.
This should be handle separately in a better way.

writecache: archive before modification of metadata

Archive before we start to modify metadata.

cleanup: avoid unneeded check

Since creation of thin snapshot already makes sure,
the message list is empty, there is no need to check
this again.

activation: move locking of critical section

Move begining of 'suspending' critical section closer to _lv_suspend_lv()
for better correctness of error paths.

configure: update help

Help shows new defaults.

configure: editline updates

Update configure file.

lvm: add readline alternative editline

LVM2 is distributed under GPLv2 only. The readline library changed its
license long ago to GPLv3. Given that those licenses are incompatible
and you follow the FSF in their interpretation that dynamically linking
creates a derivative work, distributing LVM2 linked against a current
readline version might be legally problematic.

Add support for the BSD licensed editline library as an alternative for
readline.

Link: https://thrysoee.dk/editline

tests: add case for metadata checksum differences

Cover the case where two copies of metadata have the
same seqno but different checksums.  Also elaborate
on an existing fixme in the code for this case, since
we should be doing something better for this case.

This had been uncovering an issue with reopening
fds in readwrite mode.

lvpoll: don't use hints

There's a bug when lvpoll attempts to write new hints,
related to the fact that lvpoll does not follow the same
scanning process as standard commands.
Fix by disabling the use of hints in lvpoll.  We may want
to renable hints in lvpoll in a way that they can be used,
if valid, but not updated if they don't exist or are invalid.

scanning: keep open an lvm device with scanning problem

The command may want to update it.

devices: fix reopen for unopened device

If there's a request to reopen rw a device that's not
open, then just call the normal open function.

Revert "lvconvert: display warning if raid1 LV image count does not change"

This reverts superfluous commit 3c9177fdc0b8f94c0ae335790a485477901b685d as
_lv_raid_change_image_count() already checks for non-changed image count.

Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1872130

tests: add small delay

Prevent there is no i.e. udev trying to open our device.

tests: also add thick snap of thin volume

tests: check some common errors

Collect some cases users are hitting when working
with thin-pools which has mismatching kernel metadata content with
lvm2 metadata.

tests: vgsplit of vdo volumes

makefiles: document supported var in make help

thin: pass through whole code

Instead of early 'return 0' let the whole code finish
in case of an error with syncing.

device_mapper: enhance error message

thin: improve error message

Add more info, explaing why the suspend of thin snapshot origin was omitted.

thin: enhance lvcreate error paths

Improve error response and reporting, when creating thin snapshots.
If the thin pool kernel metadata already have device with ID lvm2
tries to create, give more meanigful error message and also properly
restore transaction id to the value known to thin-pool in this case.

Before it's been possible to divert by one from kernel TID value,
and lvm2 stacked delete message for such thin device.

thin: no delete message for device_id 0

Since we always use device_id > 0, we could use
device_id == 0 to actually mark thinLV as an
LV we want to remove without delete message.

vgsplit: support for VDO volumes

Enable support and ensure VDO always moves with VDOPOOL.

tests: basic test for vdo on raid LV

Check stacing of VDO on top of raid LV works.

tests: add check for rename of cached vdopool

tests: a bit bigger mirrors

Seems even with throttling we occasinally need slightly more.

lvconvert: suppport vdo raid conversion also through vpool

User could directly use 'vdopool' LV name for conversion into raid.
(lvconvert --type raid1 vg/vdopool)

vdo: allow passing renamed vdopool name to kernel

Although kernel does not allow to load a new dm table
with renamed vdopool, at least make lvm2 code ready
it it every will get supported.

vdo: disable support for online rename of vdopool LV

Since ATM kernel does not support this operation,
disable 'lvrename' of an active vdopool.

As a workaround, user may simply deactivate, rename and activate.

tests: use aux wrapper and add more notes

This test seems to be hitting some corner case in handling
out-of-metadata space condintion in thin-pool.

Add few more aid notes and functionality.

Also add missing '|| true' with now direct-IO dd command.

tests: move function to aux for reuse

tests: update test

Shorten running time of the test.
Fix some issues in invoked resizing script to it returns
correct return code and dmeventd can be a little bit quicker
in this test.

tests: check vdopool policy extension

Check pool will grow even with small policy amount.

vdo: enhance vdo pool extension

When user tries to extend vdo pool - he needs to go always
at least by 1 full VDO slab  (defined as  vdo_slab_size_mb).

To avoid all trouble around find 'workable' size - lvm2 automatically
increases the passed (or by --use-policies calculated) extension size
(and informs a user about sometimes possibly large increase as slab
size can go upto 32GiB)

With VDO users need to always 'think-big' anyway and expect such
operation to be in GiB domain range.

vdo: extend vdo segment validation

Try to catch all suspicious VDO segments in metadata early.

vdo: correct message about policy extend support

Policy extend is already supported for vdo pools as well,
so correct the error message.

vdo: drop unnecessary tabulator from metadata output

activation: use revert_lv on tree suspend failure

When thetable reload fails during suspend() - we were only calling
plain resume() - and this will reload only those devices,
which were left suspend, but will not try to restore
metadata state according to lvm2 reverted metadata.
So if we were reloading device tree - we have restored
only top-level LV and rest of reverted device manipulation
were left alone and possibly mismatched what is in committed
metadata.

FIXME: There are several cases were such revert will likely not work
properly anyway as some operation are currenly handled in single commit,
while they need multiple commits, but it's step towards better correctness.
At least we catch there errors now earlier.

tests: fix cleanup for unbound variables

When loop can't handle sector-size option - failure caused double fail
for access of unbound variable
Also fix expression for 'rm' and remove loops after loop release.

tests: add FIXME case

tests: use DIRECT io for zeroing whenver we can

Performance with direct I/O here is noticable better,
so use it instead of buffered write whenever we can.

tests: use 4K with mkfs.xfs

If the test runs of loop device backend with 512 sectors,
xfs selects this smaller sector size and then data do not fit
(we would need -l9 with most of 'raids').
With 4K sectors data always fits.

tests: skip with fail of first prepare_scsi

tests: check for cvol

Check for cvol.
Add check for cmeta.

bache: fix error return value

Return 0 as failure (as checked for).
Also add INTERNAL_ERROR if  'DI' would be -1.

tests: use parametrized function

Shorten and make the test easily readable by moving same code into
function and removed one duplicated test for 512,4096 combination.

Always use scsi_debug - since default ramdisk or loop device backend
is unpredictible.

tests: use zero backend

Since we are not reading read - just use zero device as backend for
test, so we do not eat real disk space.

tests: use faster awk generator

Shortens log length.

tests: ensure mnt is defined before trap install

tests: reduce disk usage

metadata: open rw fd before closing ro fd

lvm opens devices readonly to scan them, but
needs to open then readwrite to update the metadata.
Previously, the ro fd was closed before the rw fd
was opened, leaving a small gap where the dev was
not held open, and during which the dev could
possibly change which storage it referred to.

With the bcache_change_fd() interface, lvm opens a
rw fd on a device to be written, tells bcache to
change to the new rw fd, and closes the ro fd.

. open dev ro
. read dev with the ro fd (label_scan)
. lock vg (ex for writing)
. open dev rw
. close ro fd
. rescan dev to check if the metadata changed
  between the scan and the lock
. if the metadata did change, reread in full
. write the metadata

bcache: use indirection table for fd

Add a "device index" (di) for each device, and use this
in the bcache api to the rest of lvm.  This replaces the
file descriptor (fd) in the api.  The rest of lvm uses
new functions bcache_set_fd(), bcache_clear_fd(), and
bcache_change_fd() to control which fd bcache uses for
io to a particular device.

. lvm opens a dev and gets and fd.
  fd = open(dev);

. lvm passes fd to the bcache layer and gets a di
  to use in the bcache api for the dev.
  di = bcache_set_fd(fd);

. lvm uses bcache functions, passing di for the dev.
  bcache_write_bytes(di, ...), etc.

. bcache translates di to fd to do io.

. lvm closes the device and clears the di/fd bcache state.
  close(fd);
  bcache_clear_fd(di);

In the bcache layer, a di-to-fd translation table
(int *_fd_table) is added.  When bcache needs to
perform io on a di, it uses _fd_table[di].

In the following commit, lvm will make use of the new
bcache_change_fd() function to change the fd that
bcache uses for the dev, without dropping cached blocks.

tests:  printf to awk

Shorten trace logs.

tests: update integrity-dmeventd

Use tee.
Switch to more simple generator with awk
(which doesn't produce long debug trace)
Sync before sleep to provoke raid action.

tests: enhance low-disk-space behavior

Use new SKIP_WITH_LOW_SPACE and set higher requirement for free space.

But still this test can't run on system's tmpfs directories -
as they typically provide less then 2G of space and when the test
runs there it also provisioning for all READ pages!)
BRD (ramdisk) device should work.

Extend a _wait_recalc() loop for slower hw.
When creating large raid which do not need to be fully synchronized use
them on delay devices - so even less data needs read/write.
Remove unneeded lvchange as lvcreate is already leaving LV inactive.
Replace printf with awk as generator.

mm

tests: inittest supports SKIP_WITH_LOW_SPACE

Test can set individually a higher value for required free space on
storage.

Note: it is not fully reliable since when 'brd' (ramdisk) device is used
this free space value is rather meanigul, but it might help
in case where a real filesystem is doing back-end for test devices.

tests: utils better handle ouf of disk space

When the test exhausts all the available free space on storage device,
then during the fail we cannot write anything as well - yet
the teardown needs to finish it's work - otherwise we leave
basicaly overfilled filesystem for all remaining tests.

tests: aux better handle invalid table

In cases where internal functions like zero_dev, delay_dev pass-in
invalid parameter so resulting table can't work, resume at least
previous table line before failing out - so the cleaning process
later on is not stuck waiting on a suspended device.

tests: also use sed to shorten log output

tests: resolve missing removal of loopdevice on error path

In case of test failure, loop device leaked and occupied space forever.

tests: bigger data still needed for 0.7.0

tests: lower memory usage

Reduce memory needed by test at one time.

configure: enable integrity by default

hints: enhance debug messages

label: cleanup set_byte error exit

Revert "label: use formaters FMTu64 and FMTsize_t"

This reverts commit d0ccb2521ba4f34455078f87f46cc41f5761ffc0.

tests: smaller delay and lowered version

See if this will still work. Some boxes are delayed too much.
Also try to check for raid extend progress from version 1.13.

tests: fix bash regex syntax

Typo before last commit.

tests: switch for checking version of installed tools

It looks like older tools were compacting metadata more.

tests: skip kernel for this test

Kills this kernel ATM

label: use formaters FMTu64 and FMTsize_t

Produces code without casts to differntly signed types
and also shortens and enhances readbility.

wipe: dev_set_bytes resolves zeroing

Since dev_write_zeros() is just subset of dev_set_bytes()
use it directly and simplify code.

wipe: convert zero_value to uint8_t

We always write this value as byte.

wipe: zeroing of 8 sectors is granted

With do_zero min is always 8 sectors, so use 0 as default.