toolib: early validation of chunk size

Since we now have validate_pool_chunk_size() we could
validate entered values directly prior openning vg.

pool: use validation

pool: validate_pool_chunk_size

Introduce pool function for validation of chunk size.
It's good idea to be able to reject invalid chunk size
when entered on command line before we open VG.

man: document -ff for removal

Make it visible in man page that -ff could make removal
process proceed in case of damaged pool.

vg/lvremove: support --yes

Make --yes equivalent to DONT_PROMT (--force).

So user could use 'lvremove --yes vg/lvol1' skipping prompt.

man: lvconvert new split options

Update man page with info how to split/uncache cached logical
volumes.

lvconvert: splitsnapshot support --yes

Allow to use --yes to skip prompt.

lvconvert: splitsnapshot supports --yes

Handle --yes arg to skip prompt.

lvconvert more test for thin external origin

Some LV types were not properly disallowed to be used as external origin.

lvconvert: cache and thin conversion validation

More test for supported conversion.

lvconvert: validate cache conversion to snapshot

Cache cannot be converted into snapshot cow nor origin.

cache: use same alg for cache size calc

Use the same algorithm for cache metadata size as the cache tool is using.

cache: improve creation code

Move code to better locations.
Improve test and remove invalid ones
(i.e. no reason to require cache size to be >= then origin).

Correctly comment where the code is doing actual conversion
of other existing volume - we do already a similar thing with
external origins.

Lots of new command line options and combinations is now supported.
Hopefully older syntax still works as well.

lvcreate --cache --cachepool vg/pool  -l1
lvcreate --type cache --cachepool vg/pool  -l1
lvcreate --type cache-pool vg/pool  -l1
lvcreate --type cache-pool --name pool vg  -l1
... and many many more ...

lvremove: detect cluster wide active state

If the LV is active remotely do not skip question for deactivation.

cache: check activation of volume activated

volume_list may silently skip activation which is then still reported as
success.

cache: lvremoved cached LV removes cache pool

When we remove cached volume, whole tree must go down.
There is  'lvconvert --splitcache' to preserve cache pool.

pools: move removal of _pmspare

Since _pmspare is internal volume move it to
lv_remove_single -  so it's automatically removed with
last remove thin-pool.

lv_remove_with_dependencies() is not always used for pool removal.

lvcreate: reuse validation of names

Use validate_lvname_param() for name validation.

lv_manip: fix out of order backup

We had only 2 remaining places that were leaving unbackuped metadata.

lvconvert: reuse cache validation

Validation is now already in
validate_lv_cache_create() so reuse it.

Also properly rename var origin -> origin_lv.

cache: add validate_lv_cache_create

Move validation tests into separate function.

lvconvert: options splitcache, split, uncache

  --splitcache
  Splits only cached LV (also pool could be specified).
  Detaches cachepool from cached LV.

  --split
  Should be univerzal command to split various complex targets.
  At this moment it knows cache.

  --uncache
  Opposite command to --cache. Detaches and DELETES cachepool for
  cached LV.

Note: we support thin pool cached metadata device for uncaching.
Also use may specify wither cached LV or association cachepool device
to request split of cache.

toollib: validate also name

In validate_lvname_param() call also validate_name().

lvcreate: support --cache and --cachepool

Enable in cmdline options for cache and cachepool.

commands: support shortcut -H for cache objects

Introduce cache_long_ARG for those instancies
where --cache is not related to caching LV.
(pvchange,vg|lv|pvscan).

cache_ARG is now with -H shortcut.

thin: better thin snapshot error detection

While creating thin snapshot, we cannot use size argument.

thin: lvcreate improve check of thin params

Use arg_from_list_is_set()
Resolve pool_lv at one single place.
Replace use of find_lv_in_vg() with find_lv().

lvcreate: refactor code

Over the time lvcreate code has accumulated various hacks.
So try to move that code in right places.

Detect all types early in _lvcreate_params() so functions like
_read_size_params() do not need to change volume types.

Also ultimately respect give volume --type, that its shortcut
(-T, H, -m, -s) and after that options which do type estimation.
(i.e. --cachepool, --thinpool)

Avoid repeative tests - if we know all types are decode at once
place we can 'optimize' number of validations.

test: Show an activation bug in lvcreate of a cache over raid.

lvconvert: Forward --splitmirror to a cache origin when applicable.

toollib: Rewrite process_each_lv.

Copy the same form as the new process_each_vg.
Replace unused struct cmd_vg and cmd_vg_read() replicator
code with struct vg and vg_read() directly.
The failed_lvnames arg is no longer used since the
cmd_vg replicator wrapper was removed.

[Committed by agk with cosmetic changes and tweaks.]

toollib: Rewrite process_each_vg.

Split VG argument collection from processing.
This allows the two different loops through VGs to
be replaced by a single loop.
Replace unused struct cmd_vg and cmd_vg_read() replicator
code with struct vg and vg_read() directly.

[Committed by agk with cosmetic changes and tweaks.]

man: lvmcache better cache mode info and other command variations

cache: include cache mode in vg metadata and display

The cache mode of a new cache pool is always explicitly
included in the vg metadata.  If a cache mode is not
specified on the command line, the cache mode is taken
from lvm.conf allocation/cache_pool_cachemode, which
defaults to "writethrough".

The cache mode can be displayed with lvs -o+cachemode.

cleanup: remove compiler warning about possible uninitialized variable use

filters/filter-usable.c:22: warning: "ucp.check_..." may be used uninitialized in this function

This can't actually be hit in real, but let's clean this up for the compiler
to be happy again.

filters: add cmd->full_filter - composite of cmd->filter and cmd->lvmetad_filter

There are actually three filter chains if lvmetad is used:
  - cmd->lvmetad_filter used when when scanning devices for lvmetad
  - cmd->filter used when processing lvmetad responses
  - cmd->full_fiilter (which is just cmd->lvmetad_filter + cmd->filter chained together) used
    for remaining situations

This patch adds the third one - "cmd->full_filter" - currently this is
used if device processing does not fall into any of the groups before,
for example, devices which does not have the PV label yet and we're just
creating a new one or we're processing the devices where the list of the
devices (PVs) is not returned by lvmetad initially.

Currently, the cmd->full_filter is used exactly in these functions:
  - lvmcache_label_scan
  - _pvcreate_check
  - pvcreate_vol
  - lvmdiskscan
  - pvscan
  - _process_each_label

If lvmetad is used, then simply cmd->full_filter == cmd->filter because
cmd->lvmetad_filter is NULL in this case.

cleanup: remove symlink to profile in test dir for CLEAN target

tools: Add ENABLE_ALL_DEVS flag.

The ENABLE_ALL_DEVS flag is added to the command structure
for commands that should process all devs (pvs and non-pvs)
when they call process_each_pv and the command includes the
--all arg.  This will be used in a later process_each_pv patch.

tools: Add ALL_VGS_IS_DEFAULT flag.

The ALL_VGS_IS_DEFAULT flag is added to the command structure
for commands that should process all vgs when they call
process_each_vg or process_each_lv with no args.
This will be used in later patches to process_each functions.

man: lvmthin mention alternate syntax

Users will probably run across the alternate syntax,
so we should explain how it relates to what is used here.

Revert "Revert "man: lvmcache should use clearer cache pool options""

This reverts commit f120c954fc065d67c1aacd5cfba58843eb552b0f.

filters: refresh filters when lvmetad use is toggled

We need to use proper filter chain when we disable lvmetad use
explicitly in the code by calling lvmetad_set_active(0) while
overriding existing configuration. We need to reinitialize filters
in this case so proper filter chain is used. The same applies
for the other way round - when we enable lvmetad use explicitly in
the code (though this is not yet used).

filters: use usable device filter and separate lvmetad filter chain so it's not reevaluated for any lvmetad response

With this change, the filter chains used look like this now:

  A) When *lvmetad is not used*:
    - persistent filter -> regex filter -> sysfs filter ->
      global regex filter -> type filter ->
      usable device filter(FILTER_MODE_NO_LVMETAD) ->
      mpath component filter -> partitioned filter ->
      md component filter

  B) When *lvmetad is used* (two separate filter chains):
     - the lvmetad filter chain used when scanning devs for lvmetad update:
       sysfs filter -> global regex filter -> type filter ->
       usable device filter(FILTER_MODE_PRE_LVMETAD) ->
       mpath component filter -> partitioned filter ->
       md component filter

     - the filter chain used for lvmetad responses:
       persistent filter -> usable device filter(FILTER_MODE_POST_LVMETAD) ->
       regex filter

filters: add "usable device" filter

Usable device filter is responsible for filtering out unusable DM devices.
The filter has 3 modes of operation:

  - FILTER_MODE_NO_LVMETAD:
    When this mode is used, we check DM device usability by looking:
      - whether device is empty
      - whether device is blocked
      - whether device is suspended (only on devices/ignore_suspended_devices=1)
      - whether device uses an error target
      - whether device name/uuid is reserved

  - FILTER_MODE_PRE_LVMETAD:
    When this mode is used, we check DM device usability by looking:
      - whether device is empty
      - whether device is suspended (only on devices/ignore_suspended_devices=1)
      - whether device uses an error target
      - whether device name/uuid is reserved

  - FILTER_MODE_POST_LVMETAD:
    When this mode is used, we check DM device usability by looking:
      - whether device is blocked
      - whether device is suspended (only on devices/ignore_suspended_devices=1)

These modes will be used by subsequent patch to create different
instances of this filter, depending on lvmetad use.

refactor: make it possible to select what to check exactly when calling device_is_usable fn

Currently, there are 5 things that device_is_usable function checks
(for DM devices only, of course):
  - is device empty?
  - is device blocked? (mirror)
  - is device suspended?
  - is device composed of an error target?
  - is device name/uuid reserved?

If answer to any of these questions is "yes", then the device is not usable.
This patch just adds possibility to choose what to check for exactly - the
device_is_usable function now accepts struct dev_usable_check_params make
this selection possible. This is going to be used by subsequent patches.

conf: Update comments on lvmetad+filters in example.conf.in.

man: lvmthin remove unnecessary fixme

The existing method for single step thin-pool + thin creation
makes sense.

Revert "Revert "man: lvmthin should use clearer thin pool options""

This reverts commit 17a1869df506a3641d49d52c413b5bc04ec2adc9.

We've agreed on the clearer syntax.

valgrind: don't eat mem with valgrind

When compiled with valgrind pool support - don't waste time
with preallocation of memory - it just waste of CPU cycles to
trace access to this memory.

We also may get slightly better estimation about real memory usage
during command processing.

cleanup: drop unused variable

lvconvert: switch to validate_lvname_param

Use new toollib function for validation.

toollib: introduce validate_lvname_param

Function for parsing and validating of lvname parameter.

cleanup: rename func

Update name of function read_and_validate_major_minor
and put it into the right header file toollib.h.

(In release update for f09f85d027d8833)

toollib: refactor extract_vgname

Split internals of extract_vgname into _extract_vgname.
This common code will be used for other similar function.

Reuse skip_dev_dir() instead of less mature coded to skip
device dir.

Instead of duplicating full vg/lv name - allocate string
only vg portion of lv name.

toollib: refactor skip_dev_dir

Detect dev dir just once.

Revert "man: lvmcache should use clearer cache pool options"

Revert: --cachepool  and --thipnpool is the right way

they both take arg

This is a major difference from  --cache   and --thin

Revert "man: lvmthin should use clearer thin pool options"

Revert: --cachepool  and --thipnpool is the right way

they both take arg

This is a major difference from  --cache   and --thin

man: lvmthin should use clearer thin pool options

Previously, this was the recommended form for creating a thin pool:

lvconvert --thinpool VG/ThinDataLV --poolmetadata VG/ThinMetaLV

but this is confusing, because --thinpool does not actually take
an arg, and is more naturally used to specify an existing thin pool.

The new recommended form is:

lvconvert --type thin-pool --poolmetadata VG/ThinMetaLV VG/ThinDataLV

man: lvmcache should use clearer cache pool options

Previously, this was the recommended form for creating a cache pool:

lvconvert --cachepool VG/CacheDataLV --poolmetadata VG/CacheMetaLV

but this is confusing, because --cachepool does not actually take
an arg, and is more natually used to specify an existing cache pool.

The new recommended form is:

lvconvert --type cache-pool --poolmetadata VG/CacheMetaLV VG/CacheDataLV

lvchange: missed bits for a8aee7dba2b76

lv_info is not used here any more.
This code should have been committed with
lv_check_not_in_use API change commit.

cleanup: Use segtype.h definitions of segment type names wherever possible

We are not using already defined segement type names where we could.

There is a lot of other places in device-mapper and LVM2 we have those
hardcoded so we should better finally have a common interface in
libdevmapper to avoid this.

tests: add helper funcionality for using gdb

When there is need for using gdb within test suite
just prefix command with LVM_DBG and run test in
standard shell (for stdin).

tests: drop * from dmsetup

We cannot use shell expansion for dmsetup here.

debug: add debug message

Since we leave error printing on the called of deactivation,
at least put in debug log for this case.

debug: show stacktrace on error path

debug: drop printing debug trace without labeler

Not having labeller on device is not reason eo generate backtrace in log.

debug: add missing stack trace

debug: monitor_dev_for_events stack trace

cleanup: reindent

Save some code lines.

cleanup: drop duplicate const usage

const char == const char const.

cleanup: drop uneeded backup call

lv_update_and_reload already handle backup.

cleanup: use supplied cmd pointer

cleanup: fix typo and use vg mempool

Since we are updating VG -  we can use its own mempool.

cleanup: replace error with print message

These are not error messages.
They are informing a user about missconfigured
options which do not change resulting error status.

cleanup: simplier _lv_passes_volumes_filter

Don't recreate string and just check components directly.

cleanup: use find_lv_in_vg_by_lvid

Replace another loop with existion function.

TODO: consider using hash maps for lvname & lvid lookups.

activate: update lv_check_not_in_use: API

Use of lv_info() internally in lv_check_not_in_use(),
so it always could use with_open_count properly.

Skip sysfs() testing in open_count == 0 case.

Accept just 'lv' pointer like other functions.

The function has 'built-in' lv_is_active_locally check,
which however is not what we need to check in many place.
For now at least remotely active snapshot merge is
detected and for this case merge on next activation is scheduled.

lvconvert: reoder old snapshot merge

Move check for snapshot-merge support before archiving.

Split code on 2 paths - with merge_on_activate
using vg_write & vg_commit
and lv_update_reload call for instant merging.

Move printing after backup.

cleanup: constify activation usage of lv pointer

Let's enforce cheking of write access to LV by compiler.
Activation part does never need to write anything to LV
so keep LV pointer const.

cleanup: move printing after backup

Print successful result after making backup.
In this place we are sure to not keep memlock.

validation: move check for spare correctness

Check lv feature when we check LVs

vgchange: use NULL 'feature' of lv_info call

When NULL is passed for info the call itself
already does the same evaluation.

vgchange: add sync point

Before leaving _activate_lvs_in_vg() wait till devices
are active - so we do not print message about active
devices earlier then it really happens for a user.

thin and cache: improve conversion validation

More validations before any thin or cache related conversion begins.

We allow to use and stack:

pool data: cache or raid
pool metadata: raid

pool:  linear, striped
cache: linear, striped, raid
thin(extorig): linear, origin, cow, virtual, thin

thin: no pool can be used for external origins

Cache pool can't be external origin either.
For simplicity use vg from passed LV.

snapshot: use lv_update_and_reload

snapshot: add missing vg_revert

Error path missed vg_revert call.

mirror: extend adjusted_mirror_region_size API

We use adjusted_mirror_region_size() in two different contexts.

Either on command line -
 here we do want to inform user about reduction of size.

Or in pvmove activation context -
 here we should only use 'verbose' info.

lv_update_and_reload: use proper lock holder

When requesting to reload an LV imrove this API to
automatically reload its lock holding LV as in cluster
only top-level LVs are addressable with lock.

lv_ondisk: option search for lv without vg_ondisk

When vg_ondisk is NULL we do not need to search
through the whole VG to find out the same LV.

NOTE: as of now - VG locking is not enabled as some code parts
are breaking memory locking rules (lvm2app).

Once we enforce VG locking for read-only commands the effect
will be much better for larger VGs.

activate: lv_check_not_in_use no check of closed

Don't perform expensive sysfs tests when the device is closed.
(having open_count == 0).

fix: regression for recent persistent commit

Do not let fly metadata with just 'minor' set
(since they would not be readable on older version)

Be permissive with invalid major/minor number and
just report them as problem, but allow to use
such metadata with default major:minor.

cleanup: use int32 for major minor

Use consistently int32_t for major, minor.

cache: fix regression and invert test

Last commit c710f02e0181cc2db5455f0c98033247a70ecc30
converting code to use lv_update_and_reload()
intoduced invalid test for error result.
Fix it and properly check for  if (!...)

debug: enhance mmap catch code

Use nice instruction_HLT macro
Use log_debug_mem()
Don't actually log things after we prohibit 'mmap'.
Move initialization of strerror & udev before blocking mmap.

man: document obsoleted options

It's shown on comand line help and it's accepted argument,
so provide matching man entry.

backup: drops locked memory

Since we want to backup metadata, this is the point
we no longer want to hold memory locked.

cleanup: lvchange remove some extra code.

We do not need to restore LV content on error path - since
for reactivation we always use  ondisk/commited metadata,
so passed data are never used.

Drop some unneded extra message, since the called function
repeated logs same info.

lvchange: backup final metadata

Shift backup after final metadata commit.

Synchronize with wiping.

tools: common handling of --persistent option

Move common code for reading and processing
of --persistent arguments for lvcreate and lvchange
into lvmcmdline.

Reuse validate_major_minor() routine for validation.

Don't blindly activate LVs after change in cluster
and instead only local reactivation is supported.
(we have now many limited targets now).

Dropping 'sigint_caught()' handling, since
prompt() is resolving this case itself.

metadata: validate major, minor numbers

Validate major, minor numbers after reading them from metadata.