WIP: Diagnostics

[WIP] Session bus is still not working
[WIP] More verbose...
2025-10-04 05:44:18 +03:00 · 2016-03-23 15:50:46 +01:00 · 2016-03-23 12:28:24 +01:00 · 2016-03-23 12:28:24 +01:00 · 2016-03-23 12:27:34 +01:00
336 changed files with 7807 additions and 28598 deletions
--- a/2
+++ b/2
@@ -1 +1 @@
-2.02.166(2)-git (2016-09-07)
+2.02.148(2)-git (2016-03-19)
--- a/2
+++ b/2
@@ -1 +1 @@
-1.02.135-git (2016-09-07)
+1.02.121-git (2016-03-19)
--- a/239
+++ b/239
@@ -1,242 +1,5 @@
-Version 2.02.166 - 
-=====================================
-  Fix possible NULL pointer derefence when checking for monitoring.
-  Add lvmreport(7) man page.
-  Don't install lvmraid(7) man page when raid excluded. (2.02.165)
-  Report 0% as dirty (copy%) for cache without any used block.
-  Fix lvm2api reporting of cache data and metadata percent.
-  Restore reporting of metadata usage for cache volumes (2.02.155).
-  Support raid scrubbing on cache origin LV.
-
-Version 2.02.165 - 7th September 2016
-=====================================
-  Add lvmraid(7) man page.
-  Use udev db to check for mpath components before running pvscan for lvmetad.
-  Use lsblk -s and lsblk -O in lvmdump only if these options are supported.
-  Fix number of stripes shown in lvcreate raid10 message when too many.
-  Change lvmdbusd to use new lvm shell facilities.
-  Do not monitor cache-pool metadata when LV is just being cleared.
-  Add allocation/cache_pool_max_chunks to prevent misuse of cache target.
-  Give error not segfault in lvconvert --splitmirrors when PV lies outside LV.
-  Fix typo in report/columns_as_rows config option name recognition (2.02.99).
-  Avoid PV tags when checking allocation against parallel PVs.
-  Disallow mirror conversions of raid10 volumes.
-  Fix dmeventd unmonitoring when segment type (and dso) changes.
-  Don't allow lvconvert --repair on raid0 devices or attempt to monitor them.
-  No longer adjust incorrect number of raid stripes supplied to lvcreate.
-  Move lcm and gcd to lib/misc.
-  Fix vgsplit of external origins. (2.02.162)
-  Prohibit creation of RAID LVs unless VG extent size is at least the page size.
-  Suppress some unnecessary --stripesize parameter warnings.
-  Fix 'pvmove -n name ...' to prohibit collocation of RAID SubLVs
-
-Version 2.02.164 - 15th August 2016
-===================================
-  Fix selection of PVs when allocating raid0_meta.
-  Fix sdbus socket leak leading to hang in lvmnotify.
-  Specify max stripes for raid LV types: raid0:64; 1:10; 4,5:63; 6:62; 10:32.
-  Avoid double suffix when naming _rmeta LV paired with _rimage LV.
-
-Version 2.02.163 - 10th August 2016
-===================================
-  Add profile for lvmdbusd which uses lvm shell json report output.
-  Restrict in-command modification of some parms in lvm shell.
-  Apply LVM_COMMAND_PROFILE early for lvm shell.
-  Refactor reporting so lvm shell log report collects whole of cmd execution.
-  Support LVM_*_FD envvars to redirect output to file descriptors.
-  Limit use of --corelog and --mirrorlog to mirrors in lvconvert.
-  Reject --nosync option for RAID6 LVs in lvcreate.
-  Do not refresh whole cmd context if profile dropped after processing LVM cmd.
-  Support straightforward lvconvert between striped and raid4 LVs.
-  Support straightforward lvconvert between raid1 and mirror LVs.
-  Report supported conversions when asked for unsupported raid lvconvert.
-  Add "--rebuild PV" option to lvchange to allow for PV selective rebuilds.
-  Preserve existing mirror region size when using --repair.
-  Forbid stripe parameters with lvconvert --repair.
-  Unify stripe size validation into get_stripe_params to catch missing cases.
-  Further lvconvert validation logic refactoring.
-
-Version 2.02.162 - 28th July 2016
-=================================
-  Extend vg_validate also to check raid configurations thoroughly.
-  Support lvconvert -Zn also when doing full cache pool conversion.
-  Suppress not zeroing warn when converting to thin LV for non-zeroing tpool.
-  Fix automatic updates of PV extension headers to newest version.
-  Improve lvconvert --trackchanges validation to require --splitmirrors 1.
-  Add note about lastlog built-in command to lvm man page.
-  Fix unrecognised segtype flag message.
-  lvconvert not clears cache pool metadata ONLY with -Zn.
-  Add allocation/raid_stripe_all_devices to reinstate previous behaviour.
-  Create raid stripes across fixed small numbers of PVs instead of all PVs.
-  Enabled lvconvert --uncache to work with partial VG.
-  Disallow lvconvert --replace with raid0* LVs.
-  Fix some lvmetad changed VG metadata notifications that sent uncommitted data.
-
-Version 2.02.161 - 15th July 2016
-=================================
-  Prohibit some lvchange/lvresize that were failing on raid0 volumes.
-  Fix segfaults in complex vgsplits. (2.02.159)
-  Reformat unwieldy lvconvert man page.
-  Allow --force to be passed through to pvcreate from vgcreate. (2.02.144)
-  Fix lvresize of filesystem when LV has already right size (2.02.141)
-  New LVM_LOG_FILE_MAX_LINES env var to limit max size of created logs.
-
-Version 2.02.160 - 6th July 2016
-================================
-  Minor fixes from coverity.
-
-Version 2.02.159 - 6th July 2016
-================================
-  Add raid0_meta segment type that provides metadata space for raid conversions.
-  Fix created link for a used pool for vgmknode.
-  Introduce and use is_power_of_2 macro.
-  Support conversions between striped and raid0 segment types.
-  Add infrastructure for raid takeover lvconvert options.
-
-Version 2.02.158 - 25th June 2016
-=================================
-  Add a more efficient native vgimportclone command to replace the script.
-  Make lvmlockd always attempt to connect to lvmetad if no connection exists.
-  Let lvmetad handle new connections after shutdown signal.
-  Disable lvmetad when vgcfgrestore begins and enable it again after.
-  Make pvscan do activation if lvmetad is configured but not running.
-  Fix rescanning the PVs for a single VG when using lvmetad.
-  Pool metadata lvresize uses now same code as resize of normal volume.
-  Preserve monitoring status when updating thin-pool metadata.
-  Return 0 (inactive) when status cannot be queried in _lv_active().
-  Switch to log_warn() for failing activation status query.
-  Replace vgimportclone script with binary.
-  While lvmetad is shutting down, continue handling all connections cleanly.
-  Refactor lvconvert argument handling code.
-  Notify lvmetad when vgcfgrestore changes VG metadata.
-  Add --logonly option to report only cmd log for a command, not other reports.
-  Add log/command_log_selection to configure default selection used on cmd log.
-  Use 'orphan' object type in cmd log for groups to collect PVs not yet in VGs.
-  Add lvm lastlog command for query and display of last cmd's log in lvm shell.
-  Report per-object return codes via cmd log while processing multiple objects.
-  Annotate processing code with log report hooks for per-object command log.
-  Also pass common printed messages (besides warnings and errors) to log report.
-  Log warnings and errors via report during cmd processing if this is enabled.
-  Make it possible to iterate over internal 'orphan' VGs in process_each_vg fn.
-  Make -S|--select option groupable that allows this option to be repeated.
-  Make -O|--sort option groupable that allows this option to be repeated.
-  Add --configreport option to select report for which next options are applied.
-  Add support for priorities on grouping command arguments.
-  Add report/{pvs,vgs,lvs,pvsegs,segs}_{cols,sort}_full to lvm.conf.
-  Add lvm fullreport command for joined PV, VG, LV and segment report per VG.
-  Integrate report group handling and cmd log report into cmd processing code.
-  Add log/report_command_log to lvm.conf to enable or disable cmd log report.
-  Add log/report_output_format to lvm.conf for default report output format.
-  Recognize --reportformat {basic|json} option to select report output format.
-  Add log/command_log_{sort,cols} to lvm.conf to configure command log report.
-  Add log_object_{type,name,id,group,group_id} fields to cmd log.
-  Add log_{seq_num,type,context,message,errno,ret_code} fields to cmd log.
-  Add CMDLOG report type - a separate report type for command logging.
-
-Version 2.02.157 - 17th June 2016
-=================================
-  Change pvscan --cache -aay to scan locally if lvmetad fails.
-
-Version 2.02.156 - 11th June 2016
-=================================
-  Don't allow duplicate orphan PVs to be used with vgcreate/vgextend/pvcreate.
-  Improve handling of lvmetad update failures.
-  Yes/No prompt accepts '^[ ^t]*([Yy]([Ee]([Ss]|)|)|[Nn]([Oo]|))[ ^t]*$'.
-  If available, also collect output from lsblk command when running lvmdump -s.
-
-Version 2.02.155 - 3rd June 2016
-================================
-  Reject PV tags on pvmove cmdline because only 1 PV is supported. (2.02.141)
-  Fix compilation error when building with configure --disable-devmapper.
-  Fix lvmconfig --type diff to display complete diff if config cascade used.
-  Automatically filter out partitioned loop devices with partscan (losetup -P).
-  Fix lvm devtypes internal error if -S used with field name from pvs/vgs/lvs.
-  When reporting Data%,Snap%,Meta%,Cpy%Sync use single ioctl per LV.
-  Add lvseg_percent_with_info_and_seg_status() for percent retrieval.
-  Enhance internal seg_status handling to understand snapshots better.
-  When refresh failed in suspend, call resume upon error path.
-  Support passthrough cache mode when waiting for clean cache.
-  Check cache status only for 'in-use' cache pools.
-  Extend setup_task() to preset flushing for dm_task object.
-  When checking LV is a merging COW, validate its a COW LV first.
-  Correcting value in copy_percent() for 100%.
-  Update vgreduce to use process_each_vg.
-  Update lvconvert to use process_each_lv.
-  Update pvscan to use process_each_vg for autoactivation.
-  Add basic support for --type raid0 using md.
-  Add support for lvchange --cachemode for cached LV.
-  Fix liblvm2app error handling when setting up context.
-  Delay liblvm2app init in python code until it is needed.
-  Simplify thread locking in lvmetad to fix locking problems.
-  Allow pvremove -ff to remove a duplicate PV.
-  Fix lvm2-activation-generator to read lvm.conf without full command setup.
-  Allow a minimal context to be used in lvm2app for reading lvm.conf.
-
-Version 2.02.154 - 14th May 2016
-================================
-  Fix liblvm segfault after failure initialising lvmetad connection.
-  Retry open without O_NOATIME if it fails (not file owner/CAP_FOWNER).
-  Split _report into one fn for options and arguments and one for processing.
-
-Version 2.02.153 - 7th May 2016
-===============================
-  Change warning messages related to duplicate PVs.
-  A named device is always processed itself, not switched for a duplicate.
-  Add PV attr "d" and report field "duplicate" for duplicate PVs.
-  Add config setting to disallow VG changes when duplicate PVs exist.
-  Use device size and active LVs to choose the preferred duplicate PV.
-  Disable lvmetad when duplicate PVs are seen.
-  Support --chunksize option also when caching LV when possible.
-  Add function to check for target presence and version via 1 ioctl.
-
-Version 2.02.152 - 30th April 2016
+Version 2.02.148 - 
 ==================================
-  Use any inherited tags when wiping metadata sub LVs to ensure activation.
-  Add str_list_wipe.
-  Improve support for interrupting procesing of volumes during lvchange.
-  Use failed command return code when lvchanging read-only volume.
-  Show creation transaction_id and zeroing state of pool with thin volume.
-  Stop checking for dm_cache_mq policy with cache target 1.9 (alias to smq).
-  Check first /sys/module/dm_* dir existance before using modprobe.
-  Remove mpath from 10-dm.rules, superseded by 11-dm-mpath.rules (mpath>=0.6.0).
-
-Version 2.02.151 - 23rd April 2016
-==================================
-  Fix error path after reusing of _setup_task (2.02.150).
-  Fix memory access for empty sysfs values (2.02.149).
-  Disable lvmetad when lvm1 metadata is seen, so commands revert to scanning.
-  Suppress errors when snapshot merge gets delayed because volume is in use.
-  Avoid internal snapshot LV names in messages.
-  Autodetect and use /run/lock dir when available instead of /var/lock.
-  lvchange --refresh for merging thin origin will retry to deactivate snapshot.
-  Recognize in-progress snapshot merge for thin volumes from dm table.
-  Avoid deciding to initiate a pending snapshot merge during resume.
-  Improve retrying lvmetad requests while lvmetad is being updated.
-  Read devices instead of using the lvmetad cache if rescan fails.
-  Move lvmetad token/filter check and device rescan to the start of commands.
-  Don't try deactivating fictional internal LV before snapshot merge. (2.02.105)
-  When not obtaining devs from udev, check they exist before caching them.
-  Detect device mismatch also when compiling without udev support.
-
-Version 2.02.150 - 9th April 2016
-=================================
-  Avoid using flushing dm status ioctl when checking for usable DM device.
-  Check for devices without LVM- uuid prefix only with kernels < 3.X.
-  Reuse %FREE size aproximation with lvcreate -l%PVS thin-pool.
-  Allow the lvmdump directory to exist already provided it is empty.
-  Show lvconverted percentage with 2 decimal digits.
-  Fix regression in suspend when repairing --type mirror (2.02.133).
-
-Version 2.02.149 - 1st April 2016
-=================================
-  Do not flush thin-pool when checking metadata fullness.
-  Remove spurious error about no value in /sys/dev/block/major:minor/dm/uuid.
-  Fix device mismatch detection for LV if persistent .cache file is used.
-  Fix holder device not being found in /dev while sysfs has it during dev scan.
-
-Version 2.02.148 - 26th March 2016
-==================================
-  Introduce TARGET_NAME and MODULE NAME macros.
  Replace hard-coded module and target names with macros.
  Add pv_major and pv_minor report fields.
  Detect and warn about mismatch between devices used and assumed for an LV.
--- a/93
+++ b/93
@@ -1,94 +1,5 @@
-Version 1.02.135 - 
-=====================================
-
-Version 1.02.134 - 7th September 2016
-=====================================
-  Improve explanation of udev fallback in libdevmapper.h.
-
-Version 1.02.133 - 10th August 2016
-===================================
-  Add dm_report_destroy_rows/dm_report_group_output_and_pop_all for lvm shell.
-  Adjust group handling and json production for lvm shell.
-
-Version 1.02.132 - 28th July 2016
-=================================
-  Fix json reporting to escape '"' character that may appear in reported string.
-
-Version 1.02.131 - 15th July 2016
-=================================
-  Disable queueing on mpath devs in blk-availability systemd service/initscript.
-  Add new -m|--mpathoption disablequeueing to blkdeactivate.
-  Automatically group regions with 'create --segments' unless --nogroup.
-  Fix resource leak when deleting the first member of a group.
-  Allow --bounds with 'create --filemap' for dmstats.
-  Enable creation of filemap regions with histograms.
-  Enable histogram aggregation for regions with more than one area.
-  Enable histogram aggregation for groups of regions.
-  Add a --filemap option to 'dmstats create' to allow mapping of files.
-  Add dm_stats_create_regions_from_fd() to map file extents to regions.
-
-Version 1.02.130 - 6th July 2016
-================================
-  Minor fixes from coverity.
-
-Version 1.02.129 - 6th July 2016
-================================
-  Update default dmstats field selections for groups.
-  Add 'obj_type', 'group_id', and 'statsname' fields to dmstats reports.
-  Add --area, --region, and --group to dmstats to control object selection.
-  Add --alias, --groupid, --regions to dmstats for group creation and deletion.
-  Add 'group' and 'ungroup' commands to dmstats.
-  Allow dm_stats_delete_group() to optionally delete all group members.
-  Add dm_stats_get_object_type() to return the type of object present.
-  Add dm_stats_walk_init() allowing control of objects visited by walks.
-  Add dm_stats_get_group_descriptor() to return the member list as a string.
-  Introduce dm_stats_get_nr_groups() and dm_stats_group_present().
-  Add dm_stats_{get,set}_alias() to set and retrieve alias names for groups.
-  Add dm_stats_get_group_id() to return the group ID for a given region.
-  Add dm_stats_{create,delete}_group() to allow grouping of stats regions.
-  Add enum-driven dm_stats_get_{metric,counter}() interfaces.
-  Add dm_bitset_parse_list() to parse a string representation of a bitset.
-  Thin dmeventd plugin umounts lvm2 volume only when pool is 95% or more.
-
-Version 1.02.128 - 25th June 2016
-=================================
-  Recognize 'all' keyword used in selection as synonym for "" (no selection).
-  Add dm_report_set_selection to set selection for multiple output of report.
-  Add DM_REPORT_OUTPUT_MULTIPLE_TIMES flag for multiple output of same report.
-  Move field width handling/sort init from dm_report_object to dm_report_output.
-  Add _LOG_BYPASS_REPORT flag for bypassing any log report currently set.
-  Introduce DM_REPORT_GROUP_JSON for report group with JSON output format.
-  Introduce DM_REPORT_GROUP_BASIC for report group with basic report output.
-  Introduce DM_REPORT_GROUP_SINGLE for report group having single report only.
-  Add dm_report_group_{create,push,pop,destroy} to support report grouping.
-
-Version 1.02.127 - 11th June 2016
-=================================
- Fix blkdeactivate regression causing skipping of dm + md devices. (1.02.126)
-
-Version 1.02.126 - 3rd June 2016
-================================
-  Report passthrough caching mode when parsing cache mode.
-
-Version 1.02.125 - 14th May 2016
-================================
-  Show library version in message even if dm driver version is unavailable.
-
-Version 1.02.124 - 30th April 2016
+Version 1.02.121 - 
 ==================================
-  Add dm_udev_wait_immediate to libdevmapper for waiting outside the library.
-
-Version 1.02.123 - 23rd April 2016
-==================================
-  Do not strip LVM- when debug reporting not found uuid.
-
-Version 1.02.122 - 9th April 2016
-=================================
-  Change log_debug ioctl flags from single characters into words.
-
-Version 1.02.121 - 26th March 2016
-==================================
-  Adjust raid status function.

 Version 1.02.120 - 11th March 2016
 ==================================
@@ -169,7 +80,7 @@ Version 1.02.110 - 30th October 2015
  Correct use of max_write_behind parameter when generating raid target line.
  Fix dm-event systemd service to make sure it is executed before mounting.

-Version 1.02.109 - 22nd September 2015
+Version 1.02.109 - 22nd September 2016
 ======================================
  Update man pages for dmsetup and dmstats.
  Improve help text for dmsetup.
--- a/conf/Makefile.in
+++ b/conf/Makefile.in
@@ -24,8 +24,7 @@ PROFILES=$(PROFILE_TEMPLATES) \
 	$(srcdir)/cache-mq.profile \
 	$(srcdir)/cache-smq.profile \
 	$(srcdir)/thin-generic.profile \
-	$(srcdir)/thin-performance.profile \
-	$(srcdir)/lvmdbusd.profile
+	$(srcdir)/thin-performance.profile

 include $(top_builddir)/make.tmpl

--- a/conf/command_profile_template.profile.in
+++ b/conf/command_profile_template.profile.in
@@ -16,20 +16,15 @@ allocation {
 	cache_settings {
 	}
 }
-log {
-	report_command_log=0
-	command_log_sort="log_seq_num"
-	command_log_cols="log_seq_num,log_type,log_context,log_object_type,log_object_name,log_object_id,log_object_group,log_object_group_id,log_message,log_errno,log_ret_code"
-	command_log_selection="!(log_type=status && message=success)"
-}
+
 global {
 	units="h"
 	si_unit_consistency=1
 	suffix=1
 	lvdisplay_shows_full_device_path=0
 }
+
 report {
-	output_format="basic"
 	compact_output=0
 	compact_output_cols=""
 	aligned=1
@@ -39,7 +34,7 @@ report {
 	list_item_separator=","
 	prefixes=0
 	quoted=1
-	columns_as_rows=0
+	colums_as_rows=0
 	binary_values_as_numeric=0
 	time_format="%Y-%m-%d %T %z"
 	devtypes_sort="devtype_name"
@@ -60,15 +55,5 @@ report {
 	pvsegs_sort="pv_name,pvseg_start"
 	pvsegs_cols="pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size"
 	pvsegs_cols_verbose="pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size,lv_name,seg_start_pe,segtype,seg_pe_ranges"
-	vgs_cols_full="vg_all"
-	pvs_cols_full="pv_all"
-	lvs_cols_full="lv_all"
-	pvsegs_cols_full="pvseg_all,pv_uuid,lv_uuid"
-	segs_cols_full="seg_all,lv_uuid"
-	vgs_sort_full="vg_name"
-	pvs_sort_full="pv_name"
-	lvs_sort_full="vg_name,lv_name"
-	pvsegs_sort_full="pv_uuid,pvseg_start"
-	segs_sort_full="lv_uuid,seg_start"
 	mark_hidden_devices=1
 }
--- a/conf/example.conf.in
+++ b/conf/example.conf.in
@@ -299,19 +299,6 @@ devices {
 	# generally do. If enabled, discards will only be issued if both the
 	# storage and kernel provide support.
 	issue_discards = 0
-
-	# Configuration option devices/allow_changes_with_duplicate_pvs.
-	# Allow VG modification while a PV appears on multiple devices.
-	# When a PV appears on multiple devices, LVM attempts to choose the
-	# best device to use for the PV. If the devices represent the same
-	# underlying storage, the choice has minimal consequence. If the
-	# devices represent different underlying storage, the wrong choice
-	# can result in data loss if the VG is modified. Disabling this
-	# setting is the safest option because it prevents modifying a VG
-	# or activating LVs in it while a PV appears on multiple devices.
-	# Enabling this setting allows the VG to be used as usual even with
-	# uncertain devices.
-	allow_changes_with_duplicate_pvs = 0
 }

 # Configuration section allocation.
@@ -377,14 +364,6 @@ allocation {
 	# The default setting changed in version 2.02.85.
 	mirror_logs_require_separate_pvs = 0

-	# Configuration option allocation/raid_stripe_all_devices.
-	# Stripe across all PVs when RAID stripes are not specified.
-	# If enabled, all PVs in the VG or on the command line are used for raid0/4/5/6/10
-	# when the command does not specify the number of stripes to use.
-	# This was the default behaviour until release 2.02.162.
-	# This configuration option has an automatic default value.
-	# raid_stripe_all_devices = 0
-
 	# Configuration option allocation/cache_pool_metadata_require_separate_pvs.
 	# Cache pool metadata and data will always use different PVs.
 	cache_pool_metadata_require_separate_pvs = 0
@@ -428,12 +407,6 @@ allocation {
 	# 32KiB to 1GiB in multiples of 32.
 	# This configuration option does not have a default value defined.

-	# Configuration option allocation/cache_pool_max_chunks.
-	# The maximum number of chunks in a cache pool.
-	# For cache target v1.9 the recommended maximumm is 1000000 chunks.
-	# Using cache pool with more chunks may degrade cache performance.
-	# 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_require_separate_pvs = 0
@@ -492,55 +465,6 @@ allocation {
 # How LVM log information is reported.
 log {

-	# Configuration option log/report_command_log.
-	# Enable or disable LVM log reporting.
-	# If enabled, LVM will collect a log of operations, messages,
-	# per-object return codes with object identification and associated
-	# error numbers (errnos) during LVM command processing. Then the
-	# log is either reported solely or in addition to any existing
-	# reports, depending on LVM command used. If it is a reporting command
-	# (e.g. pvs, vgs, lvs, lvm fullreport), then the log is reported in
-	# addition to any existing reports. Otherwise, there's only log report
-	# on output. For all applicable LVM commands, you can request that
-	# the output has only log report by using --logonly command line
-	# option. Use log/command_log_cols and log/command_log_sort settings
-	# to define fields to display and sort fields for the log report.
-	# You can also use log/command_log_selection to define selection
-	# criteria used each time the log is reported.
-	# This configuration option has an automatic default value.
-	# report_command_log = 0
-
-	# Configuration option log/command_log_sort.
-	# List of columns to sort by when reporting command log.
-	# See <lvm command> --logonly --configreport log -o help
-	# for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# command_log_sort = "log_seq_num"
-
-	# Configuration option log/command_log_cols.
-	# List of columns to report when reporting command log.
-	# See <lvm command> --logonly --configreport log -o help
-	# for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# command_log_cols = "log_seq_num,log_type,log_context,log_object_type,log_object_name,log_object_id,log_object_group,log_object_group_id,log_message,log_errno,log_ret_code"
-
-	# Configuration option log/command_log_selection.
-	# Selection criteria used when reporting command log.
-	# You can define selection criteria that are applied each
-	# time log is reported. This way, it is possible to control the
-	# amount of log that is displayed on output and you can select
-	# only parts of the log that are important for you. To define
-	# selection criteria, use fields from log report. See also
-	# <lvm command> --logonly --configreport log -S help for the
-	# list of possible fields and selection operators. You can also
-	# define selection criteria for log report on command line directly
-	# using <lvm command> --configreport log -S <selection criteria>
-	# which has precedence over log/command_log_selection setting.
-	# For more information about selection criteria in general, see
-	# lvm(8) man page.
-	# This configuration option has an automatic default value.
-	# command_log_selection = "!(log_type=status && message=success)"
-
 	# Configuration option log/verbose.
 	# Controls the messages sent to stdout or stderr.
 	verbose = 0
@@ -927,23 +851,13 @@ global {
 	# devices/global_filter.
 	use_lvmetad = @DEFAULT_USE_LVMETAD@

-	# Configuration option global/lvmetad_update_wait_time.
-	# The number of seconds a command will wait for lvmetad update to finish.
-	# After waiting for this period, a command will not use lvmetad, and
-	# will revert to disk scanning.
-	# This configuration option has an automatic default value.
-	# lvmetad_update_wait_time = 10
-
 	# Configuration option global/use_lvmlockd.
 	# Use lvmlockd for locking among hosts using LVM on shared storage.
-	# Applicable only if LVM is compiled with lockd support in which
-	# case there is also lvmlockd(8) man page available for more
-	# information.
+	# See lvmlockd(8) for more information.
 	use_lvmlockd = 0

 	# Configuration option global/lvmlockd_lock_retries.
 	# Retry lvmlockd lock requests this many times.
-	# Applicable only if LVM is compiled with lockd support
 	# This configuration option has an automatic default value.
 	# lvmlockd_lock_retries = 3

@@ -953,8 +867,7 @@ global {
 	# LVs have been created, the internal LV needs to be extended. lvcreate
 	# will automatically extend the internal LV when needed by the amount
 	# specified here. Setting this to 0 disables the automatic extension
-	# and can cause lvcreate to fail. Applicable only if LVM is compiled
-	# with lockd support
+	# and can cause lvcreate to fail.
 	# This configuration option has an automatic default value.
 	# sanlock_lv_extend = 256

@@ -1101,7 +1014,6 @@ global {
 	# a native systemd service, which allows it to be started on demand,
 	# and to use its own control group. When this option is disabled, LVM
 	# commands will supervise long running operations by forking themselves.
-	# Applicable only if LVM is compiled with lvmpolld support.
 	use_lvmpolld = @DEFAULT_USE_LVMPOLLD@

 	# Configuration option global/notify_dbus.
@@ -1614,22 +1526,6 @@ activation {
 # This configuration section has an automatic default value.
 # report {

-	# Configuration option report/output_format.
-	# Format of LVM command's report output.
-	# If there is more than one report per command, then the format
-	# is applied for all reports. You can also change output format
-	# directly on command line using --reportformat option which
-	# has precedence over log/output_format setting.
-	# Accepted values:
-	#   basic
-	#     Original format with columns and rows. If there is more than
-	#     one report per command, each report is prefixed with report's
-	#     name for identification.
-	#   json
-	#     JSON format.
-	# This configuration option has an automatic default value.
-	# output_format = "basic"
-
 	# Configuration option report/compact_output.
 	# Do not print empty values for all report fields.
 	# If enabled, all fields that don't have a value set for any of the
@@ -1690,11 +1586,11 @@ activation {
 	# This configuration option has an automatic default value.
 	# quoted = 1

-	# Configuration option report/columns_as_rows.
+	# Configuration option report/colums_as_rows.
 	# Output each column as a row.
 	# If set, this also implies report/prefixes=1.
 	# This configuration option has an automatic default value.
-	# columns_as_rows = 0
+	# colums_as_rows = 0

 	# Configuration option report/binary_values_as_numeric.
 	# Use binary values 0 or 1 instead of descriptive literal values.
@@ -1946,66 +1842,6 @@ activation {
 	# This configuration option has an automatic default value.
 	# pvsegs_cols_verbose = "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size,lv_name,seg_start_pe,segtype,seg_pe_ranges"

-	# Configuration option report/vgs_cols_full.
-	# List of columns to report for lvm fullreport's 'vgs' subreport.
-	# See 'vgs -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# vgs_cols_full = "vg_all"
-
-	# Configuration option report/pvs_cols_full.
-	# List of columns to report for lvm fullreport's 'vgs' subreport.
-	# See 'pvs -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# pvs_cols_full = "pv_all"
-
-	# Configuration option report/lvs_cols_full.
-	# List of columns to report for lvm fullreport's 'lvs' subreport.
-	# See 'lvs -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# lvs_cols_full = "lv_all"
-
-	# Configuration option report/pvsegs_cols_full.
-	# List of columns to report for lvm fullreport's 'pvseg' subreport.
-	# See 'pvs --segments -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# pvsegs_cols_full = "pvseg_all,pv_uuid,lv_uuid"
-
-	# Configuration option report/segs_cols_full.
-	# List of columns to report for lvm fullreport's 'seg' subreport.
-	# See 'lvs --segments -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# segs_cols_full = "seg_all,lv_uuid"
-
-	# Configuration option report/vgs_sort_full.
-	# List of columns to sort by when reporting lvm fullreport's 'vgs' subreport.
-	# See 'vgs -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# vgs_sort_full = "vg_name"
-
-	# Configuration option report/pvs_sort_full.
-	# List of columns to sort by when reporting lvm fullreport's 'vgs' subreport.
-	# See 'pvs -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# pvs_sort_full = "pv_name"
-
-	# Configuration option report/lvs_sort_full.
-	# List of columns to sort by when reporting lvm fullreport's 'lvs' subreport.
-	# See 'lvs -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# lvs_sort_full = "vg_name,lv_name"
-
-	# Configuration option report/pvsegs_sort_full.
-	# List of columns to sort by when reporting for lvm fullreport's 'pvseg' subreport.
-	# See 'pvs --segments -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# pvsegs_sort_full = "pv_uuid,pvseg_start"
-
-	# Configuration option report/segs_sort_full.
-	# List of columns to sort by when reporting lvm fullreport's 'seg' subreport.
-	# See 'lvs --segments -o help' for the list of possible fields.
-	# This configuration option has an automatic default value.
-	# segs_sort_full = "lv_uuid,seg_start"
-
 	# Configuration option report/mark_hidden_devices.
 	# Use brackets [] to mark hidden devices.
 	# This configuration option has an automatic default value.
--- a/conf/lvmdbusd.profile
+++ b/conf/lvmdbusd.profile
@@ -1,50 +0,0 @@
-#
-# DO NOT EDIT THIS FILE!
-#
-# LVM configuration profile used by lvmdbusd daemon.
-#
-# This sets up LVM to produce output in the most suitable format for processing
-# by lvmdbusd daemon which utilizes LVM shell to execute LVM commands.
-#
-# Do not edit this file in any way. This profile is distributed together with
-# lvmdbusd and it contains configuration that is important for lvmdbusd to
-# cooperate and interface with LVM correctly.
-#
-
-global {
-	# use bytes for expected and deterministic output
-	units=b
-	# no need for suffix if we have units set
-	suffix=0
-}
-
-report {
-	compact_output=0
-	compact_output_cols=""
-	binary_values_as_numeric=0
-	# time in number of seconds since the Epoch
-	time_format="%s"
-	mark_hidden_devices=1
-	# lvmdbusd expects JSON output
-	output_format=json
-	# *_cols_full for lvm fullreport's fields which lvmdbusd relies on to update its state
-	vgs_cols_full="vg_name,vg_uuid,vg_fmt,vg_size,vg_free,vg_sysid,vg_extent_size,vg_extent_count,vg_free_count,vg_profile,max_lv,max_pv,pv_count,lv_count,snap_count,vg_seqno,vg_mda_count,vg_mda_free,vg_mda_size,vg_mda_used_count,vg_attr,vg_tags"
-	pvs_cols_full="pv_name,pv_uuid,pv_fmt,pv_size,pv_free,pv_used,dev_size,pv_mda_size,pv_mda_free,pv_ba_start,pv_ba_size,pe_start,pv_pe_count,pv_pe_alloc_count,pv_attr,pv_tags,vg_name,vg_uuid"
-	lvs_cols_full="lv_uuid,lv_name,lv_path,lv_size,vg_name,pool_lv_uuid,pool_lv,origin_uuid,origin,data_percent,lv_attr,lv_tags,vg_uuid,lv_active,data_lv,metadata_lv,lv_parent,lv_role,lv_layout"
-	pvsegs_cols_full="pvseg_start,pvseg_size,segtype,pv_uuid,lv_uuid,pv_name"
-	segs_cols_full="seg_pe_ranges,segtype,lv_uuid"
-	vgs_sort_full="vg_name"
-	pvs_sort_full="pv_name"
-	lvs_sort_full="vg_name,lv_name"
-	pvsegs_sort_full="pv_uuid,pvseg_start"
-	segs_sort_full="lv_uuid,seg_start"
-}
-
-log {
-	# lvmdbusd relies on command log report to inspect LVM command's execution status
-	report_command_log=1
-	# display only outermost LVM shell-related log that lvmdbusd inspects first after LVM command execution (it calls 'lastlog' for more detailed log afterwards if needed)
-	command_log_selection="log_context=shell"
-	command_log_cols="log_seq_num,log_type,log_context,log_object_type,log_object_name,log_object_id,log_object_group,log_object_group_id,log_message,log_errno,log_ret_code"
-	command_log_sort="log_seq_num"
-}
--- a/conf/lvmlocal.conf.in
+++ b/conf/lvmlocal.conf.in
@@ -51,7 +51,6 @@ local {
 	# Configuration option local/host_id.
 	# The lvmlockd sanlock host_id.
 	# This must be unique among all hosts, and must be between 1 and 2000.
-	# Applicable only if LVM is compiled with lockd support
 	# This configuration option has an automatic default value.
 	# host_id = 0
 }
--- a/39
+++ b/39
@@ -1820,7 +1820,7 @@ Optional Packages:
  --with-default-cache-subdir=SUBDIR
                          default metadata cache subdir [cache]
  --with-default-locking-dir=DIR
-                          default locking directory [autodetect_lock_dir/lvm]
+                          default locking directory [/var/lock/lvm]
  --with-default-data-alignment=NUM
                          set the default data alignment in MiB [1]
  --with-interface=IFACE  choose kernel interface (ioctl) [ioctl]
@@ -3168,8 +3168,8 @@ case "$host_os" in
 		LDDEPS="$LDDEPS .export.sym"
 		LIB_SUFFIX=so
 		DEVMAPPER=yes
-		BUILD_LVMETAD=no
-		BUILD_LVMPOLLD=no
+		LVMETAD=no
+		LVMPOLLD=no
 		LOCKDSANLOCK=no
 		LOCKDDLM=no
 		ODIRECT=yes
@@ -5875,7 +5875,7 @@ fi
 done


-for ac_header in termios.h sys/statvfs.h sys/timerfd.h linux/magic.h linux/fiemap.h
+for ac_header in termios.h sys/statvfs.h sys/timerfd.h
 do :
  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
@@ -11486,9 +11486,10 @@ if test "${enable_lvmetad+set}" = set; then :
  enableval=$enable_lvmetad; LVMETAD=$enableval
 fi

-test -n "$LVMETAD" && BUILD_LVMETAD=$LVMETAD
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LVMETAD" >&5
-$as_echo "$BUILD_LVMETAD" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LVMETAD" >&5
+$as_echo "$LVMETAD" >&6; }
+
+BUILD_LVMETAD=$LVMETAD

 ################################################################################
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build lvmpolld" >&5
@@ -11498,9 +11499,10 @@ if test "${enable_lvmpolld+set}" = set; then :
  enableval=$enable_lvmpolld; LVMPOLLD=$enableval
 fi

-test -n "$LVMPOLLD" && BUILD_LVMPOLLD=$LVMPOLLD
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LVMPOLLD" >&5
-$as_echo "$BUILD_LVMPOLLD" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LVMPOLLD" >&5
+$as_echo "$LVMPOLLD" >&6; }
+
+BUILD_LVMPOLLD=$LVMPOLLD

 ################################################################################
 BUILD_LVMLOCKD=no
@@ -11693,17 +11695,11 @@ $as_echo_n "checking whether to build lvmlockd... " >&6; }
 $as_echo "$BUILD_LVMLOCKD" >&6; }

 if test "$BUILD_LVMLOCKD" = yes; then
-	if test "$LVMPOLLD" = no; then :
-  as_fn_error $? "cannot build lvmlockd with --disable-lvmpolld." "$LINENO" 5
-fi
-	if test "$LVMETAD" = no; then :
-  as_fn_error $? "cannot build lvmlockd with --disable-lvmetad." "$LINENO" 5
-fi
-	if test "$BUILD_LVMPOLLD" = no; then :
+	if test -n "$BUILD_LVMPOLLD"; then :
  BUILD_LVMPOLLD=yes; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Enabling lvmpolld - required by lvmlockd." >&5
 $as_echo "$as_me: WARNING: Enabling lvmpolld - required by lvmlockd." >&2;}
 fi
-	if test "$BUILD_LVMETAD" = no; then :
+	if test -n "$BUILD_LVMETAD"; then :
  BUILD_LVMETAD=yes; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Enabling lvmetad - required by lvmlockd." >&5
 $as_echo "$as_me: WARNING: Enabling lvmetad - required by lvmlockd." >&2;}
 fi
@@ -15117,12 +15113,7 @@ _ACEOF
 if test "${with_default_locking_dir+set}" = set; then :
  withval=$with_default_locking_dir; DEFAULT_LOCK_DIR=$withval
 else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for default lock directory" >&5
-$as_echo_n "checking for default lock directory... " >&6; }
-	     DEFAULT_LOCK_DIR="$RUN_DIR/lock/lvm"
-	     test -d "$RUN_DIR/lock" || DEFAULT_LOCK_DIR="/var/lock/lvm"
-	     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEFAULT_LOCK_DIR" >&5
-$as_echo "$DEFAULT_LOCK_DIR" >&6; }
+  DEFAULT_LOCK_DIR="/var/lock/lvm"
 fi


--- a/configure.in
+++ b/configure.in
@@ -37,8 +37,8 @@ case "$host_os" in
 		LDDEPS="$LDDEPS .export.sym"
 		LIB_SUFFIX=so
 		DEVMAPPER=yes
-		BUILD_LVMETAD=no
-		BUILD_LVMPOLLD=no
+		LVMETAD=no
+		LVMPOLLD=no
 		LOCKDSANLOCK=no
 		LOCKDDLM=no
 		ODIRECT=yes
@@ -103,7 +103,7 @@ AC_CHECK_HEADERS([assert.h ctype.h dirent.h errno.h fcntl.h float.h \
  sys/time.h sys/types.h sys/utsname.h sys/wait.h time.h \
  unistd.h], , [AC_MSG_ERROR(bailing out)])

-AC_CHECK_HEADERS(termios.h sys/statvfs.h sys/timerfd.h linux/magic.h linux/fiemap.h)
+AC_CHECK_HEADERS(termios.h sys/statvfs.h sys/timerfd.h)

 case "$host_os" in
 	linux*)
@@ -1129,8 +1129,9 @@ AC_ARG_ENABLE(lvmetad,
 	      AC_HELP_STRING([--enable-lvmetad],
 			     [enable the LVM Metadata Daemon]),
 	      LVMETAD=$enableval)
-test -n "$LVMETAD" && BUILD_LVMETAD=$LVMETAD
-AC_MSG_RESULT($BUILD_LVMETAD)
+AC_MSG_RESULT($LVMETAD)
+
+BUILD_LVMETAD=$LVMETAD

 ################################################################################
 dnl -- Build lvmpolld
@@ -1139,8 +1140,9 @@ AC_ARG_ENABLE(lvmpolld,
 	      AC_HELP_STRING([--enable-lvmpolld],
 			     [enable the LVM Polling Daemon]),
 	      LVMPOLLD=$enableval)
-test -n "$LVMPOLLD" && BUILD_LVMPOLLD=$LVMPOLLD
-AC_MSG_RESULT($BUILD_LVMPOLLD)
+AC_MSG_RESULT($LVMPOLLD)
+
+BUILD_LVMPOLLD=$LVMPOLLD

 ################################################################################
 BUILD_LVMLOCKD=no
@@ -1186,10 +1188,8 @@ AC_MSG_CHECKING(whether to build lvmlockd)
 AC_MSG_RESULT($BUILD_LVMLOCKD)

 if test "$BUILD_LVMLOCKD" = yes; then
-	AS_IF([test "$LVMPOLLD" = no], [AC_MSG_ERROR([cannot build lvmlockd with --disable-lvmpolld.])])
-	AS_IF([test "$LVMETAD" = no], [AC_MSG_ERROR([cannot build lvmlockd with --disable-lvmetad.])])
-	AS_IF([test "$BUILD_LVMPOLLD" = no], [BUILD_LVMPOLLD=yes; AC_MSG_WARN([Enabling lvmpolld - required by lvmlockd.])])
-	AS_IF([test "$BUILD_LVMETAD" = no], [BUILD_LVMETAD=yes; AC_MSG_WARN([Enabling lvmetad - required by lvmlockd.])])
+	AS_IF([test -n "$BUILD_LVMPOLLD"], [BUILD_LVMPOLLD=yes; AC_MSG_WARN([Enabling lvmpolld - required by lvmlockd.])])
+	AS_IF([test -n "$BUILD_LVMETAD"], [BUILD_LVMETAD=yes; AC_MSG_WARN([Enabling lvmetad - required by lvmlockd.])])
 	AC_MSG_CHECKING([defaults for use_lvmlockd])
 	AC_ARG_ENABLE(use_lvmlockd,
 		      AC_HELP_STRING([--disable-use-lvmlockd],
@@ -1933,12 +1933,8 @@ AC_DEFINE_UNQUOTED(DEFAULT_CACHE_SUBDIR, ["$DEFAULT_CACHE_SUBDIR"],

 AC_ARG_WITH(default-locking-dir,
 	    AC_HELP_STRING([--with-default-locking-dir=DIR],
-			   [default locking directory [autodetect_lock_dir/lvm]]),
-	    DEFAULT_LOCK_DIR=$withval,
-	    [AC_MSG_CHECKING(for default lock directory)
-	     DEFAULT_LOCK_DIR="$RUN_DIR/lock/lvm"
-	     test -d "$RUN_DIR/lock" || DEFAULT_LOCK_DIR="/var/lock/lvm"
-	     AC_MSG_RESULT($DEFAULT_LOCK_DIR)])
+			   [default locking directory [/var/lock/lvm]]),
+	    DEFAULT_LOCK_DIR=$withval, DEFAULT_LOCK_DIR="/var/lock/lvm")
 AC_DEFINE_UNQUOTED(DEFAULT_LOCK_DIR, ["$DEFAULT_LOCK_DIR"],
 		   [Name of default locking directory.])

--- a/daemons/cmirrord/functions.c
+++ b/daemons/cmirrord/functions.c
@@ -12,7 +12,6 @@
 #include "logging.h"
 #include "functions.h"

-#include <sys/sysmacros.h>
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -574,12 +573,6 @@ static int clog_ctr(struct dm_ulog_request *rq)
 	for (argc = 0, p = rq->data; (p = strstr(p, " ")); p++, argc++)
 		*p = '\0';

-	if (!argc) {
-		LOG_ERROR("Received constructor request with bad data %s",
-			  rq->data);
-		return -EINVAL;
-	}
-
 	argv = malloc(argc * sizeof(char *));
 	if (!argv)
 		return -ENOMEM;
--- a/daemons/dmeventd/libdevmapper-event.c
+++ b/daemons/dmeventd/libdevmapper-event.c
@@ -855,9 +855,9 @@ int dm_event_get_version(struct dm_event_fifos *fifos, int *version) {
 	return 1;
 }

-void dm_event_log_set(int debug_log_level, int use_syslog)
+void dm_event_log_set(int debug_level, int use_syslog)
 {
-	_debug_level = debug_log_level;
+	_debug_level = debug_level;
 	_use_syslog = use_syslog;
 }

--- a/daemons/dmeventd/libdevmapper-event.h
+++ b/daemons/dmeventd/libdevmapper-event.h
@@ -106,7 +106,7 @@ int dm_event_register_handler(const struct dm_event_handler *dmevh);
 int dm_event_unregister_handler(const struct dm_event_handler *dmevh);

 /* Set debug level for logging, and whether to log on stdout/stderr or syslog */
-void dm_event_log_set(int debug_log_level, int use_syslog);
+void dm_event_log_set(int debug_level, int use_syslog);

 /* Log messages acroding to current debug level  */
 __attribute__((format(printf, 6, 0)))
--- a/daemons/dmeventd/plugins/snapshot/dmeventd_snapshot.c
+++ b/daemons/dmeventd/plugins/snapshot/dmeventd_snapshot.c
@@ -16,7 +16,6 @@
 #include "dmeventd_lvm.h"
 #include "libdevmapper-event.h"

-#include <sys/sysmacros.h>
 #include <sys/wait.h>
 #include <stdarg.h>
 #include <pthread.h>
@@ -149,8 +148,8 @@ static void _umount(const char *device, int major, int minor)
 			continue; /* can't stat, skip this one */

 		if (S_ISBLK(st.st_mode) &&
-		    (int) major(st.st_rdev) == major &&
-		    (int) minor(st.st_rdev) == minor) {
+		    major(st.st_rdev) == major &&
+		    minor(st.st_rdev) == minor) {
 			log_error("Unmounting invalid snapshot %s from %s.", device, words[1]);
 			if (!_run(UMOUNT_COMMAND, "-fl", words[1], NULL))
 				log_error("Failed to umount snapshot %s from %s: %s.",
--- a/daemons/dmeventd/plugins/thin/dmeventd_thin.c
+++ b/daemons/dmeventd/plugins/thin/dmeventd_thin.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2016 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2011-2015 Red Hat, Inc. All rights reserved.
 *
 * This file is part of LVM2.
 *
@@ -30,9 +30,6 @@

 /* First warning when thin data or metadata is 80% full. */
 #define WARNING_THRESH	(DM_PERCENT_1 * 80)
-/* Umount thin LVs when thin data or metadata LV is >=
- * and lvextend --use-policies has failed. */
-#define UMOUNT_THRESH	(DM_PERCENT_1 * 95)
 /* Run a check every 5%. */
 #define CHECK_STEP	(DM_PERCENT_1 *  5)
 /* Do not bother checking thin data or metadata is less than 50% full. */
@@ -56,53 +53,6 @@ struct dso_state {

 DM_EVENT_LOG_FN("thin")

-#define UUID_PREFIX "LVM-"
-
-/* Figure out device UUID has LVM- prefix and is OPEN */
-static int _has_unmountable_prefix(int major, int minor)
-{
-	struct dm_task *dmt;
-	struct dm_info info;
-	const char *uuid;
-	int r = 0;
-
-	if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
-		return_0;
-
-	if (!dm_task_set_major_minor(dmt, major, minor, 1))
-		goto_out;
-
-	if (!dm_task_no_flush(dmt))
-		stack;
-
-	if (!dm_task_run(dmt))
-		goto out;
-
-	if (!dm_task_get_info(dmt, &info))
-		goto out;
-
-	if (!info.exists || !info.open_count)
-		goto out; /* Not open -> not mounted */
-
-	if (!(uuid = dm_task_get_uuid(dmt)))
-		goto out;
-
-	/* Check it's public mountable LV
-	 * has prefix  LVM-  and UUID size is 68 chars */
-	if (memcmp(uuid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1) ||
-	    strlen(uuid) != 68)
-		goto out;
-
-#if THIN_DEBUG
-	log_debug("Found logical volume %s (%u:%u).", uuid, major, minor);
-#endif
-	r = 1;
-out:
-	dm_task_destroy(dmt);
-
-	return r;
-}
-
 /* Get dependencies for device, and try to find matching device */
 static int _has_deps(const char *name, int tp_major, int tp_minor, int *dev_minor)
 {
@@ -140,9 +90,6 @@ static int _has_deps(const char *name, int tp_major, int tp_minor, int *dev_mino

 	*dev_minor = info.minor;

-	if (!_has_unmountable_prefix(major, info.minor))
-		goto out;
-
 #if THIN_DEBUG
 	{
 		char dev_name[PATH_MAX];
@@ -246,25 +193,20 @@ static int _umount_device(char *buffer, unsigned major, unsigned minor,
 			  char *target, void *cb_data)
 {
 	struct mountinfo_s *data = cb_data;
-	char *words[10];

 	if ((major == data->info.major) && dm_bit(data->minors, minor)) {
-		if (dm_split_words(buffer, DM_ARRAY_SIZE(words), 0, words) < DM_ARRAY_SIZE(words))
-			words[9] = NULL; /* just don't show device name */
-		log_info("Unmounting thin %s (%d:%d) of thin pool %s (%u:%u) from mount point \"%s\".",
-			 words[9] ? : "", major, minor, data->device,
-			 data->info.major, data->info.minor,
-			 target);
+		log_info("Unmounting thin volume %s from %s.",
+			 data->device, target);
 		if (!_run(UMOUNT_COMMAND, "-fl", target, NULL))
-			log_error("Failed to lazy umount thin %s (%d:%d) from %s: %s.",
-				  words[9], major, minor, target, strerror(errno));
+			log_error("Failed to umount thin %s from %s: %s.",
+				  data->device, target, strerror(errno));
 	}

 	return 1;
 }

 /*
- * Find all thin pool LV users and try to umount them.
+ * Find all thin pool users and try to umount them.
 * TODO: work with read-only thin pool support
 */
 static void _umount(struct dm_task *dmt)
@@ -298,7 +240,7 @@ out:
 		dm_bitset_destroy(data.minors);
 }

-static int _use_policy(struct dm_task *dmt, struct dso_state *state)
+static void _use_policy(struct dm_task *dmt, struct dso_state *state)
 {
 #if THIN_DEBUG
 	log_info("dmeventd executes: %s.", state->cmd_str);
@@ -306,12 +248,10 @@ static int _use_policy(struct dm_task *dmt, struct dso_state *state)
 	if (!dmeventd_lvm2_run_with_lock(state->cmd_str)) {
 		log_error("Failed to extend thin pool %s.",
 			  dm_task_get_name(dmt));
+		_umount(dmt);
 		state->fails++;
-		return 0;
-	}
-
-	state->fails = 0;
-	return 1;
+	} else
+		state->fails = 0;
 }

 void process_event(struct dm_task *dmt,
@@ -327,13 +267,6 @@ void process_event(struct dm_task *dmt,
 	char *target_type = NULL;
 	char *params;
 	int needs_policy = 0;
-	int needs_umount = 0;
-
-#if THIN_DEBUG
-	log_debug("Watch for tp-data:%.2f%%  tp-metadata:%.2f%%.",
-		  dm_percent_to_float(state->data_percent_check),
-		  dm_percent_to_float(state->metadata_percent_check));
-#endif

 #if 0
 	/* No longer monitoring, waiting for remove */
@@ -342,10 +275,8 @@ void process_event(struct dm_task *dmt,
 #endif
 	if (event & DM_EVENT_DEVICE_ERROR) {
 		/* Error -> no need to check and do instant resize */
-		if (_use_policy(dmt, state))
-			goto out;
-
-		stack;
+		_use_policy(dmt, state);
+		goto out;
 	}

 	dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
@@ -357,7 +288,7 @@ void process_event(struct dm_task *dmt,

 	if (!dm_get_status_thin_pool(state->mem, params, &tps)) {
 		log_error("Failed to parse status.");
-		needs_umount = 1;
+		_umount(dmt);
 		goto out;
 	}

@@ -392,9 +323,6 @@ void process_event(struct dm_task *dmt,
 			log_warn("WARNING: Thin pool %s metadata is now %.2f%% full.",
 				 device, dm_percent_to_float(percent));
 		needs_policy = 1;
-
-		if (percent >= UMOUNT_THRESH)
-			needs_umount = 1;
 	}

 	percent = dm_make_percent(tps->used_data_blocks, tps->total_data_blocks);
@@ -409,27 +337,17 @@ void process_event(struct dm_task *dmt,
 			log_warn("WARNING: Thin pool %s data is now %.2f%% full.",
 				 device, dm_percent_to_float(percent));
 		needs_policy = 1;
-
-		if (percent >= UMOUNT_THRESH)
-			needs_umount = 1;
 	}

-	if (needs_policy &&
-	    _use_policy(dmt, state))
-		needs_umount = 0; /* No umount when command was successful */
+	if (needs_policy)
+		_use_policy(dmt, state);
 out:
-	if (needs_umount) {
-		_umount(dmt);
-		/* Until something changes, do not retry any more actions */
-		state->data_percent_check = state->metadata_percent_check = (DM_PERCENT_1 * 101);
-	}
-
 	if (tps)
 		dm_pool_free(state->mem, tps);

 	if (state->fails >= MAX_FAILS) {
 		log_warn("WARNING: Dropping monitoring of %s. "
-			 "lvm2 command fails too often (%u times in row).",
+			 "lvm2 command fails too often (%u times in raw).",
 			 device, state->fails);
 		pthread_kill(pthread_self(), SIGALRM);
 	}
@@ -458,11 +376,11 @@ int register_device(const char *device,
 	state->data_percent_check = CHECK_MINIMUM;
 	*user = state;

-	log_info("Monitoring thin pool %s.", device);
+	log_info("Monitoring thin %s.", device);

 	return 1;
 bad:
-	log_error("Failed to monitor thin pool %s.", device);
+	log_error("Failed to monitor thin %s.", device);

 	return 0;
 }
@@ -476,7 +394,7 @@ int unregister_device(const char *device,
 	struct dso_state *state = *user;

 	dmeventd_lvm2_exit_with_pool(state);
-	log_info("No longer monitoring thin pool %s.", device);
+	log_info("No longer monitoring thin %s.", device);

 	return 1;
 }
--- a/daemons/lvmdbusd/Makefile.in
+++ b/daemons/lvmdbusd/Makefile.in
@@ -63,5 +63,3 @@ install_lvm2: install_lvmdbusd

 install: install_lvm2

-DISTCLEAN_TARGETS+= \
-	$(LVMDBUS_BUILDDIR_FILES)
--- a/daemons/lvmdbusd/background.py
+++ b/daemons/lvmdbusd/background.py
@@ -13,9 +13,10 @@ from . import cfg
 import time
 from .cmdhandler import options_to_cli_args
 import dbus
-from .utils import pv_range_append, pv_dest_ranges, log_error, log_debug
+from .job import Job, JobState
+from .utils import pv_range_append, pv_dest_ranges, log_debug, log_error
+from .request import RequestEntry
 import traceback
-import os

 _rlock = threading.RLock()
 _thread_list = list()
@@ -42,22 +43,40 @@ def lv_merge_cmd(merge_options, lv_full_name):
 	return cmd


-def _move_merge(interface_name, cmd, job_state):
+def _create_background_dbus_job(job_state):
+	job_obj = Job(None, job_state)
+	cfg.om.register_object(job_obj)
+	return job_obj.dbus_object_path()
+
+
+def _move_merge(interface_name, cmd, time_out):
+	# Create job object to be used while running the command
+	rc = '/'
+	job_state = JobState(None)
 	add(cmd, job_state)

-	done = job_state.Wait(-1)
-	if not done:
-		ec, err_msg = job_state.GetError
-		raise dbus.exceptions.DBusException(
-			interface_name,
-			'Exit code %s, stderr = %s' % (str(ec), err_msg))
+	if time_out == -1:
+		# Waiting forever
+		done = job_state.Wait(time_out)
+		if not done:
+			ec, err_msg = job_state.GetError
+			raise dbus.exceptions.DBusException(
+				interface_name,
+				'Exit code %s, stderr = %s' % (str(ec), err_msg))
+	elif time_out == 0:
+		# Immediately create and return a job
+		rc = _create_background_dbus_job(job_state)
+	else:
+		# Willing to wait for a bit
+		done = job_state.Wait(time_out)
+		if not done:
+			rc = _create_background_dbus_job(job_state)

-	cfg.load()
-	return '/'
+	return rc


 def move(interface_name, lv_name, pv_src_obj, pv_source_range,
-			pv_dests_and_ranges, move_options, job_state):
+			pv_dests_and_ranges, move_options, time_out):
 	"""
 	Common code for the pvmove handling.
 	:param interface_name:  What dbus interface we are providing for
@@ -66,8 +85,8 @@ def move(interface_name, lv_name, pv_src_obj, pv_source_range,
 	:param pv_source_range: (0,0 to ignore, else start, end segments)
 	:param pv_dests_and_ranges: Array of PV object paths and start/end segs
 	:param move_options: Hash with optional arguments
-	:param job_state: Used to convey information about jobs between processes
-	:return: '/' When complete, the empty object path
+	:param time_out:
+	:return: Object path to job object
 	"""
 	pv_dests = []
 	pv_src = cfg.om.get_object_by_path(pv_src_obj)
@@ -93,18 +112,18 @@ def move(interface_name, lv_name, pv_src_obj, pv_source_range,
 								pv_source_range,
 								pv_dests)

-		return _move_merge(interface_name, cmd, job_state)
+		return _move_merge(interface_name, cmd, time_out)
 	else:
 		raise dbus.exceptions.DBusException(
 			interface_name, 'pv_src_obj (%s) not found' % pv_src_obj)


-def merge(interface_name, lv_uuid, lv_name, merge_options, job_state):
+def merge(interface_name, lv_uuid, lv_name, merge_options, time_out):
 	# Make sure we have a dbus object representing it
 	dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
 	if dbo:
 		cmd = lv_merge_cmd(merge_options, dbo.lvm_id)
-		return _move_merge(interface_name, cmd, job_state)
+		return _move_merge(interface_name, cmd, time_out)
 	else:
 		raise dbus.exceptions.DBusException(
 			interface_name,
@@ -119,28 +138,30 @@ def background_reaper():
 				for i in range(num_threads, -1, -1):
 					_thread_list[i].join(0)
 					if not _thread_list[i].is_alive():
-						log_debug("Removing thread: %s" % _thread_list[i].name)
 						_thread_list.pop(i)

 		time.sleep(3)


-def background_execute(command, background_job):
+def process_background_result(job_object, exit_code, error_msg):
+	cfg.load()
+	job_object.set_result(exit_code, error_msg)
+	return None
+
+
+# noinspection PyUnusedLocal
+def empty_cb(disregard):
+	pass
+
+
+def background_execute(command, background_job, skip_first_line=False):

 	# Wrap this whole operation in an exception handler, otherwise if we
 	# hit a code bug we will silently exit this thread without anyone being
 	# the wiser.
 	try:
-		# We need to execute these command stand alone by forking & exec'ing
-		# the command always!
-		command.insert(0, cfg.LVM_CMD)
 		process = subprocess.Popen(command, stdout=subprocess.PIPE,
-									env=os.environ,
 									stderr=subprocess.PIPE, close_fds=True)
-
-		log_debug("Background process for %s is %d" %
-					(str(command), process.pid))
-
 		lines_iterator = iter(process.stdout.readline, b"")
 		for line in lines_iterator:
 			line_str = line.decode("utf-8")
@@ -149,8 +170,8 @@ def background_execute(command, background_job):
 			try:
 				if line_str.count(':') == 2:
 					(device, ignore, percentage) = line_str.split(':')
-					background_job.Percent = round(
-						float(percentage.strip()[:-1]), 1)
+					background_job.Percent = \
+						round(float(percentage.strip()[:-1]), 1)
 			except ValueError:
 				log_error("Trying to parse percentage which failed for %s" %
 					line_str)
@@ -159,20 +180,24 @@ def background_execute(command, background_job):

 		if process.returncode == 0:
 			background_job.Percent = 100
-		else:
-			log_error("Failed to execute background job %s, STDERR= %s"
-						% (str(command), out[1]))
-
-		background_job.set_result(process.returncode, out[1])
-		log_debug("Background process %d complete!" % process.pid)

+		# Queue up the result so that it gets executed in same thread as others.
+		r = RequestEntry(
+			-1, process_background_result,
+			(background_job, process.returncode, out[1]),
+			empty_cb, empty_cb, False)
+		cfg.worker_q.put(r)
 	except Exception:
-		# In the unlikely event that we blow up, we need to unblock caller which
-		# is waiting on an answer.
+		# In the unlikely event that we blew up, lets notify fill out the
+		# job object so that the client doesn't hang potentially forever!
 		st = traceback.format_exc()
 		error = "Exception in background thread: \n%s" % st
 		log_error(error)
-		background_job.set_result(1, error)
+		r = RequestEntry(
+			-1, process_background_result,
+			(background_job, 1, error),
+			empty_cb, empty_cb, False)
+		cfg.worker_q.put(r)


 def add(command, reporting_job):
@@ -185,30 +210,3 @@ def add(command, reporting_job):

 	with _rlock:
 		_thread_list.append(t)
-
-
-def wait_thread(job, timeout, cb, cbe):
-	# We need to put the wait on it's own thread, so that we don't block the
-	# entire dbus queue processing thread
-	try:
-		cb(job.state.Wait(timeout))
-	except Exception as e:
-		cbe("Wait exception: %s" % str(e))
-	return 0
-
-
-def add_wait(job, timeout, cb, cbe):
-
-	if timeout == 0:
-		# Users are basically polling, do not create thread
-		cb(job.Complete)
-	else:
-		t = threading.Thread(
-			target=wait_thread,
-			name="thread job.Wait: %s" % job.dbus_object_path(),
-			args=(job, timeout, cb, cbe)
-		)
-
-		t.start()
-		with _rlock:
-			_thread_list.append(t)
--- a/daemons/lvmdbusd/cfg.py
+++ b/daemons/lvmdbusd/cfg.py
@@ -11,8 +11,10 @@ import os
 import multiprocessing
 import queue
 import itertools
-
-from lvmdbusd import path
+try:
+	from . import path
+except SystemError:
+	import path

 LVM_CMD = os.getenv('LVM_BINARY', path.LVM_BINARY)

@@ -22,18 +24,14 @@ om = None
 # This is the global bus connection
 bus = None

-# Command line args
-args = None
-
-# Set to true if we are depending on external events for updates
-ee = False
-
 # Shared state variable across all processes
 run = multiprocessing.Value('i', 1)

-# If this is set to true, the current setup support lvm shell and we are
-# running in that mode of operation
-SHELL_IN_USE = None
+# Debug
+DEBUG = True
+
+# Use lvm shell
+USE_SHELL = False

 # Lock used by pprint
 stdout_lock = multiprocessing.Lock()
--- a/daemons/lvmdbusd/cmdhandler.py
+++ b/daemons/lvmdbusd/cmdhandler.py
@@ -12,8 +12,6 @@ import time
 import threading
 from itertools import chain
 import collections
-import traceback
-import os

 try:
 	from . import cfg
@@ -24,11 +22,6 @@ except SystemError:
 	from utils import pv_dest_ranges, log_debug, log_error
 	from lvm_shell_proxy import LVMShellProxy

-try:
-	import simplejson as json
-except ImportError:
-	import json
-
 SEP = '{|}'

 total_time = 0.0
@@ -38,6 +31,10 @@ total_count = 0
 # at the same time.
 cmd_lock = threading.RLock()

+# The actual method which gets called to invoke the lvm command, can vary
+# from forking a new process to using lvm shell
+_t_call = None
+

 class LvmExecutionMeta(object):

@@ -98,8 +95,7 @@ def call_lvm(command, debug=False):
 	# in different locations on the same box
 	command.insert(0, cfg.LVM_CMD)

-	process = Popen(command, stdout=PIPE, stderr=PIPE, close_fds=True,
-					env=os.environ)
+	process = Popen(command, stdout=PIPE, stderr=PIPE, close_fds=True)
 	out = process.communicate()

 	stdout_text = bytes(out[0]).decode("utf-8")
@@ -109,52 +105,36 @@ def call_lvm(command, debug=False):
 		_debug_c(command, process.returncode, (stdout_text, stderr_text))

 	if process.returncode == 0:
-		if cfg.args and cfg.args.debug and out[1] and len(out[1]) and \
-				'help' not in command:
+		if cfg.DEBUG and out[1] and len(out[1]):
 			log_error('WARNING: lvm is out-putting text to STDERR on success!')
 			_debug_c(command, process.returncode, (stdout_text, stderr_text))

 	return process.returncode, stdout_text, stderr_text

-# The actual method which gets called to invoke the lvm command, can vary
-# from forking a new process to using lvm shell
-_t_call = call_lvm
-

 def _shell_cfg():
 	global _t_call
-	try:
-		lvm_shell = LVMShellProxy()
-		_t_call = lvm_shell.call_lvm
-		cfg.SHELL_IN_USE = lvm_shell
-		return True
-	except Exception:
-		_t_call = call_lvm
-		cfg.SHELL_IN_USE = None
-		log_error(traceback.format_exc())
-		log_error("Unable to utilize lvm shell, dropping back to fork & exec")
-		return False
+	log_debug('Using lvm shell!')
+	lvm_shell = LVMShellProxy()
+	_t_call = lvm_shell.call_lvm
+
+
+if cfg.USE_SHELL:
+	_shell_cfg()
+else:
+	_t_call = call_lvm


 def set_execution(shell):
 	global _t_call
 	with cmd_lock:
-		# If the user requested lvm shell and we are currently setup that
-		# way, just return
-		if cfg.SHELL_IN_USE and shell:
-			return True
-		else:
-			if not shell and cfg.SHELL_IN_USE:
-				cfg.SHELL_IN_USE.exit_shell()
-				cfg.SHELL_IN_USE = None
-
-		_t_call = call_lvm
+		_t_call = None
 		if shell:
-			if cfg.args.use_json:
-				return _shell_cfg()
-			else:
-				return False
-		return True
+			log_debug('Using lvm shell!')
+			lvm_shell = LVMShellProxy()
+			_t_call = lvm_shell.call_lvm
+		else:
+			_t_call = call_lvm


 def time_wrapper(command, debug=False):
@@ -234,10 +214,6 @@ def pv_remove(device, remove_options):
 	return call(cmd)


-def _qt(tag_name):
-	return '@%s' % tag_name
-
-
 def _tag(operation, what, add, rm, tag_options):
 	cmd = [operation]
 	cmd.extend(options_to_cli_args(tag_options))
@@ -248,11 +224,9 @@ def _tag(operation, what, add, rm, tag_options):
 		cmd.append(what)

 	if add:
-		cmd.extend(list(chain.from_iterable(
-			('--addtag', _qt(x)) for x in add)))
+		cmd.extend(list(chain.from_iterable(('--addtag', x) for x in add)))
 	if rm:
-		cmd.extend(list(chain.from_iterable(
-			('--deltag', _qt(x)) for x in rm)))
+		cmd.extend(list(chain.from_iterable(('--deltag', x) for x in rm)))

 	return call(cmd, False)

@@ -432,7 +406,7 @@ def lv_cache_lv(cache_pool_full_name, lv_full_name, cache_options):
 	# lvconvert --type cache --cachepool VG/CachePoolLV VG/OriginLV
 	cmd = ['lvconvert']
 	cmd.extend(options_to_cli_args(cache_options))
-	cmd.extend(['-y', '--type', 'cache', '--cachepool',
+	cmd.extend(['--type', 'cache', '--cachepool',
 				cache_pool_full_name, lv_full_name])
 	return call(cmd)

@@ -452,66 +426,6 @@ def lv_detach_cache(lv_full_name, detach_options, destroy_cache):
 	return call(cmd)


-def supports_json():
-	cmd = ['help']
-	rc, out, err = call(cmd)
-	if rc == 0:
-		if cfg.SHELL_IN_USE:
-			return True
-		else:
-			if 'fullreport' in err:
-				return True
-	return False
-
-
-def lvm_full_report_json():
-	pv_columns = ['pv_name', 'pv_uuid', 'pv_fmt', 'pv_size', 'pv_free',
-					'pv_used', 'dev_size', 'pv_mda_size', 'pv_mda_free',
-					'pv_ba_start', 'pv_ba_size', 'pe_start', 'pv_pe_count',
-					'pv_pe_alloc_count', 'pv_attr', 'pv_tags', 'vg_name',
-					'vg_uuid']
-
-	pv_seg_columns = ['pvseg_start', 'pvseg_size', 'segtype',
-						'pv_uuid', 'lv_uuid', 'pv_name']
-
-	vg_columns = ['vg_name', 'vg_uuid', 'vg_fmt', 'vg_size', 'vg_free',
-					'vg_sysid', 'vg_extent_size', 'vg_extent_count',
-					'vg_free_count', 'vg_profile', 'max_lv', 'max_pv',
-					'pv_count', 'lv_count', 'snap_count', 'vg_seqno',
-					'vg_mda_count', 'vg_mda_free', 'vg_mda_size',
-					'vg_mda_used_count', 'vg_attr', 'vg_tags']
-
-	lv_columns = ['lv_uuid', 'lv_name', 'lv_path', 'lv_size',
-				'vg_name', 'pool_lv_uuid', 'pool_lv', 'origin_uuid',
-				'origin', 'data_percent',
-				'lv_attr', 'lv_tags', 'vg_uuid', 'lv_active', 'data_lv',
-				'metadata_lv', 'lv_parent', 'lv_role', 'lv_layout']
-
-	lv_seg_columns = ['seg_pe_ranges', 'segtype', 'lv_uuid']
-
-	cmd = _dc('fullreport', [
-		'-a',		# Need hidden too
-		'--configreport', 'pv', '-o', ','.join(pv_columns),
-		'--configreport', 'vg', '-o', ','.join(vg_columns),
-		'--configreport', 'lv', '-o', ','.join(lv_columns),
-		'--configreport', 'seg', '-o', ','.join(lv_seg_columns),
-		'--configreport', 'pvseg', '-o', ','.join(pv_seg_columns),
-		'--reportformat', 'json'
-	])
-
-	rc, out, err = call(cmd)
-	if rc == 0:
-		# With the current implementation, if we are using the shell then we
-		# are using JSON and JSON is returned back to us as it was parsed to
-		# figure out if we completed OK or not
-		if cfg.SHELL_IN_USE:
-			assert(type(out) == dict)
-			return out
-		else:
-			return json.loads(out)
-	return None
-
-
 def pv_retrieve_with_segs(device=None):
 	d = []
 	err = ""
@@ -522,7 +436,7 @@ def pv_retrieve_with_segs(device=None):
 				'pv_used', 'dev_size', 'pv_mda_size', 'pv_mda_free',
 				'pv_ba_start', 'pv_ba_size', 'pe_start', 'pv_pe_count',
 				'pv_pe_alloc_count', 'pv_attr', 'pv_tags', 'vg_name',
-				'vg_uuid', 'pvseg_start', 'pvseg_size', 'segtype']
+				'vg_uuid', 'pv_seg_start', 'pvseg_size', 'segtype']

 	# Lvm has some issues where it returns failure when querying pvs when other
 	# operations are in process, see:
--- a/daemons/lvmdbusd/job.py
+++ b/daemons/lvmdbusd/job.py
@@ -13,12 +13,11 @@ from . import cfg
 from .cfg import JOB_INTERFACE
 import dbus
 import threading
-from . import background


 # noinspection PyPep8Naming
 class JobState(object):
-	def __init__(self, request=None):
+	def __init__(self, request):
 		self.rlock = threading.RLock()

 		self._percent = 0
@@ -105,7 +104,7 @@ class JobState(object):

 # noinspection PyPep8Naming
 class Job(AutomatedProperties):
-	_Percent_meta = ('d', JOB_INTERFACE)
+	_Percent_meta = ('y', JOB_INTERFACE)
 	_Complete_meta = ('b', JOB_INTERFACE)
 	_Result_meta = ('o', JOB_INTERFACE)
 	_GetError_meta = ('(is)', JOB_INTERFACE)
@@ -121,7 +120,7 @@ class Job(AutomatedProperties):

 	@property
 	def Percent(self):
-		return dbus.Double(float(self.state.Percent))
+		return self.state.Percent

 	@Percent.setter
 	def Percent(self, value):
@@ -129,7 +128,7 @@ class Job(AutomatedProperties):

 	@property
 	def Complete(self):
-		return dbus.Boolean(self.state.Complete)
+		return self.state.Complete

 	@Complete.setter
 	def Complete(self, value):
@@ -137,7 +136,7 @@ class Job(AutomatedProperties):

 	@property
 	def GetError(self):
-		return dbus.Struct(self.state.GetError, signature="(is)")
+		return self.state.GetError

 	def set_result(self, ec, msg):
 		self.state.set_result(ec, msg)
@@ -153,14 +152,13 @@ class Job(AutomatedProperties):

 	@dbus.service.method(dbus_interface=JOB_INTERFACE,
 							in_signature='i',
-							out_signature='b',
-							async_callbacks=('cb', 'cbe'))
-	def Wait(self, timeout, cb, cbe):
-		background.add_wait(self, timeout, cb, cbe)
+							out_signature='b')
+	def Wait(self, timeout):
+		return self.state.Wait(timeout)

 	@property
 	def Result(self):
-		return dbus.ObjectPath(self.state.Result)
+		return self.state.Result

 	@property
 	def lvm_id(self):
--- a/daemons/lvmdbusd/lv.py
+++ b/daemons/lvmdbusd/lv.py
@@ -22,40 +22,6 @@ from .loader import common
 from .state import State
 from . import background
 from .utils import round_size
-from .job import JobState
-
-
-# Try and build a key for a LV, so that we sort the LVs with least dependencies
-# first.  This may be error prone because of the flexibility LVM
-# provides and what you can stack.
-def get_key(i):
-
-	name = i['lv_name']
-	parent = i['lv_parent']
-	pool = i['pool_lv']
-	a1 = ""
-	a2 = ""
-
-	if name[0] == '[':
-		a1 = '#'
-
-	# We have a parent
-	if parent:
-		# Check if parent is hidden
-		if parent[0] == '[':
-			a2 = '##'
-		else:
-			a2 = '#'
-
-	# If a LV has a pool, then it should be sorted/loaded after the pool
-	# lv, unless it's a hidden too, then after other hidden, but before visible
-	if pool:
-		if pool[0] != '[':
-			a2 += '~'
-		else:
-			a1 = '$' + a1
-
-	return "%s%s%s" % (a1, a2, name)


 # noinspection PyUnusedLocal
@@ -65,13 +31,7 @@ def lvs_state_retrieve(selection, cache_refresh=True):
 	if cache_refresh:
 		cfg.db.refresh()

-	# When building up the model, it's best to process LVs with the least
-	# dependencies to those that are dependant upon other LVs.  Otherwise, when
-	# we are trying to gather information we could be in a position where we
-	# don't have information available yet.
-	lvs = sorted(cfg.db.fetch_lvs(selection), key=get_key)
-
-	for l in lvs:
+	for l in cfg.db.fetch_lvs(selection):
 		rc.append(LvState(
 			l['lv_uuid'], l['lv_name'],
 			l['lv_path'], n(l['lv_size']),
@@ -101,16 +61,9 @@ class LvState(State):
 		rc = []
 		for pv in sorted(cfg.db.lv_contained_pv(uuid)):
 			(pv_uuid, pv_name, pv_segs) = pv
-			pv_obj = cfg.om.get_object_path_by_uuid_lvm_id(
+			pv_obj = cfg.om.get_object_path_by_lvm_id(
 				pv_uuid, pv_name, gen_new=False)
-
-			segs_decorate = []
-			for i in pv_segs:
-				segs_decorate.append((dbus.UInt64(i[0]),
-									dbus.UInt64(i[1]),
-									dbus.String(i[2])))
-
-			rc.append((dbus.ObjectPath(pv_obj), segs_decorate))
+			rc.append((pv_obj, pv_segs))

 		return dbus.Array(rc, signature="(oa(tts))")

@@ -131,10 +84,10 @@ class LvState(State):

 		for l in cfg.db.hidden_lvs(self.Uuid):
 			full_name = "%s/%s" % (vg_name, l[1])
-			op = cfg.om.get_object_path_by_uuid_lvm_id(
+			op = cfg.om.get_object_path_by_lvm_id(
 				l[0], full_name, gen_new=False)
 			assert op
-			rc.append(dbus.ObjectPath(op))
+			rc.append(op)
 		return rc

 	def __init__(self, Uuid, Name, Path, SizeBytes,
@@ -147,11 +100,11 @@ class LvState(State):
 		# value
 		self._segs = dbus.Array([], signature='s')
 		if not isinstance(segtypes, list):
-			self._segs.append(dbus.String(segtypes))
+			self._segs.append(segtypes)
 		else:
-			self._segs.extend([dbus.String(x) for x in set(segtypes)])
+			self._segs.extend(set(segtypes))

-		self.Vg = cfg.om.get_object_path_by_uuid_lvm_id(
+		self.Vg = cfg.om.get_object_path_by_lvm_id(
 			vg_uuid, vg_name, vg_obj_path_generate)

 		self.Devices = LvState._pv_devices(self.Uuid)
@@ -159,7 +112,7 @@ class LvState(State):
 		if PoolLv:
 			gen = utils.lv_object_path_method(Name, (Attr, layout, role))

-			self.PoolLv = cfg.om.get_object_path_by_uuid_lvm_id(
+			self.PoolLv = cfg.om.get_object_path_by_lvm_id(
 				pool_lv_uuid, '%s/%s' % (vg_name, PoolLv),
 				gen)
 		else:
@@ -167,7 +120,7 @@ class LvState(State):

 		if OriginLv:
 			self.OriginLv = \
-				cfg.om.get_object_path_by_uuid_lvm_id(
+				cfg.om.get_object_path_by_lvm_id(
 					origin_uuid, '%s/%s' % (vg_name, OriginLv),
 					vg_obj_path_generate)
 		else:
@@ -184,6 +137,8 @@ class LvState(State):
 			self.Name, (self.Attr, self.layout, self.role))

 	def _object_type_create(self):
+		if self.Name[0] == '[':
+			return LvCommon
 		if self.Attr[0] == 't':
 			return LvThinPool
 		elif self.Attr[0] == 'C':
@@ -191,8 +146,6 @@ class LvState(State):
 				return LvCachePool
 			else:
 				return LvCacheLv
-		elif self.Name[0] == '[':
-			return LvCommon
 		elif self.OriginLv != '/':
 			return LvSnapShot
 		else:
@@ -200,7 +153,7 @@ class LvState(State):

 	def create_dbus_object(self, path):
 		if not path:
-			path = cfg.om.get_object_path_by_uuid_lvm_id(
+			path = cfg.om.get_object_path_by_lvm_id(
 				self.Uuid, self.lvm_id, self._object_path_create())

 		obj_ctor = self._object_type_create()
@@ -226,7 +179,6 @@ class LvState(State):
@utils.dbus_property(LV_COMMON_INTERFACE, 'HiddenLvs', "ao")
 class LvCommon(AutomatedProperties):
 	_Tags_meta = ("as", LV_COMMON_INTERFACE)
-	_Roles_meta = ("as", LV_COMMON_INTERFACE)
 	_IsThinVolume_meta = ("b", LV_COMMON_INTERFACE)
 	_IsThinPool_meta = ("b", LV_COMMON_INTERFACE)
 	_Active_meta = ("b", LV_COMMON_INTERFACE)
@@ -259,16 +211,14 @@ class LvCommon(AutomatedProperties):
 					'V': 'thin Volume', 't': 'thin pool', 'T': 'Thin pool data',
 					'e': 'raid or pool metadata or pool metadata spare',
 					'-': 'Unspecified'}
-		return dbus.Struct((self.state.Attr[0], type_map[self.state.Attr[0]]),
-						signature="as")
+		return (self.state.Attr[0], type_map[self.state.Attr[0]])

 	@property
 	def Permissions(self):
 		type_map = {'w': 'writable', 'r': 'read-only',
 					'R': 'Read-only activation of non-read-only volume',
 					'-': 'Unspecified'}
-		return dbus.Struct((self.state.Attr[1], type_map[self.state.Attr[1]]),
-						signature="(ss)")
+		return (self.state.Attr[1], type_map[self.state.Attr[1]])

 	@property
 	def AllocationPolicy(self):
@@ -277,12 +227,11 @@ class LvCommon(AutomatedProperties):
 					'i': 'inherited', 'I': 'inherited locked',
 					'l': 'cling', 'L': 'cling locked',
 					'n': 'normal', 'N': 'normal locked', '-': 'Unspecified'}
-		return dbus.Struct((self.state.Attr[2], type_map[self.state.Attr[2]]),
-						signature="(ss)")
+		return (self.state.Attr[2], type_map[self.state.Attr[2]])

 	@property
 	def FixedMinor(self):
-		return dbus.Boolean(self.state.Attr[3] == 'm')
+		return self.state.Attr[3] == 'm'

 	@property
 	def State(self):
@@ -293,32 +242,29 @@ class LvCommon(AutomatedProperties):
 					'd': 'mapped device present without  tables',
 					'i': 'mapped device present with inactive table',
 					'X': 'unknown', '-': 'Unspecified'}
-		return dbus.Struct((self.state.Attr[4], type_map[self.state.Attr[4]]),
-						signature="(ss)")
+		return (self.state.Attr[4], type_map[self.state.Attr[4]])

 	@property
 	def TargetType(self):
 		type_map = {'C': 'Cache', 'm': 'mirror', 'r': 'raid',
 					's': 'snapshot', 't': 'thin', 'u': 'unknown',
 					'v': 'virtual', '-': 'Unspecified'}
-		return dbus.Struct((self.state.Attr[6], type_map[self.state.Attr[6]]),
-						signature="(ss)")
+		return (self.state.Attr[6], type_map[self.state.Attr[6]])

 	@property
 	def ZeroBlocks(self):
-		return dbus.Boolean(self.state.Attr[7] == 'z')
+		return self.state.Attr[7] == 'z'

 	@property
 	def Health(self):
 		type_map = {'p': 'partial', 'r': 'refresh',
 					'm': 'mismatches', 'w': 'writemostly',
 					'X': 'X unknown', '-': 'Unspecified'}
-		return dbus.Struct((self.state.Attr[8], type_map[self.state.Attr[8]]),
-					signature="(ss)")
+		return (self.state.Attr[8], type_map[self.state.Attr[8]])

 	@property
 	def SkipActivation(self):
-		return dbus.Boolean(self.state.Attr[9] == 'k')
+		return self.state.Attr[9] == 'k'

 	def vg_name_lookup(self):
 		return self.state.vg_name_lookup()
@@ -334,25 +280,21 @@ class LvCommon(AutomatedProperties):
 	def Tags(self):
 		return utils.parse_tags(self.state.Tags)

-	@property
-	def Roles(self):
-		return utils.parse_tags(self.state.role)
-
 	@property
 	def lvm_id(self):
 		return self.state.lvm_id

 	@property
 	def IsThinVolume(self):
-		return dbus.Boolean(self.state.Attr[0] == 'V')
+		return self.state.Attr[0] == 'V'

 	@property
 	def IsThinPool(self):
-		return dbus.Boolean(self.state.Attr[0] == 't')
+		return self.state.Attr[0] == 't'

 	@property
 	def Active(self):
-		return dbus.Boolean(self.state.active == "active")
+		return self.state.active == "active"

 	@dbus.service.method(
 		dbus_interface=LV_COMMON_INTERFACE,
@@ -364,18 +306,6 @@ class LvCommon(AutomatedProperties):

 # noinspection PyPep8Naming
 class Lv(LvCommon):
-	def _fetch_hidden(self, name):
-
-		# The name is vg/name
-		full_name = "%s/%s" % (self.vg_name_lookup(), name)
-		return cfg.om.get_object_path_by_lvm_id(full_name)
-
-	def _get_data_meta(self):
-
-		# Get the data
-		return (self._fetch_hidden(self.state.data_lv),
-				self._fetch_hidden(self.state.metadata_lv))
-
 	# noinspection PyUnusedLocal,PyPep8Naming
 	def __init__(self, object_path, object_state):
 		super(Lv, self).__init__(object_path, object_state)
@@ -458,21 +388,14 @@ class Lv(LvCommon):
 	@dbus.service.method(
 		dbus_interface=LV_INTERFACE,
 		in_signature='o(tt)a(ott)ia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
+		out_signature='o')
 	def Move(self, pv_src_obj, pv_source_range,
 				pv_dests_and_ranges,
-				tmo, move_options, cb, cbe):
-
-		job_state = JobState()
-
-		r = RequestEntry(
-				tmo, background.move,
-				(LV_INTERFACE, self.lvm_id, pv_src_obj, pv_source_range,
-				pv_dests_and_ranges, move_options, job_state), cb, cbe, False,
-				job_state)
-
-		cfg.worker_q.put(r)
+				tmo, move_options):
+		return background.move(
+			LV_INTERFACE, self.lvm_id, pv_src_obj,
+			pv_source_range, pv_dests_and_ranges,
+			move_options, tmo)

 	@staticmethod
 	def _snap_shot(lv_uuid, lv_name, name, optional_size,
@@ -485,6 +408,8 @@ class Lv(LvCommon):
 			# it is a thin lv
 			if not dbo.IsThinVolume:
 				if optional_size == 0:
+					# TODO: Should we pick a sane default or force user to
+					# make a decision?
 					space = dbo.SizeBytes / 80
 					remainder = space % 512
 					optional_size = space + 512 - remainder
@@ -704,6 +629,23 @@ class LvThinPool(Lv):
 	_DataLv_meta = ("o", THIN_POOL_INTERFACE)
 	_MetaDataLv_meta = ("o", THIN_POOL_INTERFACE)

+	def _fetch_hidden(self, name):
+
+		# The name is vg/name
+		full_name = "%s/%s" % (self.vg_name_lookup(), name)
+
+		o = cfg.om.get_object_by_lvm_id(full_name)
+		if o:
+			return o.dbus_object_path()
+
+		return '/'
+
+	def _get_data_meta(self):
+
+		# Get the data
+		return (self._fetch_hidden(self.state.data_lv),
+				self._fetch_hidden(self.state.metadata_lv))
+
 	def __init__(self, object_path, object_state):
 		super(LvThinPool, self).__init__(object_path, object_state)
 		self.set_interface(THIN_POOL_INTERFACE)
@@ -711,11 +653,11 @@ class LvThinPool(Lv):

 	@property
 	def DataLv(self):
-		return dbus.ObjectPath(self._data_lv)
+		return self._data_lv

 	@property
 	def MetaDataLv(self):
-		return dbus.ObjectPath(self._metadata_lv)
+		return self._metadata_lv

 	@staticmethod
 	def _lv_create(lv_uuid, lv_name, name, size_bytes, create_options):
@@ -760,21 +702,9 @@ class LvThinPool(Lv):

 # noinspection PyPep8Naming
 class LvCachePool(Lv):
-	_DataLv_meta = ("o", CACHE_POOL_INTERFACE)
-	_MetaDataLv_meta = ("o", CACHE_POOL_INTERFACE)
-
 	def __init__(self, object_path, object_state):
 		super(LvCachePool, self).__init__(object_path, object_state)
 		self.set_interface(CACHE_POOL_INTERFACE)
-		self._data_lv, self._metadata_lv = self._get_data_meta()
-
-	@property
-	def DataLv(self):
-		return dbus.ObjectPath(self._data_lv)
-
-	@property
-	def MetaDataLv(self):
-		return dbus.ObjectPath(self._metadata_lv)

 	@staticmethod
 	def _cache_lv(lv_uuid, lv_name, lv_object_path, cache_options):
@@ -797,7 +727,8 @@ class LvCachePool(Lv):
 				cfg.om.remove_object(lv_to_cache, emit_signal=True)
 				cfg.load()

-				lv_converted = cfg.om.get_object_path_by_lvm_id(fcn)
+				lv_converted = \
+					cfg.om.get_object_by_lvm_id(fcn).dbus_object_path()

 			else:
 				raise dbus.exceptions.DBusException(
@@ -839,7 +770,7 @@ class LvCacheLv(Lv):

 	@property
 	def CachePool(self):
-		return dbus.ObjectPath(self.state.PoolLv)
+		return self.state.PoolLv

 	@staticmethod
 	def _detach_lv(lv_uuid, lv_name, detach_options, destroy_cache):
@@ -860,7 +791,9 @@ class LvCacheLv(Lv):
 				cfg.om.remove_object(dbo, emit_signal=True)
 				cfg.load()

-				uncached_lv_path = cfg.om.get_object_path_by_lvm_id(lv_name)
+				uncached_lv_path = \
+					cfg.om.get_object_by_lvm_id(lv_name).dbus_object_path()
+
 			else:
 				raise dbus.exceptions.DBusException(
 					LV_INTERFACE,
@@ -894,13 +827,7 @@ class LvSnapShot(Lv):
 	@dbus.service.method(
 		dbus_interface=SNAPSHOT_INTERFACE,
 		in_signature='ia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
-	def Merge(self, tmo, merge_options, cb, cbe):
-		job_state = JobState()
-
-		r = RequestEntry(tmo, background.merge,
-							(SNAPSHOT_INTERFACE, self.Uuid, self.lvm_id,
-							merge_options, job_state), cb, cbe, False,
-							job_state)
-		cfg.worker_q.put(r)
+		out_signature='o')
+	def Merge(self, tmo, merge_options):
+		return background.merge(SNAPSHOT_INTERFACE, self.Uuid, self.lvm_id,
+								merge_options, tmo)
--- a/daemons/lvmdbusd/lvm_shell_proxy.py
+++ b/daemons/lvmdbusd/lvm_shell_proxy.py
@@ -14,22 +14,17 @@
 import subprocess
 import shlex
 from fcntl import fcntl, F_GETFL, F_SETFL
-import os
+from os import O_NONBLOCK
 import traceback
 import sys
-import tempfile
-import time
-import select
-import copy
+import re

 try:
-	import simplejson as json
-except ImportError:
-	import json
-
-
-from lvmdbusd.cfg import LVM_CMD
-from lvmdbusd.utils import log_debug, log_error
+	from .cfg import LVM_CMD
+	from .utils import log_debug, log_error
+except:
+	from cfg import LVM_CMD
+	from utils import log_debug, log_error

 SHELL_PROMPT = "lvm> "

@@ -43,52 +38,42 @@ def _quote_arg(arg):

 class LVMShellProxy(object):
 	def _read_until_prompt(self):
+		prev_ec = None
 		stdout = ""
-		report = ""
-		stderr = ""
-
-		# Try reading from all FDs to prevent one from filling up and causing
-		# a hang.  We are also assuming that we won't get the lvm prompt back
-		# until we have already received all the output from stderr and the
-		# report descriptor too.
 		while not stdout.endswith(SHELL_PROMPT):
 			try:
-				rd_fd = [
-					self.lvm_shell.stdout.fileno(),
-					self.report_r,
-					self.lvm_shell.stderr.fileno()]
-				ready = select.select(rd_fd, [], [], 2)
-
-				for r in ready[0]:
-					if r == self.lvm_shell.stdout.fileno():
-						while True:
-							tmp = self.lvm_shell.stdout.read()
-							if tmp:
-								stdout += tmp.decode("utf-8")
-							else:
-								break
-
-					elif r == self.report_r:
-						while True:
-							tmp = os.read(self.report_r, 16384)
-							if tmp:
-								report += tmp.decode("utf-8")
-								if len(tmp) != 16384:
-									break
-
-					elif r == self.lvm_shell.stderr.fileno():
-						while True:
-							tmp = self.lvm_shell.stderr.read()
-							if tmp:
-								stderr += tmp.decode("utf-8")
-							else:
-								break
-
-			except IOError as ioe:
-				log_debug(str(ioe))
+				tmp = self.lvm_shell.stdout.read()
+				if tmp:
+					stdout += tmp.decode("utf-8")
+			except IOError:
+				# nothing written yet
 				pass

-		return stdout, report, stderr
+		# strip the prompt from the STDOUT before returning and grab the exit
+		# code if it's available
+		m = self.re.match(stdout)
+		if m:
+			prev_ec = int(m.group(2))
+			strip_idx = -1 * len(m.group(1))
+		else:
+			strip_idx = -1 * len(SHELL_PROMPT)
+
+		return stdout[:strip_idx], prev_ec
+
+	def _read_line(self):
+		while True:
+			try:
+				tmp = self.lvm_shell.stdout.readline()
+				if tmp:
+					return tmp.decode("utf-8")
+			except IOError:
+				pass
+
+	def _discard_echo(self, expected):
+		line = ""
+		while line != expected:
+			# GNU readline inserts some interesting characters at times...
+			line += self._read_line().replace(' \r', '')

 	def _write_cmd(self, cmd):
 		cmd_bytes = bytes(cmd, "utf-8")
@@ -96,81 +81,39 @@ class LVMShellProxy(object):
 		assert (num_written == len(cmd_bytes))
 		self.lvm_shell.stdin.flush()

+	def _lvm_echos(self):
+		echo = False
+		cmd = "version\n"
+		self._write_cmd(cmd)
+		line = self._read_line()
+
+		if line == cmd:
+			echo = True
+
+		self._read_until_prompt()
+
+		return echo
+
 	def __init__(self):
-
-		# Create a temp directory
-		tmp_dir = tempfile.mkdtemp(prefix="lvmdbus_")
-		tmp_file = "%s/lvmdbus_report" % (tmp_dir)
-
-		try:
-			# Lets create fifo for the report output
-			os.mkfifo(tmp_file, 0o600)
-		except FileExistsError:
-			pass
-
-		self.report_r = os.open(tmp_file, os.O_NONBLOCK)
-
-		# Setup the environment for using our own socket for reporting
-		local_env = copy.deepcopy(os.environ)
-		local_env["LVM_REPORT_FD"] = "32"
-		local_env["LVM_COMMAND_PROFILE"] = "lvmdbusd"
-
-		flags = fcntl(self.report_r, F_GETFL)
-		fcntl(self.report_r, F_SETFL, flags | os.O_NONBLOCK)
+		self.re = re.compile(".*(\[(-?[0-9]+)\] lvm> $)", re.DOTALL)

 		# run the lvm shell
 		self.lvm_shell = subprocess.Popen(
-			[LVM_CMD + " 32>%s" % tmp_file],
-			stdin=subprocess.PIPE, stdout=subprocess.PIPE, env=local_env,
-			stderr=subprocess.PIPE, close_fds=True, shell=True)
+			[LVM_CMD], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+			stderr=subprocess.PIPE, close_fds=True)
 		flags = fcntl(self.lvm_shell.stdout, F_GETFL)
-		fcntl(self.lvm_shell.stdout, F_SETFL, flags | os.O_NONBLOCK)
+		fcntl(self.lvm_shell.stdout, F_SETFL, flags | O_NONBLOCK)
 		flags = fcntl(self.lvm_shell.stderr, F_GETFL)
-		fcntl(self.lvm_shell.stderr, F_SETFL, flags | os.O_NONBLOCK)
+		fcntl(self.lvm_shell.stderr, F_SETFL, flags | O_NONBLOCK)

 		# wait for the first prompt
-		errors = self._read_until_prompt()[2]
-		if errors and len(errors):
-			raise RuntimeError(errors)
+		self._read_until_prompt()

-		# These will get deleted when the FD count goes to zero so we can be
-		# sure to clean up correctly no matter how we finish
-		os.unlink(tmp_file)
-		os.rmdir(tmp_dir)
-
-	def get_error_msg(self):
-		# We got an error, lets go fetch the error message
-		self._write_cmd('lastlog\n')
-
-		# read everything from the STDOUT to the next prompt
-		stdout, report, stderr = self._read_until_prompt()
-
-		try:
-			log = json.loads(report)
-
-			if 'log' in log:
-				error_msg = ""
-				# Walk the entire log array and build an error string
-				for log_entry in log['log']:
-					if log_entry['log_type'] == "error":
-						if error_msg:
-							error_msg += ', ' + log_entry['log_message']
-						else:
-							error_msg = log_entry['log_message']
-
-				return error_msg
-
-			return 'No error reason provided! (missing "log" section)'
-		except ValueError:
-			log_error("Invalid JSON returned from LVM")
-			log_error("BEGIN>>\n%s\n<<END" % report)
-			return "Invalid JSON returned from LVM when retrieving exit code"
+		# Check to see if the version of LVM we are using is running with
+		# gnu readline which will echo our writes from stdin to stdout
+		self.echo = self._lvm_echos()

 	def call_lvm(self, argv, debug=False):
-		rc = 1
-		error_msg = ""
-		json_result = ""
-
 		# create the command string
 		cmd = " ".join(_quote_arg(arg) for arg in argv)
 		cmd += "\n"
@@ -178,36 +121,46 @@ class LVMShellProxy(object):
 		# run the command by writing it to the shell's STDIN
 		self._write_cmd(cmd)

-		# read everything from the STDOUT to the next prompt
-		stdout, report, stderr = self._read_until_prompt()
+		# If lvm is utilizing gnu readline, it echos stdin to stdout
+		if self.echo:
+			self._discard_echo(cmd)

-		# Parse the report to see what happened
-		if report and len(report):
-			json_result = json.loads(report)
-			if 'log' in json_result:
-				if json_result['log'][-1:][0]['log_ret_code'] == '1':
-					rc = 0
-				else:
-					error_msg = self.get_error_msg()
+		# read everything from the STDOUT to the next prompt
+		stdout, exit_code = self._read_until_prompt()
+
+		# read everything from STDERR if there's something (we waited for the
+		# prompt on STDOUT so there should be all or nothing at this point on
+		# STDERR)
+		stderr = None
+		try:
+			t_error = self.lvm_shell.stderr.read()
+			if t_error:
+				stderr = t_error.decode("utf-8")
+		except IOError:
+			# nothing on STDERR
+			pass
+
+		if exit_code is not None:
+			rc = exit_code
+		else:
+			# LVM does write to stderr even when it did complete successfully,
+			# so without having the exit code in the prompt we can never be
+			# sure.
+			if stderr:
+				rc = 1
+			else:
+				rc = 0

 		if debug or rc != 0:
 			log_error(('CMD: %s' % cmd))
 			log_error(("EC = %d" % rc))
-			log_error(("ERROR_MSG=\n %s\n" % error_msg))
+			log_error(("STDOUT=\n %s\n" % stdout))
+			log_error(("STDERR=\n %s\n" % stderr))

-		return rc, json_result, error_msg
-
-	def exit_shell(self):
-		try:
-			self._write_cmd('exit\n')
-		except Exception as e:
-			log_error(str(e))
+		return (rc, stdout, stderr)

 	def __del__(self):
-		try:
-			self.lvm_shell.terminate()
-		except:
-			pass
+		self.lvm_shell.terminate()


 if __name__ == "__main__":
@@ -217,15 +170,10 @@ if __name__ == "__main__":
 		while in_line:
 			in_line = input("lvm> ")
 			if in_line:
-				start = time.time()
-				ret, out, err = shell.call_lvm(in_line.split())
-				end = time.time()
-
-				print(("RC: %d" % ret))
-				# print(("OUT:\n%s" % out))
+				ret, out, err, = shell.call_lvm(in_line.split())
+				print(("RET: %d" % ret))
+				print(("OUT:\n%s" % out))
 				print(("ERR:\n%s" % err))
-
-				print("Command     = %f seconds" % (end - start))
 	except KeyboardInterrupt:
 		pass
 	except EOFError:
--- a/daemons/lvmdbusd/lvmdb.py
+++ b/daemons/lvmdbusd/lvmdb.py
@@ -13,14 +13,17 @@ from collections import OrderedDict

 import pprint as prettyprint
 import os
-import sys

-from lvmdbusd import cmdhandler
-from lvmdbusd.utils import log_debug, log_error
+try:
+	from . import cmdhandler
+	from .utils import log_debug, log_error
+except SystemError:
+	import cmdhandler
+	from utils import log_debug


 class DataStore(object):
-	def __init__(self, usejson=True):
+	def __init__(self):
 		self.pvs = {}
 		self.vgs = {}
 		self.lvs = {}
@@ -38,11 +41,6 @@ class DataStore(object):
 		# self.refresh()
 		self.num_refreshes = 0

-		if usejson:
-			self.json = cmdhandler.supports_json()
-		else:
-			self.json = usejson
-
 	@staticmethod
 	def _insert_record(table, key, record, allowed_multiple):
 		if key in table:
@@ -79,58 +77,7 @@ class DataStore(object):
 		for p in pvs:
 			DataStore._insert_record(
 				c_pvs, p['pv_uuid'], p,
-				['pvseg_start', 'pvseg_size', 'segtype'])
-
-		for p in c_pvs.values():
-			# Capture which PVs are associated with which VG
-			if p['vg_uuid'] not in c_pvs_in_vgs:
-				c_pvs_in_vgs[p['vg_uuid']] = []
-
-			if p['vg_name']:
-				c_pvs_in_vgs[p['vg_uuid']].append(
-					(p['pv_name'], p['pv_uuid']))
-
-			# Lookup for translating between /dev/<name> and pv uuid
-			c_lookup[p['pv_name']] = p['pv_uuid']
-
-		return c_pvs, c_lookup, c_pvs_in_vgs
-
-	@staticmethod
-	def _parse_pvs_json(_all):
-
-		c_pvs = OrderedDict()
-		c_lookup = {}
-		c_pvs_in_vgs = {}
-
-		# Each item item in the report is a collection of information pertaining
-		# to the vg
-		for r in _all['report']:
-			tmp_pv = []
-
-			# Get the pv data for this VG.
-			if 'pv' in r:
-				tmp_pv.extend(r['pv'])
-
-				# Sort them
-				sorted_tmp_pv = sorted(tmp_pv, key=lambda pk: pk['pv_name'])
-
-				# Add them to result set
-				for p in sorted_tmp_pv:
-					c_pvs[p['pv_uuid']] = p
-
-				if 'pvseg' in r:
-					for s in r['pvseg']:
-						r = c_pvs[s['pv_uuid']]
-						r.setdefault('pvseg_start', []).append(s['pvseg_start'])
-						r.setdefault('pvseg_size', []).append(s['pvseg_size'])
-						r.setdefault('segtype', []).append(s['segtype'])
-
-				# TODO: Remove this bug work around when we have orphan segs.
-				for i in c_pvs.values():
-					if 'pvseg_start' not in i:
-						i['pvseg_start'] = '0'
-						i['pvseg_size'] = i['pv_pe_count']
-						i['segtype'] = 'free'
+				['pv_seg_start', 'pvseg_size', 'segtype'])

 		for p in c_pvs.values():
 			# Capture which PVs are associated with which VG
@@ -160,31 +107,20 @@ class DataStore(object):
 		return c_vgs, c_lookup

 	@staticmethod
-	def _parse_vgs_json(_all):
+	def _parse_lvs(_lvs):
+		lvs = sorted(_lvs, key=lambda vk: vk['lv_name'])

-		tmp_vg = []
-		for r in _all['report']:
-			# Get the pv data for this VG.
-			if 'vg' in r:
-				tmp_vg.extend(r['vg'])
+		c_lvs = OrderedDict()
+		c_lvs_in_vgs = {}
+		c_lvs_hidden = {}
+		c_lv_full_lookup = {}

-		# Sort for consistent output, however this is optional
-		vgs = sorted(tmp_vg, key=lambda vk: vk['vg_name'])
-
-		c_vgs = OrderedDict()
-		c_lookup = {}
-
-		for i in vgs:
-			c_lookup[i['vg_name']] = i['vg_uuid']
-			c_vgs[i['vg_uuid']] = i
-
-		return c_vgs, c_lookup
-
-	@staticmethod
-	def _parse_lvs_common(c_lvs, c_lv_full_lookup):
-
-		c_lvs_in_vgs = OrderedDict()
-		c_lvs_hidden = OrderedDict()
+		for i in lvs:
+			full_name = "%s/%s" % (i['vg_name'], i['lv_name'])
+			c_lv_full_lookup[full_name] = i['lv_uuid']
+			DataStore._insert_record(
+				c_lvs, i['lv_uuid'], i,
+				['seg_pe_ranges', 'segtype'])

 		for i in c_lvs.values():
 			if i['vg_uuid'] not in c_lvs_in_vgs:
@@ -214,48 +150,6 @@ class DataStore(object):

 		return c_lvs, c_lvs_in_vgs, c_lvs_hidden, c_lv_full_lookup

-	@staticmethod
-	def _parse_lvs(_lvs):
-		lvs = sorted(_lvs, key=lambda vk: vk['lv_name'])
-
-		c_lvs = OrderedDict()
-		c_lv_full_lookup = OrderedDict()
-
-		for i in lvs:
-			full_name = "%s/%s" % (i['vg_name'], i['lv_name'])
-			c_lv_full_lookup[full_name] = i['lv_uuid']
-			DataStore._insert_record(
-				c_lvs, i['lv_uuid'], i,
-				['seg_pe_ranges', 'segtype'])
-
-		return DataStore._parse_lvs_common(c_lvs, c_lv_full_lookup)
-
-	@staticmethod
-	def _parse_lvs_json(_all):
-
-		c_lvs = OrderedDict()
-		c_lv_full_lookup = {}
-
-		# Each item item in the report is a collection of information pertaining
-		# to the vg
-		for r in _all['report']:
-			# Get the lv data for this VG.
-			if 'lv' in r:
-				# Add them to result set
-				for i in r['lv']:
-					full_name = "%s/%s" % (i['vg_name'], i['lv_name'])
-					c_lv_full_lookup[full_name] = i['lv_uuid']
-					c_lvs[i['lv_uuid']] = i
-
-				# Add in the segment data
-				if 'seg' in r:
-					for s in r['seg']:
-						r = c_lvs[s['lv_uuid']]
-						r.setdefault('seg_pe_ranges', []).append(s['seg_pe_ranges'])
-						r.setdefault('segtype', []).append(s['segtype'])
-
-		return DataStore._parse_lvs_common(c_lvs, c_lv_full_lookup)
-
 	@staticmethod
 	def _make_list(l):
 		if not isinstance(l, list):
@@ -384,22 +278,13 @@ class DataStore(object):
 			log_debug("lvmdb - refresh entry")

 		# Grab everything first then parse it
-		if self.json:
-			# Do a single lvm retrieve for everything in json
-			a = cmdhandler.lvm_full_report_json()
+		_raw_pvs = cmdhandler.pv_retrieve_with_segs()
+		_raw_vgs = cmdhandler.vg_retrieve(None)
+		_raw_lvs = cmdhandler.lv_retrieve_with_segments()

-			_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs_json(a)
-			_vgs, _vgs_lookup = self._parse_vgs_json(a)
-			_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs_json(a)
-
-		else:
-			_raw_pvs = cmdhandler.pv_retrieve_with_segs()
-			_raw_vgs = cmdhandler.vg_retrieve(None)
-			_raw_lvs = cmdhandler.lv_retrieve_with_segments()
-
-			_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs(_raw_pvs)
-			_vgs, _vgs_lookup = self._parse_vgs(_raw_vgs)
-			_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs(_raw_lvs)
+		_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs(_raw_pvs)
+		_vgs, _vgs_lookup = self._parse_vgs(_raw_vgs)
+		_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs(_raw_lvs)

 		# Set all
 		self.pvs = _pvs
@@ -463,7 +348,7 @@ class DataStore(object):

 	def pv_pe_segments(self, pv_uuid):
 		pv = self.pvs[pv_uuid]
-		return list(zip(pv['pvseg_start'], pv['pvseg_size']))
+		return list(zip(pv['pv_seg_start'], pv['pvseg_size']))

 	def pv_contained_lv(self, pv_device):
 		rc = []
@@ -504,20 +389,12 @@ class DataStore(object):
 if __name__ == "__main__":
 	pp = prettyprint.PrettyPrinter(indent=4)

-	use_json = False
-
-	if len(sys.argv) != 1:
-		print(len(sys.argv))
-		use_json = True
-
-	ds = DataStore(use_json)
+	ds = DataStore()
 	ds.refresh()

-	print("PVS")
 	for v in ds.pvs.values():
 		pp.pprint(v)

-	print("VGS")
 	for v in ds.vgs.values():
 		pp.pprint(v)

--- a/daemons/lvmdbusd/lvmdbusd
+++ b/daemons/lvmdbusd/lvmdbusd
@@ -10,7 +10,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.

 import sys
-from lvmdbusd import main
+import lvmdbusd

 if __name__ == '__main__':
-	sys.exit(main())
+	sys.exit(lvmdbusd.main())
--- a/daemons/lvmdbusd/main.py
+++ b/daemons/lvmdbusd/main.py
@@ -25,10 +25,9 @@ from .background import background_reaper
 import traceback
 import queue
 from . import udevwatch
-from .utils import log_debug, log_error
+from .utils import log_debug
 import argparse
 import os
-import sys
 from .refresh import handle_external_event, event_complete


@@ -93,44 +92,29 @@ def process_request():


 def main():
-	start = time.time()
 	# Add simple command line handling
 	parser = argparse.ArgumentParser()
-	parser.add_argument(
-		"--udev", action='store_true',
-		help="Use udev for updating state",
-		default=False,
-		dest='use_udev')
-	parser.add_argument(
-		"--debug", action='store_true',
-		help="Dump debug messages", default=False,
-		dest='debug')
-	parser.add_argument(
-		"--nojson", action='store_false',
-		help="Do not use LVM JSON output (disables lvmshell)", default=True,
-		dest='use_json')
-	parser.add_argument(
-		"--lvmshell", action='store_true',
-		help="Use the lvm shell, not fork & exec lvm",
-		default=False,
-		dest='use_lvm_shell')
+	parser.add_argument("--udev", action='store_true',
+						help="Use udev for updating state", default=False,
+						dest='use_udev')
+	parser.add_argument("--debug", action='store_true',
+						help="Dump debug messages", default=False,
+						dest='debug')

 	use_session = os.getenv('LVMDBUSD_USE_SESSION', False)

 	# Ensure that we get consistent output for parsing stdout/stderr
 	os.environ["LC_ALL"] = "C"

-	cfg.args = parser.parse_args()
+	args = parser.parse_args()

-	if cfg.args.use_lvm_shell and not cfg.args.use_json:
-		log_error("You cannot specify --lvmshell and --nojson")
-		sys.exit(1)
-
-	cmdhandler.set_execution(cfg.args.use_lvm_shell)
+	cfg.DEBUG = args.debug

 	# List of threads that we start up
 	thread_list = []

+	start = time.time()
+
 	# Install signal handlers
 	for s in [signal.SIGHUP, signal.SIGINT]:
 		try:
@@ -153,7 +137,7 @@ def main():

 	cfg.load = load

-	cfg.db = lvmdb.DataStore(cfg.args.use_json)
+	cfg.db = lvmdb.DataStore()

 	# Start up thread to monitor pv moves
 	thread_list.append(
@@ -169,25 +153,23 @@ def main():
 		process.damon = True
 		process.start()

-	# Add udev watching
-	if cfg.args.use_udev:
-		log_debug('Utilizing udev to trigger updates')
-
-	# In all cases we are going to monitor for udev until we get an
-	# ExternalEvent.  In the case where we get an external event and the user
-	# didn't specify --udev we will stop monitoring udev
-	udevwatch.add()
-
 	end = time.time()
 	log_debug(
-		'Service ready! total time= %.4f, lvm time= %.4f count= %d' %
+		'Service ready! total time= %.2f, lvm time= %.2f count= %d' %
 		(end - start, cmdhandler.total_time, cmdhandler.total_count),
 		'bg_black', 'fg_light_green')

+	# Add udev watching
+	if args.use_udev:
+		log_debug('Utilizing udev to trigger updates')
+		udevwatch.add()
+
 	try:
 		if cfg.run.value != 0:
 			cfg.loop.run()
-			udevwatch.remove()
+
+			if args.use_udev:
+				udevwatch.remove()

 			for process in thread_list:
 				process.join()
--- a/daemons/lvmdbusd/manager.py
+++ b/daemons/lvmdbusd/manager.py
@@ -17,12 +17,11 @@ from . import cmdhandler
 from .fetch import load_pvs, load_vgs
 from .request import RequestEntry
 from .refresh import event_add
-from . import udevwatch


 # noinspection PyPep8Naming
 class Manager(AutomatedProperties):
-	_Version_meta = ("s", MANAGER_INTERFACE)
+	_Version_meta = ("t", MANAGER_INTERFACE)

 	def __init__(self, object_path):
 		super(Manager, self).__init__(object_path)
@@ -30,14 +29,14 @@ class Manager(AutomatedProperties):

 	@property
 	def Version(self):
-		return dbus.String('1.0.0')
+		return '1.0.0'

 	@staticmethod
 	def _pv_create(device, create_options):

 		# Check to see if we are already trying to create a PV for an existing
 		# PV
-		pv = cfg.om.get_object_path_by_uuid_lvm_id(
+		pv = cfg.om.get_object_path_by_lvm_id(
 			device, device, None, False)
 		if pv:
 			raise dbus.exceptions.DBusException(
@@ -160,7 +159,7 @@ class Manager(AutomatedProperties):
 		:param key: The lookup value
 		:return: Return the object path.  If object not found you will get '/'
 		"""
-		p = cfg.om.get_object_path_by_uuid_lvm_id(
+		p = cfg.om.get_object_path_by_lvm_id(
 			key, key, gen_new=False)
 		if p:
 			return p
@@ -168,27 +167,20 @@ class Manager(AutomatedProperties):

 	@dbus.service.method(
 		dbus_interface=MANAGER_INTERFACE,
-		in_signature='b', out_signature='b')
+		in_signature='b')
 	def UseLvmShell(self, yes_no):
 		"""
 		Allow the client to enable/disable lvm shell, used for testing
 		:param yes_no:
 		:return: Nothing
 		"""
-		return dbus.Boolean(cmdhandler.set_execution(yes_no))
+		cmdhandler.set_execution(yes_no)

 	@dbus.service.method(
 		dbus_interface=MANAGER_INTERFACE,
 		in_signature='s', out_signature='i')
 	def ExternalEvent(self, command):

-		# If a user didn't explicitly specify udev, we will turn it off now.
-		if not cfg.args.use_udev:
-			if udevwatch.remove():
-				utils.log_debug("ExternalEvent received, disabling "
-								"udev monitoring")
-				# We are dependent on external events now to stay current!
-				cfg.ee = True
 		event_add((command,))
 		return dbus.Int32(0)

--- a/daemons/lvmdbusd/objectmanager.py
+++ b/daemons/lvmdbusd/objectmanager.py
@@ -124,8 +124,8 @@ class ObjectManager(AutomatedProperties):
 		with self.rlock:
 			path, props = dbus_object.emit_data()

-			# print('Registering object path %s for %s' %
-			# (path, dbus_object.lvm_id))
+			# print 'Registering object path %s for %s' %
+			# (path, dbus_object.lvm_id)

 			# We want fast access to the object by a number of different ways
 			# so we use multiple hashs with different keys
@@ -173,7 +173,7 @@ class ObjectManager(AutomatedProperties):
 	def get_object_by_uuid_lvm_id(self, uuid, lvm_id):
 		with self.rlock:
 			return self.get_object_by_path(
-				self.get_object_path_by_uuid_lvm_id(uuid, lvm_id, None, False))
+				self.get_object_path_by_lvm_id(uuid, lvm_id, None, False))

 	def get_object_by_lvm_id(self, lvm_id):
 		"""
@@ -185,17 +185,6 @@ class ObjectManager(AutomatedProperties):
 				return self.get_object_by_path(self._id_to_object_path[lvm_id])
 			return None

-	def get_object_path_by_lvm_id(self, lvm_id):
-		"""
-		Given an lvm identifier, return the object path for it
-		:param lvm_id: The lvm identifier
-		:return: Object path or '/' if not found
-		"""
-		with self.rlock:
-			if lvm_id in self._id_to_object_path:
-				return self._id_to_object_path[lvm_id]
-			return '/'
-
 	def _uuid_verify(self, path, uuid, lvm_id):
 		"""
 		Ensure uuid is present for a successful lvm_id lookup
@@ -223,8 +212,8 @@ class ObjectManager(AutomatedProperties):
 		self._uuid_verify(path, uuid, lvm_identifier)
 		return path

-	def get_object_path_by_uuid_lvm_id(self, uuid, lvm_id, path_create=None,
-										gen_new=True):
+	def get_object_path_by_lvm_id(self, uuid, lvm_id, path_create=None,
+								gen_new=True):
 		"""
 		For a given lvm asset return the dbus object registered to it.  If the
 		object is not found and gen_new == True and path_create is a valid
--- a/daemons/lvmdbusd/pv.py
+++ b/daemons/lvmdbusd/pv.py
@@ -55,6 +55,9 @@ class PvState(State):
 		return self.lvm_path

 	def _lv_object_list(self, vg_name):
+
+		# Note we are returning "a(oa(tts))"
+
 		rc = []
 		if vg_name:
 			for lv in sorted(cfg.db.pv_contained_lv(self.lvm_id)):
@@ -62,11 +65,11 @@ class PvState(State):
 				full_name = "%s/%s" % (vg_name, lv_name)

 				path_create = lv_object_path_method(lv_name, meta)
-				lv_path = cfg.om.get_object_path_by_uuid_lvm_id(
+				lv_path = cfg.om.get_object_path_by_lvm_id(
 					lv_uuid, full_name, path_create)

 				rc.append((lv_path, segs))
-		return rc
+		return dbus.Array(rc, signature="(oa(tts))")

 	# noinspection PyUnusedLocal,PyPep8Naming
 	def __init__(self, lvm_path, Uuid, Name,
@@ -80,7 +83,7 @@ class PvState(State):
 		self.lv = self._lv_object_list(vg_name)

 		if vg_name:
-			self.vg_path = cfg.om.get_object_path_by_uuid_lvm_id(
+			self.vg_path = cfg.om.get_object_path_by_lvm_id(
 				vg_uuid, vg_name, vg_obj_path_generate)
 		else:
 			self.vg_path = '/'
@@ -90,8 +93,8 @@ class PvState(State):

 	def create_dbus_object(self, path):
 		if not path:
-			path = cfg.om.get_object_path_by_uuid_lvm_id(self.Uuid, self.Name,
-														pv_obj_path_generate)
+			path = cfg.om.get_object_path_by_lvm_id(self.Uuid, self.Name,
+													pv_obj_path_generate)
 		return Pv(path, self)

 	# noinspection PyMethodMayBeStatic
@@ -238,20 +241,26 @@ class Pv(AutomatedProperties):
 	@property
 	def PeSegments(self):
 		if len(self.state.pe_segments):
-			return dbus.Array(self.state.pe_segments, signature='(tt)')
+			return self.state.pe_segments
 		return dbus.Array([], '(tt)')

 	@property
 	def Exportable(self):
-		return dbus.Boolean(self.state.attr[1] == 'x')
+		if self.state.attr[1] == 'x':
+			return True
+		return False

 	@property
 	def Allocatable(self):
-		return dbus.Boolean(self.state.attr[0] == 'a')
+		if self.state.attr[0] == 'a':
+			return True
+		return False

 	@property
 	def Missing(self):
-		return dbus.Boolean(self.state.attr[2] == 'm')
+		if self.state.attr[2] == 'm':
+			return True
+		return False

 	def object_path(self):
 		return self._object_path
@@ -266,8 +275,8 @@ class Pv(AutomatedProperties):

 	@property
 	def Lv(self):
-		return dbus.Array(self.state.lv, signature="(oa(tts))")
+		return self.state.lv

 	@property
 	def Vg(self):
-		return dbus.ObjectPath(self.state.vg_path)
+		return self.state.vg_path
--- a/daemons/lvmdbusd/request.py
+++ b/daemons/lvmdbusd/request.py
@@ -18,7 +18,7 @@ from .utils import log_error

 class RequestEntry(object):
 	def __init__(self, tmo, method, arguments, cb, cb_error,
-			return_tuple=True, job_state=None):
+			return_tuple=True):
 		self.tmo = tmo
 		self.method = method
 		self.arguments = arguments
@@ -29,11 +29,10 @@ class RequestEntry(object):
 		self.lock = threading.RLock()
 		self.done = False
 		self._result = None
-		self._job = None
+		self._job = False
 		self._rc = 0
 		self._rc_error = None
 		self._return_tuple = return_tuple
-		self._job_state = job_state

 		if self.tmo < 0:
 			# Client is willing to block forever
@@ -54,7 +53,7 @@ class RequestEntry(object):
 		r.timer_expired()

 	def _return_job(self):
-		self._job = Job(self, self._job_state)
+		self._job = Job(self)
 		cfg.om.register_object(self._job, True)
 		if self._return_tuple:
 			self.cb(('/', self._job.dbus_object_path()))
--- a/daemons/lvmdbusd/udevwatch.py
+++ b/daemons/lvmdbusd/udevwatch.py
@@ -8,12 +8,10 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.

 import pyudev
-import threading
 from .refresh import event_add
 from . import cfg

 observer = None
-observer_lock = threading.RLock()


 # noinspection PyUnusedLocal
@@ -42,20 +40,15 @@ def filter_event(action, device):


 def add():
-	with observer_lock:
-		global observer
-		context = pyudev.Context()
-		monitor = pyudev.Monitor.from_netlink(context)
-		monitor.filter_by('block')
-		observer = pyudev.MonitorObserver(monitor, filter_event)
-		observer.start()
+	global observer
+	context = pyudev.Context()
+	monitor = pyudev.Monitor.from_netlink(context)
+	monitor.filter_by('block')
+	observer = pyudev.MonitorObserver(monitor, filter_event)
+	observer.start()


 def remove():
-	with observer_lock:
-		global observer
-		if observer:
-			observer.stop()
-			observer = None
-			return True
-		return False
+	global observer
+	observer.stop()
+	observer = None
--- a/daemons/lvmdbusd/utils.py
+++ b/daemons/lvmdbusd/utils.py
@@ -13,13 +13,15 @@ import inspect
 import ctypes
 import os
 import string
-import datetime

 import dbus
 import dbus.service
 import dbus.mainloop.glib
-from lvmdbusd import cfg

+try:
+	from . import cfg
+except SystemError:
+	import cfg

 STDOUT_TTY = os.isatty(sys.stdout.fileno())

@@ -233,7 +235,7 @@ def parse_tags(tags):
 	if len(tags):
 		if ',' in tags:
 			return tags.split(',')
-		return dbus.Array(sorted([tags]), signature='s')
+		return sorted([tags])
 	return dbus.Array([], signature='s')


@@ -241,13 +243,7 @@ def _common_log(msg, *attributes):
 	cfg.stdout_lock.acquire()
 	tid = ctypes.CDLL('libc.so.6').syscall(186)

-	if STDOUT_TTY:
-		msg = "%s: %d:%d - %s" % \
-			(datetime.datetime.now().strftime("%b %d %H:%M:%S.%f"),
-			os.getpid(), tid, msg)
-
-	else:
-		msg = "%d:%d - %s" % (os.getpid(), tid, msg)
+	msg = "%d:%d - %s" % (os.getpid(), tid, msg)

 	if STDOUT_TTY and attributes:
 		print(color(msg, *attributes))
@@ -262,7 +258,7 @@ def _common_log(msg, *attributes):
 # @param msg    Message to output to stdout
 # @return None
 def log_debug(msg, *attributes):
-	if cfg.args and cfg.args.debug:
+	if cfg.DEBUG:
 		_common_log(msg, *attributes)


@@ -393,7 +389,7 @@ def round_size(size_bytes):
 	return size_bytes + bs - remainder


-_ALLOWABLE_CH = string.ascii_letters + string.digits + '#+-.:=@_\/%'
+_ALLOWABLE_CH = string.ascii_letters + string.digits + '#+.:=@_\/%'
 _ALLOWABLE_CH_SET = set(_ALLOWABLE_CH)

 _ALLOWABLE_VG_LV_CH = string.ascii_letters + string.digits + '.-_+'
--- a/daemons/lvmdbusd/vg.py
+++ b/daemons/lvmdbusd/vg.py
@@ -20,7 +20,6 @@ from .loader import common
 from .state import State
 from . import background
 from .utils import round_size
-from .job import JobState


 # noinspection PyUnusedLocal
@@ -67,7 +66,7 @@ class VgState(State):

 			gen = utils.lv_object_path_method(lv_name, meta)

-			lv_path = cfg.om.get_object_path_by_uuid_lvm_id(
+			lv_path = cfg.om.get_object_path_by_lvm_id(
 				lv_uuid, full_name, gen)
 			rc.append(lv_path)
 		return dbus.Array(rc, signature='o')
@@ -76,9 +75,9 @@ class VgState(State):
 		rc = []
 		for p in cfg.db.pvs_in_vg(self.Uuid):
 			(pv_name, pv_uuid) = p
-			rc.append(cfg.om.get_object_path_by_uuid_lvm_id(
+			rc.append(cfg.om.get_object_path_by_lvm_id(
 				pv_uuid, pv_name, pv_obj_path_generate))
-		return rc
+		return dbus.Array(rc, signature='o')

 	def __init__(self, Uuid, Name, Fmt,
 			SizeBytes, FreeBytes, SysId, ExtentSizeBytes,
@@ -91,7 +90,7 @@ class VgState(State):

 	def create_dbus_object(self, path):
 		if not path:
-			path = cfg.om.get_object_path_by_uuid_lvm_id(
+			path = cfg.om.get_object_path_by_lvm_id(
 				self.Uuid, self.Name, vg_obj_path_generate)
 		return Vg(path, self)

@@ -145,8 +144,13 @@ class Vg(AutomatedProperties):

 	@staticmethod
 	def fetch_new_lv(vg_name, lv_name):
+		full_name = "%s/%s" % (vg_name, lv_name)
+
 		cfg.load()
-		return cfg.om.get_object_by_lvm_id("%s/%s" % (vg_name, lv_name))
+		l = cfg.om.get_object_by_lvm_id(full_name)
+		created_lv = l.dbus_object_path()
+
+		return created_lv

 	@staticmethod
 	def _rename(uuid, vg_name, new_name, rename_options):
@@ -353,20 +357,12 @@ class Vg(AutomatedProperties):
 	@dbus.service.method(
 		dbus_interface=VG_INTERFACE,
 		in_signature='o(tt)a(ott)ia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
+		out_signature='o')
 	def Move(self, pv_src_obj, pv_source_range, pv_dests_and_ranges,
-			tmo, move_options, cb, cbe):
-
-		job_state = JobState()
-
-		r = RequestEntry(
-				tmo, background.move,
-				(VG_INTERFACE, None, pv_src_obj, pv_source_range,
-				pv_dests_and_ranges, move_options, job_state), cb, cbe, False,
-				job_state)
-
-		cfg.worker_q.put(r)
+			tmo, move_options):
+		return background.move(
+			VG_INTERFACE, None, pv_src_obj, pv_source_range,
+			pv_dests_and_ranges, move_options, tmo)

 	@staticmethod
 	def _lv_create(uuid, vg_name, name, size_bytes, pv_dests_and_ranges,
@@ -840,7 +836,9 @@ class Vg(AutomatedProperties):
 		cfg.worker_q.put(r)

 	def _attribute(self, pos, ch):
-		return dbus.Boolean(self.state.attr[pos] == ch)
+		if self.state.attr[pos] == ch:
+			return True
+		return False

 	@dbus.service.method(
 		dbus_interface=VG_INTERFACE,
@@ -906,11 +904,11 @@ class Vg(AutomatedProperties):

 	@property
 	def Pvs(self):
-		return dbus.Array(self.state.Pvs, signature='o')
+		return self.state.Pvs

 	@property
 	def Lvs(self):
-		return dbus.Array(self.state.Lvs, signature='o')
+		return self.state.Lvs

 	@property
 	def lvm_id(self):
--- a/daemons/lvmetad/lvmetactl.c
+++ b/daemons/lvmetad/lvmetactl.c
@@ -37,12 +37,11 @@ int main(int argc, char **argv)
 		printf("lvmetactl dump\n");
 		printf("lvmetactl pv_list\n");
 		printf("lvmetactl vg_list\n");
-		printf("lvmetactl get_global_info\n");
 		printf("lvmetactl vg_lookup_name <name>\n");
 		printf("lvmetactl vg_lookup_uuid <uuid>\n");
 		printf("lvmetactl pv_lookup_uuid <uuid>\n");
 		printf("lvmetactl set_global_invalid 0|1\n");
-		printf("lvmetactl set_global_disable 0|1\n");
+		printf("lvmetactl get_global_invalid\n");
 		printf("lvmetactl set_vg_version <uuid> <name> <version>\n");
 		printf("lvmetactl vg_lock_type <uuid>\n");
 		return -1;
@@ -55,32 +54,18 @@ int main(int argc, char **argv)
 	if (!strcmp(cmd, "dump")) {
 		reply = daemon_send_simple(h, "dump",
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		printf("%s\n", reply.buffer.mem);

 	} else if (!strcmp(cmd, "pv_list")) {
 		reply = daemon_send_simple(h, "pv_list",
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		printf("%s\n", reply.buffer.mem);

 	} else if (!strcmp(cmd, "vg_list")) {
 		reply = daemon_send_simple(h, "vg_list",
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else if (!strcmp(cmd, "get_global_info")) {
-		reply = daemon_send_simple(h, "get_global_info",
-					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		printf("%s\n", reply.buffer.mem);

@@ -94,26 +79,14 @@ int main(int argc, char **argv)
 		reply = daemon_send_simple(h, "set_global_info",
 					   "global_invalid = " FMTd64, (int64_t) val,
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		print_reply(reply);

-	} else if (!strcmp(cmd, "set_global_disable")) {
-		if (argc < 3) {
-			printf("set_global_disable 0|1\n");
-			return -1;
-		}
-		val = atoi(argv[2]);
-
-		reply = daemon_send_simple(h, "set_global_info",
-					   "global_disable = " FMTd64, (int64_t) val,
-					   "disable_reason = %s", LVMETAD_DISABLE_REASON_DIRECT,
+	} else if (!strcmp(cmd, "get_global_invalid")) {
+		reply = daemon_send_simple(h, "get_global_info",
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
-		print_reply(reply);
+		printf("%s\n", reply.buffer.mem);

 	} else if (!strcmp(cmd, "set_vg_version")) {
 		if (argc < 5) {
@@ -135,24 +108,18 @@ int main(int argc, char **argv)
 						   "name = %s", name,
 						   "version = " FMTd64, (int64_t) ver,
 						   "token = %s", "skip",
-						   "pid = " FMTd64, (int64_t)getpid(),
-						   "cmd = %s", "lvmetactl",
 						   NULL);
 		} else if (uuid) {
 			reply = daemon_send_simple(h, "set_vg_info",
 						   "uuid = %s", uuid,
 						   "version = " FMTd64, (int64_t) ver,
 						   "token = %s", "skip",
-						   "pid = " FMTd64, (int64_t)getpid(),
-						   "cmd = %s", "lvmetactl",
 						   NULL);
 		} else if (name) {
 			reply = daemon_send_simple(h, "set_vg_info",
 						   "name = %s", name,
 						   "version = " FMTd64, (int64_t) ver,
 						   "token = %s", "skip",
-						   "pid = " FMTd64, (int64_t)getpid(),
-						   "cmd = %s", "lvmetactl",
 						   NULL);
 		} else {
 			printf("name or uuid required\n");
@@ -171,8 +138,6 @@ int main(int argc, char **argv)
 		reply = daemon_send_simple(h, "vg_lookup",
 					   "name = %s", name,
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		printf("%s\n", reply.buffer.mem);

@@ -186,8 +151,6 @@ int main(int argc, char **argv)
 		reply = daemon_send_simple(h, "vg_lookup",
 					   "uuid = %s", uuid,
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		printf("%s\n", reply.buffer.mem);

@@ -204,8 +167,6 @@ int main(int argc, char **argv)
 		reply = daemon_send_simple(h, "vg_lookup",
 					   "uuid = %s", uuid,
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		/* printf("%s\n", reply.buffer.mem); */

@@ -232,8 +193,6 @@ int main(int argc, char **argv)
 		reply = daemon_send_simple(h, "pv_lookup",
 					   "uuid = %s", uuid,
 					   "token = %s", "skip",
-					   "pid = " FMTd64, (int64_t)getpid(),
-					   "cmd = %s", "lvmetactl",
 					   NULL);
 		printf("%s\n", reply.buffer.mem);

--- a/daemons/lvmetad/lvmetad-client.h
+++ b/daemons/lvmetad/lvmetad-client.h
@@ -19,13 +19,6 @@

 #define LVMETAD_SOCKET DEFAULT_RUN_DIR "/lvmetad.socket"

-#define LVMETAD_TOKEN_UPDATE_IN_PROGRESS "update in progress"
-
-#define LVMETAD_DISABLE_REASON_DIRECT		"DIRECT"
-#define LVMETAD_DISABLE_REASON_LVM1		"LVM1"
-#define LVMETAD_DISABLE_REASON_DUPLICATES	"DUPLICATES"
-#define LVMETAD_DISABLE_REASON_VGRESTORE	"VGRESTORE"
-
 struct volume_group;

 /* Different types of replies we may get from lvmetad. */
--- a/daemons/lvmetad/lvmetad-core.c
+++ b/daemons/lvmetad/lvmetad-core.c
--- a/daemons/lvmetad/testclient.c
+++ b/daemons/lvmetad/testclient.c
@@ -75,10 +75,7 @@ int scan(daemon_handle h, char *fn) {
 	}

 	char uuid[64];
-	if (!id_write_format(dev->pvid, uuid, 64)) {
-		fprintf(stderr, "[C] Failed to format PV UUID for %s", dev_name(dev));
-		return;
-	}
+	id_write_format(dev->pvid, uuid, 64);
 	fprintf(stderr, "[C] found PV: %s\n", uuid);
 	struct lvmcache_info *info = (struct lvmcache_info *) label->info;
 	struct physical_volume pv = { 0, };
--- a/daemons/lvmlockd/lvmlockctl.c
+++ b/daemons/lvmlockd/lvmlockctl.c
@@ -77,7 +77,7 @@ static void save_client_info(char *line)
 	uint32_t client_id = 0;
 	char name[MAX_NAME+1] = { 0 };

-	(void) sscanf(line, "info=client pid=%u fd=%d pi=%d id=%u name=%s",
+	sscanf(line, "info=client pid=%u fd=%d pi=%d id=%u name=%s",
 	       &pid, &fd, &pi, &client_id, name);

 	clients[num_clients].client_id = client_id;
@@ -110,7 +110,7 @@ static void format_info_ls(char *line)
 	char lock_args[MAX_ARGS+1] = { 0 };
 	char lock_type[MAX_NAME+1] = { 0 };

-	(void) sscanf(line, "info=ls ls_name=%s vg_name=%s vg_uuid=%s vg_sysid=%s vg_args=%s lm_type=%s",
+	sscanf(line, "info=ls ls_name=%s vg_name=%s vg_uuid=%s vg_sysid=%s vg_args=%s lm_type=%s",
 	       ls_name, vg_name, vg_uuid, vg_sysid, lock_args, lock_type);

 	if (!first_ls)
@@ -131,7 +131,7 @@ static void format_info_ls_action(char *line)
 	uint32_t pid = 0;
 	char cl_name[MAX_NAME+1] = { 0 };

-	(void) sscanf(line, "info=ls_action client_id=%u %s %s op=%s",
+	sscanf(line, "info=ls_action client_id=%u %s %s op=%s",
 	       &client_id, flags, version, op);

 	find_client_info(client_id, &pid, cl_name);
@@ -147,7 +147,7 @@ static void format_info_r(char *line, char *r_name_out, char *r_type_out)
 	char sh_count[MAX_NAME+1] = { 0 };
 	uint32_t ver = 0;

-	(void) sscanf(line, "info=r name=%s type=%s mode=%s %s version=%u",
+	sscanf(line, "info=r name=%s type=%s mode=%s %s version=%u",
 	       r_name, r_type, mode, sh_count, &ver);

 	strcpy(r_name_out, r_name);
@@ -185,7 +185,7 @@ static void format_info_lk(char *line, char *r_name, char *r_type)
 		return;
 	}

-	(void) sscanf(line, "info=lk mode=%s version=%u %s client_id=%u",
+	sscanf(line, "info=lk mode=%s version=%u %s client_id=%u",
 	       mode, &ver, flags, &client_id);

 	find_client_info(client_id, &pid, cl_name);
@@ -221,7 +221,7 @@ static void format_info_r_action(char *line, char *r_name, char *r_type)
 		return;
 	}

-	(void) sscanf(line, "info=r_action client_id=%u %s %s op=%s rt=%s mode=%s %s %s %s",
+	sscanf(line, "info=r_action client_id=%u %s %s op=%s rt=%s mode=%s %s %s %s",
 	       &client_id, flags, version, op, rt, mode, lm, result, lm_rv);

 	find_client_info(client_id, &pid, cl_name);
--- a/daemons/lvmlockd/lvmlockd-core.c
+++ b/daemons/lvmlockd/lvmlockd-core.c
@@ -306,13 +306,7 @@ static const char *_syslog_num_to_name(int num)
 static uint64_t monotime(void)
 {
 	struct timespec ts;
-
-	if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
-		log_error("clock_gettime failed to get timestamp %s.",
-			  strerror(errno));
-		ts.tv_sec = 0;
-	}
-
+	clock_gettime(CLOCK_MONOTONIC, &ts);
 	return ts.tv_sec;
 }

@@ -1013,7 +1007,6 @@ static daemon_reply send_lvmetad(const char *id, ...)
 	daemon_reply reply;
 	va_list ap;
 	int retries = 0;
-	int err;

 	va_start(ap, id);

@@ -1023,28 +1016,20 @@ static daemon_reply send_lvmetad(const char *id, ...)
 	 */
 	pthread_mutex_lock(&lvmetad_mutex);
 retry:
-	if (!lvmetad_connected) {
-		lvmetad_handle = lvmetad_open(NULL);
-		if (lvmetad_handle.error || lvmetad_handle.socket_fd < 0) {
-			err = lvmetad_handle.error ?: lvmetad_handle.socket_fd;
-			pthread_mutex_unlock(&lvmetad_mutex);
-			log_error("lvmetad_open reconnect error %d", err);
-			memset(&reply, 0, sizeof(reply));
-			reply.error = err;
-			va_end(ap);
-			return reply;
-		} else {
-			log_debug("lvmetad reconnected");
-			lvmetad_connected = 1;
-		}
-	}
-
 	reply = daemon_send_simple_v(lvmetad_handle, id, ap);

 	/* lvmetad may have been restarted */
 	if ((reply.error == ECONNRESET) && (retries < 2)) {
 		daemon_close(lvmetad_handle);
 		lvmetad_connected = 0;
+
+		lvmetad_handle = lvmetad_open(NULL);
+		if (lvmetad_handle.error || lvmetad_handle.socket_fd < 0) {
+			log_error("lvmetad_open reconnect error %d", lvmetad_handle.error);
+		} else {
+			log_debug("lvmetad reconnected");
+			lvmetad_connected = 1;
+		}
 		retries++;
 		goto retry;
 	}
@@ -1249,6 +1234,10 @@ static int res_lock(struct lockspace *ls, struct resource *r, struct action *act
 		rv = -EREMOVED;
 	}

+	if (!lvmetad_connected && inval_meta)
+		log_debug("S %s R %s res_lock no lvmetad connection to invalidate",
+			  ls->name, r->name);
+
 	/*
 	 * r is vglk: tell lvmetad to set the vg invalid
 	 * flag, and provide the new r_version.  If lvmetad finds
@@ -1264,7 +1253,7 @@ static int res_lock(struct lockspace *ls, struct resource *r, struct action *act
 	 * caches, and tell lvmetad to set global invalid to 0.
 	 */

-	if (inval_meta && (r->type == LD_RT_VG)) {
+	if (lvmetad_connected && inval_meta && (r->type == LD_RT_VG)) {
 		daemon_reply reply;
 		char *uuid;

@@ -1288,7 +1277,7 @@ static int res_lock(struct lockspace *ls, struct resource *r, struct action *act
 		daemon_reply_destroy(reply);
 	}

-	if (inval_meta && (r->type == LD_RT_GL)) {
+	if (lvmetad_connected && inval_meta && (r->type == LD_RT_GL)) {
 		daemon_reply reply;

 		log_debug("S %s R %s res_lock set lvmetad global invalid",
@@ -1654,9 +1643,6 @@ static int res_able(struct lockspace *ls, struct resource *r,
 	}

 	rv = lm_able_gl_sanlock(ls, act->op == LD_OP_ENABLE);
-
-	if (!rv && (act->op == LD_OP_ENABLE))
-		gl_vg_removed = 0;
 out:
 	return rv;
 }
@@ -2630,10 +2616,8 @@ out_act:

 	if (free_vg && ls->sanlock_gl_enabled && act_op_free) {
 		pthread_mutex_lock(&lockspaces_mutex);
-		if (other_sanlock_vgs_exist(ls)) {
+		if (other_sanlock_vgs_exist(ls))
 			act_op_free->flags |= LD_AF_WARN_GL_REMOVED;
-			gl_vg_removed = 1;
-		}
 		pthread_mutex_unlock(&lockspaces_mutex);
 	}

@@ -3356,10 +3340,7 @@ static void *worker_thread_main(void *arg_in)

 	while (1) {
 		pthread_mutex_lock(&worker_mutex);
-		if (clock_gettime(CLOCK_REALTIME, &ts)) {
-			log_error("clock_gettime failed.");
-			ts.tv_sec = ts.tv_nsec = 0;
-		}
+		clock_gettime(CLOCK_REALTIME, &ts);
 		ts.tv_sec += delay_sec;
 		rv = 0;
 		act = NULL;
@@ -3673,7 +3654,7 @@ static int client_send_result(struct client *cl, struct action *act)
 	if (act->flags & LD_AF_DUP_GL_LS)
 		strcat(result_flags, "DUP_GL_LS,");

-	if ((act->flags & LD_AF_WARN_GL_REMOVED) || gl_vg_removed)
+	if (act->flags & LD_AF_WARN_GL_REMOVED)
 		strcat(result_flags, "WARN_GL_REMOVED,");
 	
 	if (act->op == LD_OP_INIT) {
--- a/daemons/lvmlockd/lvmlockd-internal.h
+++ b/daemons/lvmlockd/lvmlockd-internal.h
@@ -320,7 +320,6 @@ static inline int list_empty(const struct list_head *head)
 EXTERN int gl_type_static;
 EXTERN int gl_use_dlm;
 EXTERN int gl_use_sanlock;
-EXTERN int gl_vg_removed;
 EXTERN char gl_lsname_dlm[MAX_NAME+1];
 EXTERN char gl_lsname_sanlock[MAX_NAME+1];
 EXTERN int global_dlm_lockspace_exists;
--- a/daemons/lvmlockd/lvmlockd-sanlock.c
+++ b/daemons/lvmlockd/lvmlockd-sanlock.c
@@ -206,7 +206,7 @@ int lm_data_size_sanlock(void)
 #define VG_LOCK_BEGIN UINT64_C(66)
 #define LV_LOCK_BEGIN UINT64_C(67)

-static uint64_t daemon_test_lv_count;
+static unsigned int daemon_test_lv_count;

 static int lock_lv_name_from_args(char *vg_args, char *lock_lv_name)
 {
@@ -276,8 +276,8 @@ static int read_host_id_file(void)
 		*sep = '\0';
 		memset(key_str, 0, sizeof(key_str));
 		memset(val_str, 0, sizeof(val_str));
-		(void) sscanf(key, "%s", key_str);
-		(void) sscanf(val, "%s", val_str);
+		sscanf(key, "%s", key_str);
+		sscanf(val, "%s", val_str);

 		if (!strcmp(key_str, "host_id")) {
 			host_id = atoi(val_str);
--- a/daemons/lvmpolld/lvmpolld-cmd-utils.c
+++ b/daemons/lvmpolld/lvmpolld-cmd-utils.c
@@ -31,7 +31,7 @@ const char *polling_op(enum poll_type type)

 static int add_to_cmd_arr(const char ***cmdargv, const char *str, unsigned *ind)
 {
-	const char **newargv;
+	const char **newargv = *cmdargv;

 	if (*ind && !(*ind % MIN_ARGV_SIZE)) {
 		newargv = dm_realloc(*cmdargv, (*ind / MIN_ARGV_SIZE + 1) * MIN_ARGV_SIZE * sizeof(char *));
--- a/doc/kernel/cache-policies.txt
+++ b/doc/kernel/cache-policies.txt
@@ -11,7 +11,7 @@ Every bio that is mapped by the target is referred to the policy.
 The policy can return a simple HIT or MISS or issue a migration.

 Currently there's no way for the policy to issue background work,
-e.g. to start writing back dirty blocks that are going to be evicted
+e.g. to start writing back dirty blocks that are going to be evicte
 soon.

 Because we map bios, rather than requests it's easy for the policy
@@ -25,77 +25,53 @@ trying to see when the io scheduler has let the ios run.
 Overview of supplied cache replacement policies
 ===============================================

-multiqueue (mq)
---------------
+multiqueue
+----------

-This policy is now an alias for smq (see below).
+This policy is the default.

-The following tunables are accepted, but have no effect:
+The multiqueue policy has three sets of 16 queues: one set for entries
+waiting for the cache and another two for those in the cache (a set for
+clean entries and a set for dirty entries).

+Cache entries in the queues are aged based on logical time. Entry into
+the cache is based on variable thresholds and queue selection is based
+on hit count on entry. The policy aims to take different cache miss
+costs into account and to adjust to varying load patterns automatically.
+
+Message and constructor argument pairs are:
 	'sequential_threshold <#nr_sequential_ios>'
 	'random_threshold <#nr_random_ios>'
 	'read_promote_adjustment <value>'
 	'write_promote_adjustment <value>'
 	'discard_promote_adjustment <value>'

-Stochastic multiqueue (smq)
---------------------------
+The sequential threshold indicates the number of contiguous I/Os
+required before a stream is treated as sequential.  Once a stream is
+considered sequential it will bypass the cache.  The random threshold
+is the number of intervening non-contiguous I/Os that must be seen
+before the stream is treated as random again.

-This policy is the default.
+The sequential and random thresholds default to 512 and 4 respectively.

-The stochastic multi-queue (smq) policy addresses some of the problems
-with the multiqueue (mq) policy.
+Large, sequential I/Os are probably better left on the origin device
+since spindles tend to have good sequential I/O bandwidth.  The
+io_tracker counts contiguous I/Os to try to spot when the I/O is in one
+of these sequential modes.  But there are use-cases for wanting to
+promote sequential blocks to the cache (e.g. fast application startup).
+If sequential threshold is set to 0 the sequential I/O detection is
+disabled and sequential I/O will no longer implicitly bypass the cache.
+Setting the random threshold to 0 does _not_ disable the random I/O
+stream detection.

-The smq policy (vs mq) offers the promise of less memory utilization,
-improved performance and increased adaptability in the face of changing
-workloads.  smq also does not have any cumbersome tuning knobs.
-
-Users may switch from "mq" to "smq" simply by appropriately reloading a
-DM table that is using the cache target.  Doing so will cause all of the
-mq policy's hints to be dropped.  Also, performance of the cache may
-degrade slightly until smq recalculates the origin device's hotspots
-that should be cached.
-
-Memory usage:
-The mq policy used a lot of memory; 88 bytes per cache block on a 64
-bit machine.
-
-smq uses 28bit indexes to implement it's data structures rather than
-pointers.  It avoids storing an explicit hit count for each block.  It
-has a 'hotspot' queue, rather than a pre-cache, which uses a quarter of
-the entries (each hotspot block covers a larger area than a single
-cache block).
-
-All this means smq uses ~25bytes per cache block.  Still a lot of
-memory, but a substantial improvement nontheless.
-
-Level balancing:
-mq placed entries in different levels of the multiqueue structures
-based on their hit count (~ln(hit count)).  This meant the bottom
-levels generally had the most entries, and the top ones had very
-few.  Having unbalanced levels like this reduced the efficacy of the
-multiqueue.
-
-smq does not maintain a hit count, instead it swaps hit entries with
-the least recently used entry from the level above.  The overall
-ordering being a side effect of this stochastic process.  With this
-scheme we can decide how many entries occupy each multiqueue level,
-resulting in better promotion/demotion decisions.
-
-Adaptability:
-The mq policy maintained a hit count for each cache block.  For a
-different block to get promoted to the cache it's hit count has to
-exceed the lowest currently in the cache.  This meant it could take a
-long time for the cache to adapt between varying IO patterns.
-
-smq doesn't maintain hit counts, so a lot of this problem just goes
-away.  In addition it tracks performance of the hotspot queue, which
-is used to decide which blocks to promote.  If the hotspot queue is
-performing badly then it starts moving entries more quickly between
-levels.  This lets it adapt to new IO patterns very quickly.
-
-Performance:
-Testing smq shows substantially better performance than mq.
+Internally the mq policy determines a promotion threshold.  If the hit
+count of a block not in the cache goes above this threshold it gets
+promoted to the cache.  The read, write and discard promote adjustment
+tunables allow you to tweak the promotion threshold by adding a small
+value based on the io type.  They default to 4, 8 and 1 respectively.
+If you're trying to quickly warm a new cache device you may wish to
+reduce these to encourage promotion.  Remember to switch them back to
+their defaults after the cache fills though.

 cleaner
 -------
--- a/doc/kernel/cache.txt
+++ b/doc/kernel/cache.txt
@@ -221,7 +221,6 @@ Status
 <#read hits> <#read misses> <#write hits> <#write misses>
 <#demotions> <#promotions> <#dirty> <#features> <features>*
 <#core args> <core args>* <policy name> <#policy args> <policy args>*
-<cache metadata mode>

 metadata block size	 : Fixed block size for each metadata block in
 			     sectors
@@ -252,18 +251,8 @@ core args		 : Key/value pairs for tuning the core
 			     e.g. migration_threshold
 policy name		 : Name of the policy
 #policy args		 : Number of policy arguments to follow (must be even)
-policy args		 : Key/value pairs e.g. sequential_threshold
-cache metadata mode      : ro if read-only, rw if read-write
-	In serious cases where even a read-only mode is deemed unsafe
-	no further I/O will be permitted and the status will just
-	contain the string 'Fail'.  The userspace recovery tools
-	should then be used.
-needs_check		 : 'needs_check' if set, '-' if not set
-	A metadata operation has failed, resulting in the needs_check
-	flag being set in the metadata's superblock.  The metadata
-	device must be deactivated and checked/repaired before the
-	cache can be made fully operational again.  '-' indicates
-	needs_check is not set.
+policy args		 : Key/value pairs
+			     e.g. sequential_threshold

 Messages
 --------
--- a/doc/kernel/delay.txt
+++ b/doc/kernel/delay.txt
@@ -8,7 +8,6 @@ Parameters:
    <device> <offset> <delay> [<write_device> <write_offset> <write_delay>]

 With separate write parameters, the first set is only used for reads.
-Offsets are specified in sectors.
 Delays are specified in milliseconds.

 Example scripts
--- a/doc/kernel/raid.txt
+++ b/doc/kernel/raid.txt
@@ -209,37 +209,6 @@ include:
 	"repair" - Initiate a repair of the array.
 	"reshape"- Currently unsupported (-EINVAL).

-
-Discard Support
---------------
-The implementation of discard support among hardware vendors varies.
-When a block is discarded, some storage devices will return zeroes when
-the block is read.  These devices set the 'discard_zeroes_data'
-attribute.  Other devices will return random data.  Confusingly, some
-devices that advertise 'discard_zeroes_data' will not reliably return
-zeroes when discarded blocks are read!  Since RAID 4/5/6 uses blocks
-from a number of devices to calculate parity blocks and (for performance
-reasons) relies on 'discard_zeroes_data' being reliable, it is important
-that the devices be consistent.  Blocks may be discarded in the middle
-of a RAID 4/5/6 stripe and if subsequent read results are not
-consistent, the parity blocks may be calculated differently at any time;
-making the parity blocks useless for redundancy.  It is important to
-understand how your hardware behaves with discards if you are going to
-enable discards with RAID 4/5/6.
-
-Since the behavior of storage devices is unreliable in this respect,
-even when reporting 'discard_zeroes_data', by default RAID 4/5/6
-discard support is disabled -- this ensures data integrity at the
-expense of losing some performance.
-
-Storage devices that properly support 'discard_zeroes_data' are
-increasingly whitelisted in the kernel and can thus be trusted.
-
-For trusted devices, the following dm-raid module parameter can be set
-to safely enable discard support for RAID 4/5/6:
-    'devices_handle_discards_safely'
-
-
 Version History
 ---------------
 1.0.0	Initial version.  Support for RAID 4/5/6
@@ -255,5 +224,3 @@ Version History
 	New status (STATUSTYPE_INFO) fields: sync_action and mismatch_cnt.
 1.5.1   Add ability to restore transiently failed devices on resume.
 1.5.2   'mismatch_cnt' is zero unless [last_]sync_action is "check".
-1.6.0   Add discard support (and devices_handle_discard_safely module param).
-1.7.0   Add support for MD RAID0 mappings.
--- a/doc/kernel/snapshot.txt
+++ b/doc/kernel/snapshot.txt
@@ -41,13 +41,9 @@ useless and be disabled, returning errors.  So it is important to monitor
 the amount of free space and expand the <COW device> before it fills up.

 <persistent?> is P (Persistent) or N (Not persistent - will not survive
-after reboot).  O (Overflow) can be added as a persistent store option
-to allow userspace to advertise its support for seeing "Overflow" in the
-snapshot status.  So supported store types are "P", "PO" and "N".
-
-The difference between persistent and transient is with transient
-snapshots less metadata must be saved on disk - they can be kept in
-memory by the kernel.
+after reboot).
+The difference is that for transient snapshots less metadata must be
+saved on disk - they can be kept in memory by the kernel.


 * snapshot-merge <origin> <COW device> <persistent> <chunksize>
--- a/doc/kernel/statistics.txt
+++ b/doc/kernel/statistics.txt
@@ -13,14 +13,9 @@ the range specified.
 The I/O statistics counters for each step-sized area of a region are
 in the same format as /sys/block/*/stat or /proc/diskstats (see:
 Documentation/iostats.txt).  But two extra counters (12 and 13) are
-provided: total time spent reading and writing.  When the histogram
-argument is used, the 14th parameter is reported that represents the
-histogram of latencies.  All these counters may be accessed by sending
-the @stats_print message to the appropriate DM device via dmsetup.
-
-The reported times are in milliseconds and the granularity depends on
-the kernel ticks.  When the option precise_timestamps is used, the
-reported times are in nanoseconds.
+provided: total time spent reading and writing in milliseconds.	 All
+these counters may be accessed by sending the @stats_print message to
+the appropriate DM device via dmsetup.

 Each region has a corresponding unique identifier, which we call a
 region_id, that is assigned when the region is created.	 The region_id
@@ -38,9 +33,7 @@ memory is used by reading
 Messages
 ========

-    @stats_create <range> <step>
-		[<number_of_optional_arguments> <optional_arguments>...]
-		[<program_id> [<aux_data>]]
+    @stats_create <range> <step> [<program_id> [<aux_data>]]

 	Create a new region and return the region_id.

@@ -55,29 +48,6 @@ Messages
 	  "/<number_of_areas>" - the range is subdivided into the specified
 				 number of areas.

-	<number_of_optional_arguments>
-	  The number of optional arguments
-
-	<optional_arguments>
-	  The following optional arguments are supported
-	  precise_timestamps - use precise timer with nanosecond resolution
-		instead of the "jiffies" variable.  When this argument is
-		used, the resulting times are in nanoseconds instead of
-		milliseconds.  Precise timestamps are a little bit slower
-		to obtain than jiffies-based timestamps.
-	  histogram:n1,n2,n3,n4,... - collect histogram of latencies.  The
-		numbers n1, n2, etc are times that represent the boundaries
-		of the histogram.  If precise_timestamps is not used, the
-		times are in milliseconds, otherwise they are in
-		nanoseconds.  For each range, the kernel will report the
-		number of requests that completed within this range. For
-		example, if we use "histogram:10,20,30", the kernel will
-		report four numbers a:b:c:d. a is the number of requests
-		that took 0-10 ms to complete, b is the number of requests
-		that took 10-20 ms to complete, c is the number of requests
-		that took 20-30 ms to complete and d is the number of
-		requests that took more than 30 ms to complete.
-
 	<program_id>
 	  An optional parameter.  A name that uniquely identifies
 	  the userspace owner of the range.  This groups ranges together
@@ -85,9 +55,6 @@ Messages
 	  created and ignore those created by others.
 	  The kernel returns this string back in the output of
 	  @stats_list message, but it doesn't use it for anything else.
-	  If we omit the number of optional arguments, program id must not
-	  be a number, otherwise it would be interpreted as the number of
-	  optional arguments.

 	<aux_data>
 	  An optional parameter.  A word that provides auxiliary data
@@ -121,10 +88,6 @@ Messages

 	Output format:
 	  <region_id>: <start_sector>+<length> <step> <program_id> <aux_data>
-	        precise_timestamps histogram:n1,n2,n3,...
-
-	The strings "precise_timestamps" and "histogram" are printed only
-	if they were specified when creating the region.

    @stats_print <region_id> [<starting_line> <number_of_lines>]

@@ -205,7 +168,7 @@ statistics on them:

  dmsetup message vol 0 @stats_create - /100

-Set the auxiliary data string to "foo bar baz" (the escape for each
+Set the auxillary data string to "foo bar baz" (the escape for each
 space must also be escaped, otherwise the shell will consume them):

  dmsetup message vol 0 @stats_set_aux 0 foo\\ bar\\ baz
--- a/doc/kernel/thin-provisioning.txt
+++ b/doc/kernel/thin-provisioning.txt
@@ -296,7 +296,7 @@ ii) Status
 	underlying device.  When this is enabled when loading the table,
 	it can get disabled if the underlying device doesn't support it.

-    ro|rw|out_of_data_space
+    ro|rw
 	If the pool encounters certain types of device failures it will
 	drop into a read-only metadata mode in which no changes to
 	the pool metadata (like allocating new blocks) are permitted.
@@ -314,13 +314,6 @@ ii) Status
 	module parameter can be used to change this timeout -- it
 	defaults to 60 seconds but may be disabled using a value of 0.

-    needs_check
-	A metadata operation has failed, resulting in the needs_check
-	flag being set in the metadata's superblock.  The metadata
-	device must be deactivated and checked/repaired before the
-	thin-pool can be made fully operational again.  '-' indicates
-	needs_check is not set.
-
 iii) Messages

    create_thin <dev id>
--- a/doc/kernel/verity.txt
+++ b/doc/kernel/verity.txt
@@ -18,11 +18,11 @@ Construction Parameters

    0 is the original format used in the Chromium OS.
      The salt is appended when hashing, digests are stored continuously and
-      the rest of the block is padded with zeroes.
+      the rest of the block is padded with zeros.

    1 is the current format that should be used for new devices.
      The salt is prepended when hashing and each digest is
-      padded with zeroes to the power of two.
+      padded with zeros to the power of two.

 <dev>
    This is the device containing data, the integrity of which needs to be
@@ -79,37 +79,6 @@ restart_on_corruption
    not compatible with ignore_corruption and requires user space support to
    avoid restart loops.

-ignore_zero_blocks
-    Do not verify blocks that are expected to contain zeroes and always return
-    zeroes instead. This may be useful if the partition contains unused blocks
-    that are not guaranteed to contain zeroes.
-
-use_fec_from_device <fec_dev>
-    Use forward error correction (FEC) to recover from corruption if hash
-    verification fails. Use encoding data from the specified device. This
-    may be the same device where data and hash blocks reside, in which case
-    fec_start must be outside data and hash areas.
-
-    If the encoding data covers additional metadata, it must be accessible
-    on the hash device after the hash blocks.
-
-    Note: block sizes for data and hash devices must match. Also, if the
-    verity <dev> is encrypted the <fec_dev> should be too.
-
-fec_roots <num>
-    Number of generator roots. This equals to the number of parity bytes in
-    the encoding data. For example, in RS(M, N) encoding, the number of roots
-    is M-N.
-
-fec_blocks <num>
-    The number of encoding data blocks on the FEC device. The block size for
-    the FEC device is <data_block_size>.
-
-fec_start <offset>
-    This is the offset, in <data_block_size> blocks, from the start of the
-    FEC device to the beginning of the encoding data.
-
-
 Theory of operation
 ===================

@@ -129,11 +98,6 @@ per-block basis. This allows for a lightweight hash computation on first read
 into the page cache. Block hashes are stored linearly, aligned to the nearest
 block size.

-If forward error correction (FEC) support is enabled any recovery of
-corrupted data will be verified using the cryptographic hash of the
-corresponding data. This is why combining error correction with
-integrity checking is essential.
-
 Hash Tree
 ---------

--- a/include/.symlinks.in
+++ b/include/.symlinks.in
@@ -50,7 +50,6 @@
@top_srcdir@/lib/misc/lvm-file.h
@top_srcdir@/lib/misc/lvm-flock.h
@top_srcdir@/lib/misc/lvm-globals.h
-@top_srcdir@/lib/misc/lvm-maths.h
@top_srcdir@/lib/misc/lvm-percent.h
@top_srcdir@/lib/misc/lvm-signal.h
@top_srcdir@/lib/misc/lvm-string.h
--- a/include/configure.h.in
+++ b/include/configure.h.in
@@ -264,15 +264,9 @@
 /* Define to 1 if you have the <limits.h> header file. */
 #undef HAVE_LIMITS_H

-/* Define to 1 if you have the <linux/fiemap.h> header file. */
-#undef HAVE_LINUX_FIEMAP_H
-
 /* Define to 1 if you have the <linux/fs.h> header file. */
 #undef HAVE_LINUX_FS_H

-/* Define to 1 if you have the <linux/magic.h> header file. */
-#undef HAVE_LINUX_MAGIC_H
-
 /* Define to 1 if you have the <locale.h> header file. */
 #undef HAVE_LOCALE_H

--- a/lib/Makefile.in
+++ b/lib/Makefile.in
@@ -76,7 +76,6 @@ SOURCES =\
 	filters/filter-partitioned.c \
 	filters/filter-type.c \
 	filters/filter-usable.c \
-	filters/filter-internal.c \
 	format_text/archive.c \
 	format_text/archiver.c \
 	format_text/export.c \
@@ -112,7 +111,6 @@ SOURCES =\
 	misc/lvm-file.c \
 	misc/lvm-flock.c \
 	misc/lvm-globals.c \
-	misc/lvm-maths.c \
 	misc/lvm-signal.c \
 	misc/lvm-string.c \
 	misc/lvm-wrappers.c \
--- a/lib/activate/activate.c
+++ b/lib/activate/activate.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2016 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2013 Red Hat, Inc. All rights reserved.
 *
 * This file is part of LVM2.
 *
@@ -253,9 +253,8 @@ int lv_status(struct cmd_context *cmd, const struct lv_segment *lv_seg,
 int lv_cache_status(const struct logical_volume *cache_lv,
 		    struct lv_status_cache **status)
 {
-	return 0;
 }
-int lv_check_not_in_use(const struct logical_volume *lv, int error_if_used)
+int lv_check_not_in_use(const struct logical_volume *lv)
 {
        return 0;
 }
@@ -288,6 +287,18 @@ int lv_raid_message(const struct logical_volume *lv, const char *msg)
 {
 	return 0;
 }
+int lv_cache_block_info(struct logical_volume *lv,
+			uint32_t *chunk_size, uint64_t *dirty_count,
+			uint64_t *used_count, uint64_t *total_count)
+{
+	return 0;
+}
+int lv_cache_policy_info(struct logical_volume *lv,
+			 const char **policy_name, int *policy_argc,
+			 const char ***policy_argv)
+{
+	return 0;
+}
 int lv_thin_pool_percent(const struct logical_volume *lv, int metadata,
 			 dm_percent_t *percent)
 {
@@ -592,24 +603,7 @@ int module_present(struct cmd_context *cmd, const char *target_name)
 #ifdef MODPROBE_CMD
 	char module[128];
 	const char *argv[] = { MODPROBE_CMD, module, NULL };
-#endif
-	struct stat st;
-	char path[PATH_MAX];
-	int i = dm_snprintf(path, (sizeof(path) - 1), "%smodule/dm_%s",
-			    dm_sysfs_dir(), target_name);

-	if (i > 0) {
-		while (path[--i] != '/')  /* stop on dm_ */
-			if (path[i] == '-')
-				path[i] = '_'; /* replace '-' with '_' */
-
-		if ((lstat(path, &st) == 0) && S_ISDIR(st.st_mode)) {
-			log_debug_activation("Module directory %s exists.", path);
-			return 1;
-		}
-	}
-
-#ifdef MODPROBE_CMD
 	if (dm_snprintf(module, sizeof(module), "dm-%s", target_name) < 0) {
 		log_error("module_present module name too long: %s",
 			  target_name);
@@ -621,33 +615,25 @@ int module_present(struct cmd_context *cmd, const char *target_name)
 	return ret;
 }

-int target_present_version(struct cmd_context *cmd, const char *target_name,
-			   int use_modprobe,
-			   uint32_t *maj, uint32_t *min, uint32_t *patchlevel)
+int target_present(struct cmd_context *cmd, const char *target_name,
+		   int use_modprobe)
 {
-	if (!activation()) {
-		log_error(INTERNAL_ERROR "Target present version called when activation is disabled.");
+	uint32_t maj, min, patchlevel;
+
+	if (!activation())
 		return 0;
-	}
+
 #ifdef MODPROBE_CMD
 	if (use_modprobe) {
-		if (target_version(target_name, maj, min, patchlevel))
+		if (target_version(target_name, &maj, &min, &patchlevel))
 			return 1;

 		if (!module_present(cmd, target_name))
 			return_0;
 	}
 #endif
-	return target_version(target_name, maj, min, patchlevel);
-}

-int target_present(struct cmd_context *cmd, const char *target_name,
-		   int use_modprobe)
-{
-	uint32_t maj, min, patchlevel;
-
-	return target_present_version(cmd, target_name, use_modprobe,
-				      &maj, &min, &patchlevel);
+	return target_version(target_name, &maj, &min, &patchlevel);
 }

 static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv,
@@ -674,44 +660,16 @@ static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv,
 	/* New thin-pool has no layer, but -tpool suffix needs to be queried */
 	if (!use_layer && lv_is_new_thin_pool(lv)) {
 		/* Check if there isn't existing old thin pool mapping in the table */
-		if (!dev_manager_info(cmd, lv, NULL, 0, 0, &dminfo, NULL, NULL))
+		if (!dev_manager_info(cmd->mem, lv, NULL, 0, 0, &dminfo, NULL, NULL))
 			return_0;
 		if (!dminfo.exists)
 			use_layer = 1;
 	}

-	if (seg_status) {
-		/* TODO: for now it's mess with seg_status */
+	if (seg_status)
 		seg_status->seg = seg;
-		if (lv_is_merging_cow(lv)) {
-			if (lv_has_target_type(cmd->mem, origin_from_cow(lv), NULL, TARGET_NAME_SNAPSHOT_MERGE)) {
-				/*
-				 * When the snapshot-merge has not yet started, query COW LVs as is.
-				 * When merge is in progress, query merging origin LV instead.
-				 * COW volume is already mapped as error target in this case.
-				 */
-				lv = origin_from_cow(lv);
-				seg_status->seg = first_seg(lv);
-				log_debug_activation("Snapshot merge is in progress, querying status of %s instead.",
-						     display_lvname(lv));
-			}
-		} else if (!use_layer && lv_is_origin(lv) && !lv_is_external_origin(lv)) {
-			/*
-			 * Query status for 'layered' (-real) device most of the time,
-			 * only when snapshot merge started, query its progress.
-			 * TODO: single LV may need couple status to be exposed at once....
-			 *       but this needs more logical background
-			 */
-			if (!lv_is_merging_origin(lv) ||
-			    !lv_has_target_type(cmd->mem, origin_from_cow(lv), NULL, TARGET_NAME_SNAPSHOT_MERGE))
-				use_layer = 1;
-		} else if (lv_is_cow(lv)) {
-			/* Hadle fictional lvm2 snapshot and query snapshotX volume */
-			seg_status->seg = find_snapshot(lv);
-		}
-	}

-	if (!dev_manager_info(cmd, lv,
+	if (!dev_manager_info(cmd->mem, lv,
 			      (use_layer) ? lv_layer(lv) : NULL,
 			      with_open_count, with_read_ahead,
 			      &dminfo, (info) ? &info->read_ahead : NULL,
@@ -805,8 +763,7 @@ int lv_info_with_seg_status(struct cmd_context *cmd, const struct logical_volume
 #define OPEN_COUNT_CHECK_RETRIES 25
 #define OPEN_COUNT_CHECK_USLEEP_DELAY 200000

-/* Only report error if error_if_used is set */
-int lv_check_not_in_use(const struct logical_volume *lv, int error_if_used)
+int lv_check_not_in_use(const struct logical_volume *lv)
 {
 	struct lvinfo info;
 	unsigned int open_count_check_retries;
@@ -817,22 +774,14 @@ int lv_check_not_in_use(const struct logical_volume *lv, int error_if_used)
 	/* If sysfs is not used, use open_count information only. */
 	if (dm_sysfs_dir()) {
 		if (dm_device_has_holders(info.major, info.minor)) {
-			if (error_if_used)
-				log_error("Logical volume %s is used by another device.",
-					  display_lvname(lv));
-			else
-				log_debug_activation("Logical volume %s is used by another device.",
-						     display_lvname(lv));
+			log_error("Logical volume %s is used by another device.",
+				  display_lvname(lv));
 			return 0;
 		}

 		if (dm_device_has_mounted_fs(info.major, info.minor)) {
-			if (error_if_used)
-				log_error("Logical volume %s contains a filesystem in use.",
-					  display_lvname(lv));
-			else
-				log_debug_activation("Logical volume %s contains a filesystem in use.",
-						     display_lvname(lv));
+			log_error("Logical volume %s contains a filesystem in use.",
+				  display_lvname(lv));
 			return 0;
 		}
 	}
@@ -840,10 +789,8 @@ int lv_check_not_in_use(const struct logical_volume *lv, int error_if_used)
 	open_count_check_retries = retry_deactivation() ? OPEN_COUNT_CHECK_RETRIES : 1;
 	while (info.open_count > 0 && open_count_check_retries--) {
 		if (!open_count_check_retries) {
-			if (error_if_used)
-				log_error("Logical volume %s in use.", display_lvname(lv));
-			else
-				log_debug_activation("Logical volume %s in use.", display_lvname(lv));
+			log_error("Logical volume %s in use.",
+				  display_lvname(lv));
 			return 0;
 		}

@@ -1120,29 +1067,19 @@ int lv_cache_status(const struct logical_volume *cache_lv,
 	struct dev_manager *dm;
 	struct lv_segment *cache_seg;

-	if (lv_is_cache_pool(cache_lv)) {
-		if (dm_list_empty(&cache_lv->segs_using_this_lv) ||
-		    !(cache_seg = get_only_segment_using_this_lv(cache_lv))) {
-			log_error(INTERNAL_ERROR "Cannot check status for unused cache pool %s.",
-				  display_lvname(cache_lv));
-			return 0;
-		}
+	if (lv_is_cache_pool(cache_lv) && !dm_list_empty(&cache_lv->segs_using_this_lv)) {
+		if (!(cache_seg = get_only_segment_using_this_lv(cache_lv)))
+			return_0;
 		cache_lv = cache_seg->lv;
 	}

-	if (lv_is_pending_delete(cache_lv)) {
-		log_error("Cannot check status for deleted cache volume %s.",
-			  display_lvname(cache_lv));
+	if (lv_is_pending_delete(cache_lv))
 		return 0;
-	}

-	if (!lv_info(cache_lv->vg->cmd, cache_lv, 0, NULL, 0, 0)) {
-		log_error("Cannot check status for locally inactive cache volume %s.",
-			  display_lvname(cache_lv));
+	if (!lv_info(cache_lv->vg->cmd, cache_lv, 0, NULL, 0, 0))
 		return 0;
-	}

-	log_debug_activation("Checking status for cache volume %s.",
+	log_debug_activation("Checking cache status for LV %s.",
 			     display_lvname(cache_lv));

 	if (!(dm = dev_manager_create(cache_lv->vg->cmd, cache_lv->vg->name, 1)))
@@ -1223,13 +1160,13 @@ int lv_thin_pool_transaction_id(const struct logical_volume *lv,
 	if (!lv_info(lv->vg->cmd, lv, 1, NULL, 0, 0))
 		return 0;

-	log_debug_activation("Checking thin-pool transaction id for LV %s.",
+	log_debug_activation("Checking thin-pool percent for LV %s.",
 			     display_lvname(lv));

 	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name, 1)))
 		return_0;

-	if (!(r = dev_manager_thin_pool_status(dm, lv, &status, 0)))
+	if (!(r = dev_manager_thin_pool_status(dm, lv, &status, 1)))
 		stack;
 	else
 		*transaction_id = status->transaction_id;
@@ -1266,10 +1203,8 @@ static int _lv_active(struct cmd_context *cmd, const struct logical_volume *lv)
 	struct lvinfo info;

 	if (!lv_info(cmd, lv, 0, &info, 0, 0)) {
-		log_debug("Cannot determine activation status of %s%s.",
-			  display_lvname(lv),
-			  activation() ? "" : " (no device driver)");
-		return 0;
+		stack;
+		return -1;
 	}

 	return info.exists;
@@ -1394,7 +1329,7 @@ int lvs_in_vg_opened(const struct volume_group *vg)
 		if (lv_is_visible(lvl->lv))
 			count += (_lv_open_count(vg->cmd, lvl->lv) > 0);

-	log_debug_activation("Counted %d open LVs in VG %s.", count, vg->name);
+	log_debug_activation("Counted %d open LVs in VG %s", count, vg->name);

 	return count;
 }
@@ -1456,9 +1391,9 @@ static int _lv_is_active(const struct logical_volume *lv,
 	 * Old users of this function will never be affected by this,
 	 * since they are only concerned about active vs. not active.
 	 * New users of this function who specifically ask for 'exclusive'
-	 * will be given a warning message.
+	 * will be given an error message.
 	 */
-	log_warn("WARNING: Unable to determine exclusivity of %s.", display_lvname(lv));
+	log_error("Unable to determine exclusivity of %s.", display_lvname(lv));

 	e = 0;

@@ -1548,7 +1483,7 @@ static struct dm_event_handler *_create_dm_event_handler(struct cmd_context *cmd
 	if (dm_event_handler_set_dmeventd_path(dmevh, find_config_tree_str(cmd, dmeventd_executable_CFG, NULL)))
 		goto_bad;

-	if (dso && dm_event_handler_set_dso(dmevh, dso))
+	if (dm_event_handler_set_dso(dmevh, dso))
 		goto_bad;

 	if (dm_event_handler_set_uuid(dmevh, dmuuid))
@@ -1592,39 +1527,6 @@ static char *_build_target_uuid(struct cmd_context *cmd, const struct logical_vo
 	return build_dm_uuid(cmd->mem, lv, layer);
 }

-static int _device_registered_with_dmeventd(struct cmd_context *cmd, const struct logical_volume *lv, int *pending, const char **dso)
-{
-	char *uuid;
-	enum dm_event_mask evmask = 0;
-	struct dm_event_handler *dmevh;
-
-	*pending = 0;
-
-	if (!(uuid = _build_target_uuid(cmd, lv)))
-		return_0;
-
-	if (!(dmevh = _create_dm_event_handler(cmd, uuid, NULL, 0, DM_EVENT_ALL_ERRORS)))
-		return_0;
-
-	if (dm_event_get_registered_device(dmevh, 0)) {
-		dm_event_handler_destroy(dmevh);
-		return 0;
-	}
-
-	evmask = dm_event_handler_get_event_mask(dmevh);
-	if (evmask & DM_EVENT_REGISTRATION_PENDING) {
-		*pending = 1;
-		evmask &= ~DM_EVENT_REGISTRATION_PENDING;
-	}
-
-	if (dso && (*dso = dm_event_handler_get_dso(dmevh)) && !(*dso = dm_pool_strdup(cmd->mem, *dso)))
-		log_error("Failed to duplicate dso name.");
-
-	dm_event_handler_destroy(dmevh);
-
-	return evmask;
-}
-
 int target_registered_with_dmeventd(struct cmd_context *cmd, const char *dso,
 				    const struct logical_volume *lv, int *pending)
 {
@@ -1707,8 +1609,6 @@ int monitor_dev_for_events(struct cmd_context *cmd, const struct logical_volume
 	uint32_t s;
 	static const struct lv_activate_opts zlaopts = { 0 };
 	struct lvinfo info;
-	const char *dso = NULL;
-	int new_unmonitor;

 	if (!laopts)
 		laopts = &zlaopts;
@@ -1723,23 +1623,6 @@ int monitor_dev_for_events(struct cmd_context *cmd, const struct logical_volume
 	if (monitor && !dmeventd_monitor_mode())
 		return 1;

-	/*
-	 * Activation of unused cache-pool activates metadata device as
-	 * a public LV  for clearing purpose.
-	 * FIXME:
-	 *  As VG lock is held across whole operation unmonitored volume
-	 *  is usually OK since dmeventd couldn't do anything.
-	 *  However in case command would have crashed, such LV is
-	 *  left unmonitored and may potentially require dmeventd.
-	 */
-	if ((lv_is_cache_pool_data(lv) || lv_is_cache_pool_metadata(lv)) &&
-	    !lv_is_used_cache_pool((find_pool_seg(first_seg(lv))->lv))) {
-		log_debug_activation("Skipping %smonitor of %s.%s",
-				     (monitor) ? "" : "un", display_lvname(lv),
-				     (monitor) ? " Cache pool activation for clearing only." : "");
-		return 1;
-	}
-
 	/*
 	 * Allow to unmonitor thin pool via explicit pool unmonitor
 	 * or unmonitor before the last thin pool user deactivation
@@ -1833,58 +1716,42 @@ int monitor_dev_for_events(struct cmd_context *cmd, const struct logical_volume
 		    !seg->segtype->ops->target_monitored) /* doesn't support registration */
 			continue;

-		if (!monitor)
-			/* When unmonitoring, obtain existing dso being used. */
-			monitored = _device_registered_with_dmeventd(cmd, seg->lv, &pending, &dso);
-		else
-			monitored = seg->segtype->ops->target_monitored(seg, &pending);
+		monitored = seg->segtype->ops->target_monitored(seg, &pending);

 		/* FIXME: We should really try again if pending */
 		monitored = (pending) ? 0 : monitored;

 		monitor_fn = NULL;
-		new_unmonitor = 0;

 		if (monitor) {
 			if (monitored)
 				log_verbose("%s already monitored.", display_lvname(lv));
-			else if (seg->segtype->ops->target_monitor_events) {
-				log_verbose("Monitoring %s%s", display_lvname(lv), test_mode() ? " [Test mode: skipping this]" : "");
+			else if (seg->segtype->ops->target_monitor_events)
 				monitor_fn = seg->segtype->ops->target_monitor_events;
-			}
 		} else {
 			if (!monitored)
 				log_verbose("%s already not monitored.", display_lvname(lv));
-			else if (dso && *dso) {
-				/*
-				 * Divert unmonitor away from code that depends on the new segment
-				 * type instead of the existing one if it's changing.
-				 */
-				log_verbose("Not monitoring %s with %s%s", display_lvname(lv), dso, test_mode() ? " [Test mode: skipping this]" : "");
-				new_unmonitor = 1;
-			}
+			else if (seg->segtype->ops->target_unmonitor_events)
+				monitor_fn = seg->segtype->ops->target_unmonitor_events;
 		}

+		/* Do [un]monitor */
+		if (!monitor_fn)
+			continue;
+
+		log_verbose("%sonitoring %s%s", monitor ? "M" : "Not m", display_lvname(lv),
+			    test_mode() ? " [Test mode: skipping this]" : "");
+
 		/* FIXME Test mode should really continue a bit further. */
 		if (test_mode())
 			continue;

-		if (new_unmonitor) {
-			if (!target_register_events(cmd, dso, lv, 0, 0, 10)) {
-				log_error("%s: segment unmonitoring failed.",
-					  display_lvname(lv));
- 
-				return 0;
-			}
-		} else if (monitor_fn) {
-			/* FIXME specify events */
-			if (!monitor_fn(seg, 0)) {
-				log_error("%s: %s segment monitoring function failed.",
-					  display_lvname(lv), seg->segtype->name);
-				return 0;
-			}
-		} else
-			continue;
+		/* FIXME specify events */
+		if (!monitor_fn(seg, 0)) {
+			log_error("%s: %s segment monitoring function failed.",
+				  display_lvname(lv), seg->segtype->name);
+			return 0;
+		}

 		/* Check [un]monitor results */
 		/* Try a couple times if pending, but not forever... */
@@ -1960,7 +1827,7 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 	const struct logical_volume *lv_pre_to_free = NULL;
 	struct logical_volume *lv_pre_tmp;
 	struct seg_list *sl;
-	struct lv_segment *snap_seg;
+        struct lv_segment *snap_seg;
 	struct lvinfo info;
 	int r = 0, lockfs = 0, flush_required = 0;
 	struct detached_lv_data detached;
@@ -2066,16 +1933,6 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 		}
 	}

-	/* Flush is ATM required for the tested cases
-	 * NOTE: Mirror repair requires noflush for proper repair!
-	 * TODO: Relax this limiting condition further */
-	if (!flush_required &&
-	    (lv_is_pvmove(lv) ||
-	     (!lv_is_mirror(lv) && !lv_is_thin_pool(lv) && !lv_is_thin_volume(lv)))) {
-		log_debug("Requiring flush for LV %s.", display_lvname(lv));
-		flush_required = 1;
-	}
-
 	if (!monitor_dev_for_events(cmd, lv, laopts, 0))
 		/* FIXME Consider aborting here */
 		stack;
@@ -2196,7 +2053,6 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 	}

 	laopts->read_only = _passes_readonly_filter(cmd, lv);
-	laopts->resuming = 1;

 	if (!_lv_activate_lv(lv, laopts))
 		goto_out;
@@ -2251,7 +2107,7 @@ static int _lv_has_open_snapshots(const struct logical_volume *lv)
 	int r = 0;

 	dm_list_iterate_items_gen(snap_seg, &lv->snapshot_segs, origin_list)
-		if (!lv_check_not_in_use(snap_seg->cow, 1))
+		if (!lv_check_not_in_use(snap_seg->cow))
 			r++;

 	if (r)
@@ -2305,7 +2161,7 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s, const struct logi

 	if (lv_is_visible(lv) || lv_is_virtual_origin(lv) ||
 	    lv_is_merging_thin_snapshot(lv)) {
-		if (!lv_check_not_in_use(lv, 1))
+		if (!lv_check_not_in_use(lv))
 			goto_out;

 		if (lv_is_origin(lv) && _lv_has_open_snapshots(lv))
@@ -2443,7 +2299,7 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
 	if (info.exists && !info.suspended && info.live_table &&
 	    (info.read_only == read_only_lv(lv, laopts))) {
 		r = 1;
-		log_debug_activation("LV %s is already active.", display_lvname(lv));
+		log_debug_activation("Volume is already active.");
 		goto out;
 	}

--- a/lib/activate/activate.h
+++ b/lib/activate/activate.h
@@ -81,7 +81,6 @@ struct lv_activate_opts {
 				 * set of flags to avoid any scanning in udev. These udev
 				 * flags are persistent in udev db for any spurious event
 				 * that follows. */
-	unsigned resuming;	/* Set when resuming after a suspend. */
 };

 void set_activation(int activation, int silent);
@@ -92,9 +91,6 @@ int library_version(char *version, size_t size);
 int lvm1_present(struct cmd_context *cmd);

 int module_present(struct cmd_context *cmd, const char *target_name);
-int target_present_version(struct cmd_context *cmd, const char *target_name,
-			   int use_modprobe, uint32_t *maj,
-			   uint32_t *min, uint32_t *patchlevel);
 int target_present(struct cmd_context *cmd, const char *target_name,
 		   int use_modprobe);
 int target_version(const char *target_name, uint32_t *maj,
@@ -150,7 +146,7 @@ int lv_info_with_seg_status(struct cmd_context *cmd, const struct logical_volume
 			    struct lv_with_info_and_seg_status *status,
 			    int with_open_count, int with_read_ahead);

-int lv_check_not_in_use(const struct logical_volume *lv, int error_if_used);
+int lv_check_not_in_use(const struct logical_volume *lv);

 /*
 * Returns 1 if activate_lv has been set: 1 = activate; 0 = don't.
--- a/lib/activate/dev_manager.c
+++ b/lib/activate/dev_manager.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2016 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.
 *
 * This file is part of LVM2.
 *
@@ -85,8 +85,7 @@ int read_only_lv(const struct logical_volume *lv, const struct lv_activate_opts
 static struct dm_task *_setup_task(const char *name, const char *uuid,
 				   uint32_t *event_nr, int task,
 				   uint32_t major, uint32_t minor,
-				   int with_open_count,
-				   int with_flush)
+				   int with_open_count)
 {
 	struct dm_task *dmt;

@@ -111,9 +110,6 @@ static struct dm_task *_setup_task(const char *name, const char *uuid,
 	if (!with_open_count && !dm_task_no_open_count(dmt))
 		log_warn("WARNING: Failed to disable open_count.");

-	if (!with_flush && !dm_task_no_flush(dmt))
-		log_warn("WARNING: Failed to set no_flush.");
-
 	return dmt;
      out:
 	dm_task_destroy(dmt);
@@ -127,7 +123,6 @@ static int _get_segment_status_from_target_params(const char *target_name,
 	struct segment_type *segtype;

 	seg_status->type = SEG_STATUS_UNKNOWN;
-
 	/*
 	 * TODO: Add support for other segment types too!
 	 * The segment to report status for must be properly
@@ -135,27 +130,19 @@ static int _get_segment_status_from_target_params(const char *target_name,
 	 * linear/striped, old snapshots and raids have proper
 	 * segment selected for status!
 	 */
-	if (!strcmp(target_name, TARGET_NAME_SNAPSHOT_MERGE) &&
-	    lv_is_merging_origin(seg_status->seg->lv)) {
-		/* Snapshot merge has started, check snapshot status */
-		if (!(segtype = get_segtype_from_string(seg_status->seg->lv->vg->cmd, TARGET_NAME_SNAPSHOT)))
-			return_0;
-	} else {
-		if (strcmp(target_name, TARGET_NAME_CACHE) &&
-		    strcmp(target_name, TARGET_NAME_SNAPSHOT) &&
-		    strcmp(target_name, TARGET_NAME_THIN_POOL) &&
-		    strcmp(target_name, TARGET_NAME_THIN))
-			return 1; /* TODO: Do not know how to handle yet */
+	if (strcmp(target_name, TARGET_NAME_CACHE) &&
+	    strcmp(target_name, TARGET_NAME_THIN_POOL) &&
+	    strcmp(target_name, TARGET_NAME_THIN))
+		return 1;

-		if (!(segtype = get_segtype_from_string(seg_status->seg->lv->vg->cmd, target_name)))
-			return_0;
+	if (!(segtype = get_segtype_from_string(seg_status->seg->lv->vg->cmd, target_name)))
+		return_0;

-		if (segtype != seg_status->seg->segtype) {
-			log_error(INTERNAL_ERROR "_get_segment_status_from_target_params: "
-				  "segment type %s found does not match expected segment type %s",
-				  segtype->name, seg_status->seg->segtype->name);
-			return 0;
-		}
+	if (segtype != seg_status->seg->segtype) {
+		log_error(INTERNAL_ERROR "_get_segment_status_from_target_params: "
+			  "segment type %s found does not match expected segment type %s",
+			   segtype->name, seg_status->seg->segtype->name);
+		return 0;
 	}

 	if (segtype_is_cache(segtype)) {
@@ -205,7 +192,6 @@ static int _info_run(info_type_t type, const char *name, const char *dlid,
 	uint64_t target_start, target_length;
 	char *target_name, *target_params, *params_to_process = NULL;
 	uint32_t extent_size;
-	int with_flush = 1; /* TODO: arg for _info_run */

 	switch (type) {
 		case INFO:
@@ -213,7 +199,6 @@ static int _info_run(info_type_t type, const char *name, const char *dlid,
 			break;
 		case STATUS:
 			dmtask = DM_DEVICE_STATUS;
-			with_flush = 0;
 			break;
 		case MKNODES:
 			dmtask = DM_DEVICE_MKNODES;
@@ -224,7 +209,7 @@ static int _info_run(info_type_t type, const char *name, const char *dlid,
 	}

 	if (!(dmt = _setup_task((type == MKNODES) ? name : NULL, dlid, 0, dmtask,
-				major, minor, with_open_count, with_flush)))
+				major, minor, with_open_count)))
 		return_0;

 	if (!dm_task_run(dmt))
@@ -352,8 +337,13 @@ static int _ignore_blocked_mirror_devices(struct device *dev,
 	 * We avoid another system call if we can, but if a device is
 	 * dead, we have no choice but to look up the table too.
 	 */
-	if (!(dmt = _setup_task(NULL, NULL, NULL, DM_DEVICE_TABLE,
-				MAJOR(dev->dev), MINOR(dev->dev), 0, 1)))
+	if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
+		goto_out;
+
+	if (!dm_task_set_major_minor(dmt, MAJOR(dev->dev), MINOR(dev->dev), 1))
+		goto_out;
+
+	if (activation_checks() && !dm_task_enable_checks(dmt))
 		goto_out;

 	if (!dm_task_run(dmt))
@@ -394,9 +384,14 @@ static int _device_is_suspended(int major, int minor)
 	struct dm_info info;
 	int r = 0;

-	if (!(dmt = _setup_task(NULL, NULL, NULL, DM_DEVICE_INFO,
-				major, minor, 0, 0)))
-		return_0;
+	if (!(dmt = dm_task_create(DM_DEVICE_INFO)))
+		return 0;
+
+	if (!dm_task_set_major_minor(dmt, major, minor, 1))
+		goto_out;
+
+	if (activation_checks() && !dm_task_enable_checks(dmt))
+		goto_out;

 	if (!dm_task_run(dmt) ||
 	    !dm_task_get_info(dmt, &info)) {
@@ -419,10 +414,15 @@ static int _ignore_suspended_snapshot_component(struct device *dev)
 	int major1, minor1, major2, minor2;
 	int r = 0;

-	if (!(dmt = _setup_task(NULL, NULL, NULL, DM_DEVICE_TABLE,
-				MAJOR(dev->dev), MINOR(dev->dev), 0, 1)))
+	if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
 		return_0;

+	if (!dm_task_set_major_minor(dmt, MAJOR(dev->dev), MINOR(dev->dev), 1))
+		goto_out;
+
+	if (activation_checks() && !dm_task_enable_checks(dmt))
+		goto_out;
+
 	if (!dm_task_run(dmt)) {
 		log_error("Failed to get state of snapshot or snapshot origin device");
 		goto out;
@@ -466,26 +466,32 @@ static int _ignore_unusable_thins(struct device *dev)
 	if (!(mem = dm_pool_create("unusable_thins", 128)))
 		return_0;

-	if (!(dmt = _setup_task(NULL, NULL, NULL, DM_DEVICE_TABLE,
-				MAJOR(dev->dev), MINOR(dev->dev), 0, 1)))
+	if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
+		goto_out;
+	if (!dm_task_no_open_count(dmt))
+		goto_out;
+	if (!dm_task_set_major_minor(dmt, MAJOR(dev->dev), MINOR(dev->dev), 1))
 		goto_out;
-
 	if (!dm_task_run(dmt)) {
 		log_error("Failed to get state of mapped device.");
 		goto out;
 	}
 	dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
-	if (!params || sscanf(params, "%d:%d", &major, &minor) != 2) {
+	if (!params || sscanf(params, "%d:%d", &minor, &major) != 2) {
 		log_error("Failed to get thin-pool major:minor for thin device %d:%d.",
 			  (int)MAJOR(dev->dev), (int)MINOR(dev->dev));
 		goto out;
 	}
 	dm_task_destroy(dmt);

-	if (!(dmt = _setup_task(NULL, NULL, NULL, DM_DEVICE_STATUS,
-				major, minor, 0, 0)))
+	if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
+		goto_out;
+	if (!dm_task_no_flush(dmt))
+		log_warn("Can't set no_flush.");
+	if (!dm_task_no_open_count(dmt))
+		goto_out;
+	if (!dm_task_set_major_minor(dmt, minor, major, 1))
 		goto_out;
-
 	if (!dm_task_run(dmt)) {
 		log_error("Failed to get state of mapped device.");
 		goto out;
@@ -539,10 +545,15 @@ int device_is_usable(struct device *dev, struct dev_usable_check_params check)
 	int only_error_target = 1;
 	int r = 0;

-	if (!(dmt = _setup_task(NULL, NULL, NULL, DM_DEVICE_STATUS,
-				MAJOR(dev->dev), MINOR(dev->dev), 0, 0)))
+	if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
 		return_0;

+	if (!dm_task_set_major_minor(dmt, MAJOR(dev->dev), MINOR(dev->dev), 1))
+		goto_out;
+
+	if (activation_checks() && !dm_task_enable_checks(dmt))
+		goto_out;
+		
 	if (!dm_task_run(dmt)) {
 		log_error("Failed to get state of mapped device");
 		goto out;
@@ -663,32 +674,7 @@ int device_is_usable(struct device *dev, struct dev_usable_check_params check)
 	return r;
 }

-/*
- * If active LVs were activated by a version of LVM2 before 2.02.00 we must
- * perform additional checks to find them because they do not have the LVM-
- * prefix on their dm uuids.
- * As of 2.02.150, we've chosen to disable this compatibility arbitrarily if
- * we're running kernel version 3 or above.
- */
-#define MIN_KERNEL_MAJOR 3
-
-static int _original_uuid_format_check_required(struct cmd_context *cmd)
-{
-	static int _kernel_major = 0;
-
-	if (!_kernel_major) {
-		if ((sscanf(cmd->kernel_vsn, "%d", &_kernel_major) == 1) &&
-		    (_kernel_major >= MIN_KERNEL_MAJOR))
-			log_debug_activation("Skipping checks for old devices without " UUID_PREFIX
-					     " dm uuid prefix (kernel vsn %d >= %d).", _kernel_major, MIN_KERNEL_MAJOR);
-		else
-			_kernel_major = -1;
-	}
-
-	return (_kernel_major == -1);
-}
-
-static int _info(struct cmd_context *cmd, const char *dlid, int with_open_count, int with_read_ahead,
+static int _info(const char *dlid, int with_open_count, int with_read_ahead,
 		 struct dm_info *dminfo, uint32_t *read_ahead,
 		 struct lv_seg_status *seg_status)
 {
@@ -717,10 +703,6 @@ static int _info(struct cmd_context *cmd, const char *dlid, int with_open_count,
 		}
 	}

-	/* Must we still check for the pre-2.02.00 dm uuid format? */
-	if (!_original_uuid_format_check_required(cmd))
-		return r;
-
 	/* Check for dlid before UUID_PREFIX was added */
 	if ((r = _info_run(seg_status ? STATUS : INFO, NULL, dlid + sizeof(UUID_PREFIX) - 1,
 				dminfo, read_ahead, seg_status, with_open_count,
@@ -735,7 +717,7 @@ static int _info_by_dev(uint32_t major, uint32_t minor, struct dm_info *info)
 	return _info_run(INFO, NULL, NULL, info, NULL, 0, 0, 0, major, minor);
 }

-int dev_manager_info(struct cmd_context *cmd, const struct logical_volume *lv,
+int dev_manager_info(struct dm_pool *mem, const struct logical_volume *lv,
 		     const char *layer,
 		     int with_open_count, int with_read_ahead,
 		     struct dm_info *dminfo, uint32_t *read_ahead,
@@ -744,19 +726,19 @@ int dev_manager_info(struct cmd_context *cmd, const struct logical_volume *lv,
 	char *dlid, *name;
 	int r;

-	if (!(name = dm_build_dm_name(cmd->mem, lv->vg->name, lv->name, layer)))
+	if (!(name = dm_build_dm_name(mem, lv->vg->name, lv->name, layer)))
 		return_0;

-	if (!(dlid = build_dm_uuid(cmd->mem, lv, layer))) {
+	if (!(dlid = build_dm_uuid(mem, lv, layer))) {
 		r = 0;
 		goto_out;
 	}

 	log_debug_activation("Getting device info for %s [%s]", name, dlid);
-	r = _info(cmd, dlid, with_open_count, with_read_ahead,
+	r = _info(dlid, with_open_count, with_read_ahead,
 		  dminfo, read_ahead, seg_status);
 out:
-	dm_pool_free(cmd->mem, name);
+	dm_pool_free(mem, name);

 	return r;
 }
@@ -774,11 +756,11 @@ static const struct dm_info *_cached_dm_info(struct dm_pool *mem,
 		return_NULL;

 	if (!(dnode = dm_tree_find_node_by_uuid(dtree, dlid)))
-		goto out;
+		goto_out;

 	if (!(dinfo = dm_tree_node_get_info(dnode))) {
-		log_warn("WARNING: Cannot get info from tree node for %s.",
-			 display_lvname(lv));
+		log_error("Failed to get info from tree node for %s.",
+			  display_lvname(lv));
 		goto out;
 	}

@@ -805,7 +787,7 @@ int lv_has_target_type(struct dm_pool *mem, const struct logical_volume *lv,
 	if (!(dlid = build_dm_uuid(mem, lv, layer)))
 		return_0;

-	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0, 0)))
+	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0)))
 		goto_bad;

 	if (!dm_task_run(dmt))
@@ -814,28 +796,13 @@ int lv_has_target_type(struct dm_pool *mem, const struct logical_volume *lv,
 	if (!dm_task_get_info(dmt, &info) || !info.exists)
 		goto_out;

-	/* If there is a preloaded table, use that in preference. */
-	if (info.inactive_table) {
-		dm_task_destroy(dmt);
-
-		if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0, 0)))
-			goto_bad;
-
-		if (!dm_task_query_inactive_table(dmt))
-			goto_out;
-
-		if (!dm_task_run(dmt))
-			goto_out;
-
-		if (!dm_task_get_info(dmt, &info) || !info.exists || !info.inactive_table)
-			goto_out;
-	}
-
 	do {
 		next = dm_get_next_target(dmt, next, &start, &length,
 					  &type, &params);
-		if (type && !strncmp(type, target_type, strlen(target_type))) {
-			r = 1;
+		if (type && strncmp(type, target_type,
+				    strlen(target_type)) == 0) {
+			if (info.live_table)
+				r = 1;
 			break;
 		}
 	} while (next);
@@ -848,67 +815,6 @@ bad:
 	return r;
 }

-static int _thin_lv_has_device_id(struct dm_pool *mem, const struct logical_volume *lv,
-				  const char *layer, unsigned device_id)
-{
-	char *dlid;
-	struct dm_task *dmt;
-	struct dm_info info;
-	void *next = NULL;
-	uint64_t start, length;
-	char *type = NULL;
-	char *params = NULL;
-	unsigned id = ~0;
-
-	if (!(dlid = build_dm_uuid(mem, lv, layer)))
-		return_0;
-
-	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TABLE, 0, 0, 0, 1)))
-		goto_bad;
-
-	if (!dm_task_run(dmt))
-		goto_out;
-
-	if (!dm_task_get_info(dmt, &info) || !info.exists)
-		goto_out;
-
-	/* If there is a preloaded table, use that in preference. */
-	if (info.inactive_table) {
-		dm_task_destroy(dmt);
-
-		if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TABLE, 0, 0, 0, 1)))
-			goto_bad;
-
-		if (!dm_task_query_inactive_table(dmt))
-			goto_out;
-
-		if (!dm_task_run(dmt))
-			goto_out;
-
-		if (!dm_task_get_info(dmt, &info) || !info.exists || !info.inactive_table)
-			goto_out;
-	}
-
-	(void) dm_get_next_target(dmt, next, &start, &length, &type, &params);
-
-	if (!type || strcmp(type, TARGET_NAME_THIN))
-		goto_out;
-
-	if (!params || sscanf(params, "%*u:%*u %u", &id) != 1)
-		goto_out;
-
-	log_debug_activation("%soaded thin volume %s with id %u is %smatching id %u.",
-			     info.inactive_table  ? "Prel" : "L",
-			     display_lvname(lv), id,
-			     (device_id != id) ? "not " : "", device_id);
-out:
-	dm_task_destroy(dmt);
-bad:
-	dm_pool_free(mem, dlid);
-
-	return (device_id == id);
-}
-
 int add_linear_area_to_dtree(struct dm_tree_node *node, uint64_t size, uint32_t extent_size, int use_linear_target, const char *vgname, const char *lvname)
 {
 	uint32_t page_size;
@@ -978,19 +884,22 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 	char *params = NULL;
 	const struct dm_list *segh = lv ? &lv->segments : NULL;
 	struct lv_segment *seg = NULL;
+	struct segment_type *segtype;
 	int first_time = 1;
 	dm_percent_t percent = DM_PERCENT_INVALID;
+
 	uint64_t total_numerator = 0, total_denominator = 0;
-	struct segment_type *segtype;

 	*overall_percent = percent;

-	if (!(segtype = get_segtype_from_string(dm->cmd, target_type)))
+	if (!(dmt = _setup_task(name, dlid, event_nr,
+				wait ? DM_DEVICE_WAITEVENT : DM_DEVICE_STATUS, 0, 0, 0)))
 		return_0;

-	if (!(dmt = _setup_task(name, dlid, event_nr,
-				wait ? DM_DEVICE_WAITEVENT : DM_DEVICE_STATUS, 0, 0, 0, 0)))
-		return_0;
+	/* No freeze on overfilled thin-pool, read existing slightly outdated data */
+	if (lv && lv_is_thin_pool(lv) &&
+	    !dm_task_no_flush(dmt))
+		log_warn("Can't set no_flush flag."); /* Non fatal */

 	if (!dm_task_run(dmt))
 		goto_out;
@@ -1017,6 +926,9 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 		if (!type || !params)
 			continue;

+		if (!(segtype = get_segtype_from_string(dm->cmd, target_type)))
+			continue;
+
 		if (strcmp(type, target_type)) {
 			/* If kernel's type isn't an exact match is it compatible? */
 			if (!segtype->ops->target_status_compatible ||
@@ -1074,8 +986,7 @@ static int _percent(struct dev_manager *dm, const char *name, const char *dlid,
 		if (_percent_run(dm, NULL, dlid, target_type, wait, lv, percent,
 				 event_nr, fail_if_percent_unsupported))
 			return 1;
-		else if (_original_uuid_format_check_required(dm->cmd) &&
-			 _percent_run(dm, NULL, dlid + sizeof(UUID_PREFIX) - 1,
+		else if (_percent_run(dm, NULL, dlid + sizeof(UUID_PREFIX) - 1,
 				      target_type, wait, lv, percent,
 				      event_nr, fail_if_percent_unsupported))
 			return 1;
@@ -1106,7 +1017,7 @@ int dev_manager_transient(struct dev_manager *dm, const struct logical_volume *l
 	if (!(dlid = build_dm_uuid(dm->mem, lv, layer)))
 		return_0;

-	if (!(dmt = _setup_task(0, dlid, NULL, DM_DEVICE_STATUS, 0, 0, 0, 0)))
+	if (!(dmt = _setup_task(0, dlid, NULL, DM_DEVICE_STATUS, 0, 0, 0)))
 		return_0;

 	if (!dm_task_run(dmt))
@@ -1302,7 +1213,7 @@ int dev_manager_raid_status(struct dev_manager *dm,
 	if (!(dlid = build_dm_uuid(dm->mem, lv, layer)))
 		return_0;

-	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0, 0)))
+	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0)))
 		return_0;

 	if (!dm_task_run(dmt))
@@ -1361,7 +1272,7 @@ int dev_manager_raid_message(struct dev_manager *dm,
 	if (!(dlid = build_dm_uuid(dm->mem, lv, layer)))
 		return_0;

-	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TARGET_MSG, 0, 0, 0, 1)))
+	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TARGET_MSG, 0, 0, 0)))
 		return_0;

 	if (!dm_task_set_message(dmt, msg))
@@ -1396,7 +1307,7 @@ int dev_manager_cache_status(struct dev_manager *dm,
 	if (!(*status = dm_pool_zalloc(dm->mem, sizeof(struct lv_status_cache))))
 		return_0;

-	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0, 0)))
+	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0)))
 		return_0;

 	if (!dm_task_run(dmt))
@@ -1418,10 +1329,10 @@ int dev_manager_cache_status(struct dev_manager *dm,
 	 * ->target_percent() API is able to transfer only a single value.
 	 * Needs to be able to pass whole structure.
 	 */
-	if (!dm_get_status_cache(dm->mem, params, &c))
+	if (!dm_get_status_cache(dm->mem, params, &((*status)->cache)))
 		goto_out;

-	(*status)->cache = c;
+	c = (*status)->cache;
 	(*status)->mem = dm->mem; /* User has to destroy this mem pool later */
 	if (c->fail || c->error) {
 		(*status)->data_usage =
@@ -1432,9 +1343,8 @@ int dev_manager_cache_status(struct dev_manager *dm,
 							c->total_blocks);
 		(*status)->metadata_usage = dm_make_percent(c->metadata_used_blocks,
 							    c->metadata_total_blocks);
-		(*status)->dirty_usage = (c->used_blocks) ?
-			dm_make_percent(c->dirty_blocks,
-					c->used_blocks) : DM_PERCENT_0;
+		(*status)->dirty_usage = dm_make_percent(c->dirty_blocks,
+							 c->used_blocks);
 	}
 	r = 1;
 out:
@@ -1446,7 +1356,7 @@ out:
 int dev_manager_thin_pool_status(struct dev_manager *dm,
 				 const struct logical_volume *lv,
 				 struct dm_status_thin_pool **status,
-				 int flush)
+				 int noflush)
 {
 	const char *dlid;
 	struct dm_task *dmt;
@@ -1460,9 +1370,12 @@ int dev_manager_thin_pool_status(struct dev_manager *dm,
 	if (!(dlid = build_dm_uuid(dm->mem, lv, lv_layer(lv))))
 		return_0;

-	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0, flush)))
+	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_STATUS, 0, 0, 0)))
 		return_0;

+	if (noflush && !dm_task_no_flush(dmt))
+		log_warn("Can't set no_flush.");
+
 	if (!dm_task_run(dmt))
 		goto_out;

@@ -1522,7 +1435,7 @@ int dev_manager_thin_percent(struct dev_manager *dm,
 		return_0;

 	log_debug_activation("Getting device status percentage for %s", name);
-	if (!(_percent(dm, name, dlid, TARGET_NAME_THIN, 0,
+	if (!(_percent(dm, name, dlid, "thin", 0,
 		       (mapped) ? NULL : lv, percent, NULL, 1)))
 		return_0;

@@ -1544,7 +1457,7 @@ int dev_manager_thin_device_id(struct dev_manager *dm,
 	if (!(dlid = build_dm_uuid(dm->mem, lv, lv_layer(lv))))
 		return_0;

-	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TABLE, 0, 0, 0, 1)))
+	if (!(dmt = _setup_task(NULL, dlid, 0, DM_DEVICE_TABLE, 0, 0, 0)))
 		return_0;

 	if (!dm_task_run(dmt))
@@ -1600,12 +1513,6 @@ static int _dev_manager_lv_rmnodes(const struct logical_volume *lv)
 	return fs_del_lv(lv);
 }

-static int _lv_has_mknode(const struct logical_volume *lv)
-{
-	return (lv_is_visible(lv) &&
-		(!lv_is_thin_pool(lv) || lv_is_new_thin_pool(lv)));
-}
-
 int dev_manager_mknodes(const struct logical_volume *lv)
 {
 	struct dm_info dminfo;
@@ -1617,7 +1524,7 @@ int dev_manager_mknodes(const struct logical_volume *lv)

 	if ((r = _info_run(MKNODES, name, NULL, &dminfo, NULL, NULL, 0, 0, 0, 0))) {
 		if (dminfo.exists) {
-			if (_lv_has_mknode(lv))
+			if (lv_is_visible(lv))
 				r = _dev_manager_lv_mknodes(lv);
 		} else
 			r = _dev_manager_lv_rmnodes(lv);
@@ -1757,7 +1664,7 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		return_0;

 	log_debug_activation("Getting device info for %s [%s]", name, dlid);
-	if (!_info(dm->cmd, dlid, 1, 0, &info, NULL, NULL)) {
+	if (!_info(dlid, 1, 0, &info, NULL, NULL)) {
 		log_error("Failed to get info for %s [%s].", name, dlid);
 		return 0;
 	}
@@ -1770,7 +1677,7 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		/*
 		 * FIXME compare info.major with lv->major if multiple major support
 		 */
-		if (info.exists && ((int) info.minor != lv->minor)) {
+		if (info.exists && (info.minor != lv->minor)) {
 			log_error("Volume %s (%" PRIu32 ":%" PRIu32")"
 				  " differs from already active device "
 				  "(%" PRIu32 ":%" PRIu32")",
@@ -1955,8 +1862,8 @@ static int _pool_callback(struct dm_tree_node *node,
 			log_sys_error("close", argv[args]);

 		if (ret == (int) DM_ARRAY_SIZE(buf)) {
-			log_debug_activation("%s skipped, detect empty disk header on %s.",
-					     argv[0], argv[args]);
+			log_debug("%s skipped, detect empty disk header on %s.",
+				  argv[0], argv[args]);
 			return 1;
 		}
 	}
@@ -2161,7 +2068,6 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		dm_list_iterate(snh, &lv->snapshot_segs)
 			if (!_add_lv_to_dtree(dm, dtree, dm_list_struct_base(snh, struct lv_segment, origin_list)->cow, 0))
 				return_0;
-
 	if (dm->activation && !origin_only && lv_is_merging_origin(lv) &&
 	    !_add_lv_to_dtree(dm, dtree, find_snapshot(lv)->lv, 1))
 		return_0;
@@ -2214,7 +2120,7 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 			    (!dm->track_pending_delete || !lv_is_cache(lv)) &&
 			    !_add_lv_to_dtree(dm, dtree, seg_lv(seg, s), 0))
 				return_0;
-			if (seg_is_raid_with_meta(seg) && seg->meta_areas && seg_metalv(seg, s) &&
+			if (seg_is_raid(seg) &&
 			    !_add_lv_to_dtree(dm, dtree, seg_metalv(seg, s), 0))
 				return_0;
 		}
@@ -2282,7 +2188,7 @@ static char *_add_error_device(struct dev_manager *dm, struct dm_tree *dtree,
 		return_NULL;

 	log_debug_activation("Getting device info for %s [%s]", name, dlid);
-	if (!_info(dm->cmd, dlid, 1, 0, &info, NULL, NULL)) {
+	if (!_info(dlid, 1, 0, &info, NULL, NULL)) {
 		log_error("Failed to get info for %s [%s].", name, dlid);
 		return 0;
 	}
@@ -2386,13 +2292,9 @@ int add_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 					return_0;
 				continue;
 			}
-
-			if (seg->meta_areas && seg_metalv(seg, s)) {
-				if (!(dlid = build_dm_uuid(dm->mem, seg_metalv(seg, s), NULL)))
-					return_0;
-				if (!dm_tree_node_add_target_area(node, NULL, dlid, extent_size * seg_metale(seg, s)))
-					return_0;
-			} else if (!dm_tree_node_add_null_area(node, 0))
+			if (!(dlid = build_dm_uuid(dm->mem, seg_metalv(seg, s), NULL)))
+				return_0;
+			if (!dm_tree_node_add_target_area(node, NULL, dlid, extent_size * seg_metale(seg, s)))
 				return_0;

 			if (!(dlid = build_dm_uuid(dm->mem, seg_lv(seg, s), NULL)))
@@ -2720,7 +2622,7 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 		    !_add_new_lv_to_dtree(dm, dtree, seg_lv(seg, s),
 					  laopts, NULL))
 			return_0;
-		if (seg_is_raid_with_meta(seg) && seg->meta_areas && seg_metalv(seg, s) &&
+		if (seg_is_raid(seg) &&
 		    !_add_new_lv_to_dtree(dm, dtree, seg_metalv(seg, s),
 					  laopts, NULL))
 			return_0;
@@ -2753,7 +2655,6 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	uint32_t read_ahead = lv->read_ahead;
 	uint32_t read_ahead_flags = UINT32_C(0);
 	int save_pending_delete = dm->track_pending_delete;
-	int merge_in_progress = 0;

 	/* LV with pending delete is never put new into a table */
 	if (lv_is_pending_delete(lv) && !_cached_dm_info(dm->mem, dtree, lv, NULL))
@@ -2774,51 +2675,23 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	if (!layer && lv_is_merging_origin(lv)) {
 		seg = find_snapshot(lv);
 		/*
-		 * Prevent merge if merge isn't currently possible:
+		 * Clear merge attributes if merge isn't currently possible:
 		 * either origin or merging snapshot are open
-		 * - for old snaps use "snapshot-merge" if it is already in use
+		 * - but use "snapshot-merge" if it is already in use
 		 * - open_count is always retrieved (as of dm-ioctl 4.7.0)
 		 *   so just use the tree's existing nodes' info
 		 */
-		if ((dinfo = _cached_dm_info(dm->mem, dtree, lv, NULL))) {
-			/* Merging origin LV is present, check if mergins is already running. */
-			if ((seg_is_thin_volume(seg) && _thin_lv_has_device_id(dm->mem, lv, NULL, seg->device_id)) ||
-			    (!seg_is_thin_volume(seg) && lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))) {
-				log_debug_activation("Merging of snapshot volume %s to origin %s is in progress.",
-						     display_lvname(seg->lv), display_lvname(seg->lv));
-				merge_in_progress = 1; /* Merge is already running */
-			} /* Merge is not yet running, so check if it can be started */
-			else if (laopts->resuming) {
-				log_debug_activation("Postponing pending snapshot merge for origin %s, "
-						     "merge was not started before suspend.",
-						     display_lvname(lv));
-				laopts->no_merging = 1; /* Cannot be reloaded in suspend */
-			} /* Non-resuming merge requires origin to be unused */
-			else if (dinfo->open_count) {
-				log_debug_activation("Postponing pending snapshot merge for origin %s, "
-						     "origin volume is opened.",
-						     display_lvname(lv));
+		/* An activating merging origin won't have a node in the tree yet */
+		if (((dinfo = _cached_dm_info(dm->mem, dtree, lv, NULL)) &&
+		     dinfo->open_count) ||
+		    ((dinfo = _cached_dm_info(dm->mem, dtree,
+					      seg_is_thin_volume(seg) ?
+					      seg->lv : seg->cow, NULL)) &&
+		     dinfo->open_count)) {
+			if (seg_is_thin_volume(seg) ||
+			    /* FIXME Is there anything simpler to check for instead? */
+			    !lv_has_target_type(dm->mem, lv, NULL, TARGET_NAME_SNAPSHOT_MERGE))
 				laopts->no_merging = 1;
-			}
-		}
-
-		/* If merge would be still undecided, look as snapshot */
-		if (!merge_in_progress && !laopts->no_merging &&
-		    (dinfo = _cached_dm_info(dm->mem, dtree,
-					     seg_is_thin_volume(seg) ?
-					     seg->lv : seg->cow, NULL))) {
-			if (seg_is_thin_volume(seg)) {
-				/* Active thin snapshot prevents merge */
-				log_debug_activation("Postponing pending snapshot merge for origin volume %s, "
-						     "merging thin snapshot volume %s is active.",
-						     display_lvname(lv), display_lvname(seg->lv));
-				laopts->no_merging = 1;
-			} else if (dinfo->open_count) {
-				log_debug_activation("Postponing pending snapshot merge for origin volume %s, "
-						     "merging snapshot volume %s is opened.",
-						     display_lvname(lv), display_lvname(seg->lv));
-				laopts->no_merging = 1;
-			}
 		}
 	}

@@ -3000,7 +2873,7 @@ static int _create_lv_symlinks(struct dev_manager *dm, struct dm_tree_node *root
 				r = 0;
 			continue;
 		}
-		if (_lv_has_mknode(lvlayer->lv)) {
+		if (lv_is_visible(lvlayer->lv)) {
 			if (!_dev_manager_lv_mknodes(lvlayer->lv))
 				r = 0;
 			continue;
@@ -3116,7 +2989,6 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv,
 	/* Some targets may build bigger tree for activation */
 	dm->activation = ((action == PRELOAD) || (action == ACTIVATE));
 	dm->suspend = (action == SUSPEND_WITH_LOCKFS) || (action == SUSPEND);
-
 	if (!(dtree = _create_partial_dtree(dm, lv, laopts->origin_only)))
 		return_0;

@@ -3152,7 +3024,7 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv,
 		break;
 	case SUSPEND:
 		dm_tree_skip_lockfs(root);
-		if (!dm->flush_required)
+		if (!dm->flush_required && !lv_is_pvmove(lv))
 			dm_tree_use_no_flush_suspend(root);
 		/* Fall through */
 	case SUSPEND_WITH_LOCKFS:
@@ -3171,15 +3043,14 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv,
 		if (!dm_tree_preload_children(root, dlid, DLID_SIZE))
 			goto_out;

-		//if (action == PRELOAD) { log_debug("SLEEP"); sleep(7); }
-
 		if ((dm_tree_node_size_changed(root) < 0))
 			dm->flush_required = 1;
+
 		/* Currently keep the code require flush for any
-		 * non 'thin pool/volume' and  size increase */
-		else if (!lv_is_thin_volume(lv) &&
-			 !lv_is_thin_pool(lv) &&
-			 dm_tree_node_size_changed(root))
+		 * non 'thin pool/volume, mirror' or with any size change */
+		if (!lv_is_thin_volume(lv) &&
+		    !lv_is_thin_pool(lv) &&
+		    (!lv_is_mirror(lv) || dm_tree_node_size_changed(root)))
 			dm->flush_required = 1;

 		if (action == ACTIVATE) {
@@ -3224,8 +3095,6 @@ int dev_manager_activate(struct dev_manager *dm, const struct logical_volume *lv
 int dev_manager_preload(struct dev_manager *dm, const struct logical_volume *lv,
 			struct lv_activate_opts *laopts, int *flush_required)
 {
-	dm->flush_required = *flush_required;
-
 	if (!_tree_action(dm, lv, laopts, PRELOAD))
 		return_0;

--- a/lib/activate/dev_manager.h
+++ b/lib/activate/dev_manager.h
@@ -45,12 +45,11 @@ void dev_manager_exit(void);
 * (eg, an origin is created before its snapshot, but is not
 * unsuspended until the snapshot is also created.)
 */
-int dev_manager_info(struct cmd_context *cmd, const struct logical_volume *lv,
+int dev_manager_info(struct dm_pool *mem, const struct logical_volume *lv,
 		     const char *layer,
 		     int with_open_count, int with_read_ahead,
 		     struct dm_info *dminfo, uint32_t *read_ahead,
 		     struct lv_seg_status *seg_status);
-
 int dev_manager_snapshot_percent(struct dev_manager *dm,
 				 const struct logical_volume *lv,
 				 dm_percent_t *percent);
@@ -69,7 +68,7 @@ int dev_manager_cache_status(struct dev_manager *dm,
 int dev_manager_thin_pool_status(struct dev_manager *dm,
 				 const struct logical_volume *lv,
 				 struct dm_status_thin_pool **status,
-				 int flush);
+				 int noflush);
 int dev_manager_thin_pool_percent(struct dev_manager *dm,
 				  const struct logical_volume *lv,
 				  int metadata, dm_percent_t *percent);
--- a/lib/cache/lvmcache.c
+++ b/lib/cache/lvmcache.c
--- a/lib/cache/lvmcache.h
+++ b/lib/cache/lvmcache.h
@@ -102,16 +102,15 @@ int lvmcache_vginfo_holders_dec_and_test_for_zero(struct lvmcache_vginfo *vginfo
 struct lvmcache_vginfo *lvmcache_vginfo_from_vgname(const char *vgname,
 					   const char *vgid);
 struct lvmcache_vginfo *lvmcache_vginfo_from_vgid(const char *vgid);
-struct lvmcache_info *lvmcache_info_from_pvid(const char *pvid, struct device *dev, int valid_only);
+struct lvmcache_info *lvmcache_info_from_pvid(const char *pvid, int valid_only);
 const char *lvmcache_vgname_from_vgid(struct dm_pool *mem, const char *vgid);
 const char *lvmcache_vgid_from_vgname(struct cmd_context *cmd, const char *vgname);
 struct device *lvmcache_device_from_pvid(struct cmd_context *cmd, const struct id *pvid,
 				unsigned *scan_done_once, uint64_t *label_sector);
 const char *lvmcache_pvid_from_devname(struct cmd_context *cmd,
-				       const char *devname);
+			      const char *dev_name);
 char *lvmcache_vgname_from_pvid(struct cmd_context *cmd, const char *pvid);
 const char *lvmcache_vgname_from_info(struct lvmcache_info *info);
-const struct format_type *lvmcache_fmt_from_info(struct lvmcache_info *info);
 int lvmcache_vgs_locked(void);
 int lvmcache_vgname_is_locked(const char *vgname);

@@ -194,11 +193,12 @@ unsigned lvmcache_mda_count(struct lvmcache_info *info);
 int lvmcache_vgid_is_cached(const char *vgid);
 uint64_t lvmcache_smallest_mda_size(struct lvmcache_info *info);

+void lvmcache_replace_dev(struct cmd_context *cmd, struct physical_volume *pv,
+			struct device *dev);
+
 int lvmcache_found_duplicate_pvs(void);

-int lvmcache_get_unused_duplicate_devs(struct cmd_context *cmd, struct dm_list *head);
-
-int vg_has_duplicate_pvs(struct volume_group *vg);
+void lvmcache_set_preferred_duplicates(const char *vgid);

 int lvmcache_contains_lock_type_sanlock(struct cmd_context *cmd);

@@ -209,10 +209,4 @@ int lvmcache_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const ch

 void lvmcache_lock_ordering(int enable);

-int lvmcache_dev_is_unchosen_duplicate(struct device *dev);
-
-void lvmcache_remove_unchosen_duplicate(struct device *dev);
-
-int lvmcache_pvid_in_unchosen_duplicates(const char *pvid);
-
 #endif
--- a/lib/cache/lvmetad.c
+++ b/lib/cache/lvmetad.c
--- a/lib/cache/lvmetad.h
+++ b/lib/cache/lvmetad.h
@@ -28,35 +28,54 @@ typedef int (*activation_handler) (struct cmd_context *cmd,
 				   enum activation_change activate);

 #ifdef LVMETAD_SUPPORT
+/*
+ * Sets up a global handle for our process.
+ */
+void lvmetad_init(struct cmd_context *);

 /*
- * lvmetad_connect: connect to lvmetad
- * lvmetad_disconnect: disconnect from lvmetad
- * lvmetad_make_unused: disconnect from lvmetad and refresh cmd filter
- * lvmetad_used: check if lvmetad is being used (i.e. is connected)
+ * Override the use of lvmetad for retrieving scan results and metadata.
 */
-int lvmetad_connect(struct cmd_context *cmd);
-void lvmetad_disconnect(void);
-void lvmetad_make_unused(struct cmd_context *cmd);
-int lvmetad_used(void);
-
+void lvmetad_set_active(struct cmd_context *, int);

 /*
 * Configure the socket that lvmetad_init will use to connect to the daemon.
 */
 void lvmetad_set_socket(const char *);

+/*
+ * Check whether lvmetad is used.
+ */
+int lvmetad_used(void);
+
 /*
 * Check if lvmetad socket is present (either the one set by lvmetad_set_socket
- * or the default one if not set).
+ * or the default one if not set). For example, this may be used before calling
+ * lvmetad_active() check that does connect to the socket - this would produce
+ * various connection errors if the socket is not present.
 */
 int lvmetad_socket_present(void);

 /*
- * Check if lvmetad pidfile is present, indicating that the lvmetad
- * process is running or not.
+ * Check whether lvmetad is active (where active means both that it is running
+ * and that we have a working connection with it). It opens new connection
+ * with lvmetad in the process when lvmetad is supposed to be used and the
+ * connection is not open yet.
 */
-int lvmetad_pidfile_present(void);
+int lvmetad_active(void);
+
+/* 
+ * Connect to lvmetad unless the connection is already open or lvmetad is
+ * not configured to be used.  If we fail to connect, print a warning.
+ */
+void lvmetad_connect_or_warn(void);
+
+/*
+ * Drop connection to lvmetad. A subsequent lvmetad_connect_or_warn or
+ * lvmetad_active will re-establish the connection (possibly at a
+ * different socket path).
+ */
+void lvmetad_disconnect(void);

 /*
 * Set the "lvmetad validity token" (currently only consists of the lvmetad
@@ -78,16 +97,14 @@ void lvmetad_release_token(void);
 * lvmetad_vg_commit. The request is validated immediately and lvmetad_vg_commit
 * only constitutes a pointer update.
 */
-int lvmetad_vg_update_pending(struct volume_group *vg);
-int lvmetad_vg_update_finish(struct volume_group *vg);
+int lvmetad_vg_update(struct volume_group *vg);

 /*
 * Inform lvmetad that a VG has been removed. This is not entirely safe, but is
 * only needed during vgremove, which does not wipe PV labels and therefore
 * cannot mark the PVs as gone.
 */
-int lvmetad_vg_remove_pending(struct volume_group *vg);
-int lvmetad_vg_remove_finish(struct volume_group *vg);
+int lvmetad_vg_remove(struct volume_group *vg);

 /*
 * Notify lvmetad that a PV has been found. It is not an error if the PV is
@@ -97,17 +114,15 @@ int lvmetad_vg_remove_finish(struct volume_group *vg);
 * number on the cached and on the discovered PV match but the metadata content
 * does not.
 */
-int lvmetad_pv_found(struct cmd_context *cmd, const struct id *pvid, struct device *dev,
+int lvmetad_pv_found(const struct id *pvid, struct device *dev,
 		     const struct format_type *fmt, uint64_t label_sector,
-		     struct volume_group *vg,
-		     struct dm_list *found_vgnames,
-		     struct dm_list *changed_vgnames);
+		     struct volume_group *vg, activation_handler handler);

 /*
 * Inform the daemon that the device no longer exists.
 */
-int lvmetad_pv_gone(dev_t devno, const char *pv_name);
-int lvmetad_pv_gone_by_dev(struct device *dev);
+int lvmetad_pv_gone(dev_t devno, const char *pv_name, activation_handler handler);
+int lvmetad_pv_gone_by_dev(struct device *dev, activation_handler handler);

 /*
 * Request a list of all PVs available to lvmetad. If requested, this will also
@@ -146,55 +161,45 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd,
 * Scan a single device and update lvmetad with the result(s).
 */
 int lvmetad_pvscan_single(struct cmd_context *cmd, struct device *dev,
-			  struct dm_list *found_vgnames,
-			  struct dm_list *changed_vgnames);
+			  activation_handler handler, int ignore_obsolete);

-int lvmetad_pvscan_all_devs(struct cmd_context *cmd, int do_wait);
+int lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler handler);
+int lvmetad_pvscan_foreign_vgs(struct cmd_context *cmd, activation_handler handler);

 int lvmetad_vg_clear_outdated_pvs(struct volume_group *vg);
 void lvmetad_validate_global_cache(struct cmd_context *cmd, int force);
-int lvmetad_token_matches(struct cmd_context *cmd);

 int lvmetad_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const char *vgid);

-int lvmetad_is_disabled(struct cmd_context *cmd, const char **reason);
-void lvmetad_set_disabled(struct cmd_context *cmd, const char *reason);
-void lvmetad_clear_disabled(struct cmd_context *cmd);
-
 #  else		/* LVMETAD_SUPPORT */

+#    define lvmetad_init(cmd)	do { } while (0)
 #    define lvmetad_disconnect()	do { } while (0)
-#    define lvmetad_connect(cmd)	(0)
-#    define lvmetad_make_unused(cmd)	do { } while (0)
-#    define lvmetad_used()		(0)
+#    define lvmetad_set_active(cmd, a)	do { } while (0)
 #    define lvmetad_set_socket(a)	do { } while (0)
+#    define lvmetad_used()	(0)
 #    define lvmetad_socket_present()	(0)
-#    define lvmetad_pidfile_present()   (0)
+#    define lvmetad_active()	(0)
+#    define lvmetad_connect_or_warn()	do { } while (0)
 #    define lvmetad_set_token(a)	do { } while (0)
 #    define lvmetad_release_token()	do { } while (0)
 #    define lvmetad_vg_update(vg)	(1)
-#    define lvmetad_vg_update_pending(vg)	(1)
-#    define lvmetad_vg_update_finish(vg)	(1)
-#    define lvmetad_vg_remove_pending(vg)	(1)
-#    define lvmetad_vg_remove_finish(vg)	(1)
-#    define lvmetad_pv_found(cmd, pvid, dev, fmt, label_sector, vg, found_vgnames, changed_vgnames)	(1)
-#    define lvmetad_pv_gone(devno, pv_name)	(1)
-#    define lvmetad_pv_gone_by_dev(dev)	(1)
+#    define lvmetad_vg_remove(vg)	(1)
+#    define lvmetad_pv_found(pvid, dev, fmt, label_sector, vg, handler)	(1)
+#    define lvmetad_pv_gone(devno, pv_name, handler)	(1)
+#    define lvmetad_pv_gone_by_dev(dev, handler)	(1)
 #    define lvmetad_pv_list_to_lvmcache(cmd)	(1)
 #    define lvmetad_pv_lookup(cmd, pvid, found)	(0)
 #    define lvmetad_pv_lookup_by_dev(cmd, dev, found)	(0)
 #    define lvmetad_vg_list_to_lvmcache(cmd)	(1)
 #    define lvmetad_get_vgnameids(cmd, vgnameids)       do { } while (0)
 #    define lvmetad_vg_lookup(cmd, vgname, vgid)	(NULL)
-#    define lvmetad_pvscan_single(cmd, dev, found_vgnames, changed_vgnames)	(0)
-#    define lvmetad_pvscan_all_devs(cmd, do_wait)	(0)
-#    define lvmetad_vg_clear_outdated_pvs(vg)           do { } while (0)
+#    define lvmetad_pvscan_single(cmd, dev, handler, ignore_obsolete)	(0)
+#    define lvmetad_pvscan_all_devs(cmd, handler)	(0)
+#    define lvmetad_pvscan_foreign_vgs(cmd, handler)	(0)
+#    define lvmetad_vg_clear_outdated_pvs(vg)           (1)
 #    define lvmetad_validate_global_cache(cmd, force)	do { } while (0)
 #    define lvmetad_vg_is_foreign(cmd, vgname, vgid) (0)
-#    define lvmetad_token_matches(cmd) (1)
-#    define lvmetad_is_disabled(cmd, reason) (0)
-#    define lvmetad_set_disabled(cmd, reason) do { } while (0)
-#    define lvmetad_clear_disabled(cmd) do { } while (0)

 #  endif	/* LVMETAD_SUPPORT */

--- a/lib/cache_segtype/cache.c
+++ b/lib/cache_segtype/cache.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2016 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2013-2014 Red Hat, Inc. All rights reserved.
 *
 * This file is part of LVM2.
 *
@@ -26,8 +26,6 @@
 #include "defaults.h"

 static const char _cache_module[] = "cache";
-#define CACHE_POLICY_WHEN_MISSING   "mq"
-#define CACHE_MODE_WHEN_MISSING	    CACHE_MODE_WRITETHROUGH

 /* TODO: using static field here, maybe should be a part of segment_type */
 static unsigned _feature_mask;
@@ -43,21 +41,24 @@ static unsigned _feature_mask;
 *
 * Needs both segments cache and cache_pool to be loaded.
 */
-static void _fix_missing_defaults(struct lv_segment *cpool_seg)
+static int _fix_missing_defaults(struct lv_segment *cpool_seg)
 {
 	if (!cpool_seg->policy_name) {
-		cpool_seg->policy_name = CACHE_POLICY_WHEN_MISSING;
-		log_verbose("Cache pool %s is missing cache policy, using %s.",
-			    display_lvname(cpool_seg->lv),
+		cpool_seg->policy_name = "mq";
+		log_verbose("Cache is missing cache policy, using %s.",
 			    cpool_seg->policy_name);
 	}

-	if (cpool_seg->cache_mode == CACHE_MODE_UNDEFINED) {
-		cpool_seg->cache_mode = CACHE_MODE_WHEN_MISSING;
-		log_verbose("Cache pool %s is missing cache mode, using %s.",
-			    display_lvname(cpool_seg->lv),
+	if (!cache_mode_is_set(cpool_seg)) {
+		if (!cache_set_mode(cpool_seg, "writethrough")) {
+			log_error(INTERNAL_ERROR "Failed to writethrough cache mode.");
+			return 0;
+		}
+		log_verbose("Cache is missing cache mode, using %s.",
 			    get_cache_mode_name(cpool_seg));
 	}
+
+	return 1;
 }

 static int _cache_pool_text_import(struct lv_segment *seg,
@@ -96,7 +97,7 @@ static int _cache_pool_text_import(struct lv_segment *seg,
 	if (dm_config_has_node(sn, "cache_mode")) {
 		if (!(str = dm_config_find_str(sn, "cache_mode", NULL)))
 			return SEG_LOG_ERROR("cache_mode must be a string in");
-		if (!set_cache_mode(&seg->cache_mode, str))
+		if (!cache_set_mode(seg, str))
 			return SEG_LOG_ERROR("Unknown cache_mode in");
 	}

@@ -140,9 +141,9 @@ static int _cache_pool_text_import(struct lv_segment *seg,
 	if (!attach_pool_metadata_lv(seg, meta_lv))
 		return_0;

-	/* when cache pool is used, we require policy and mode to be defined */
-	if (!dm_list_empty(&seg->lv->segs_using_this_lv))
-		_fix_missing_defaults(seg);
+	if (!dm_list_empty(&seg->lv->segs_using_this_lv) &&
+	    !_fix_missing_defaults(seg))
+		return_0;

 	return 1;
 }
@@ -169,7 +170,7 @@ static int _cache_pool_text_export(const struct lv_segment *seg,
 	 * but not worth to break backward compatibility, by shifting
 	 * content to cache segment
 	 */
-	if (seg->cache_mode != CACHE_MODE_UNDEFINED) {
+	if (cache_mode_is_set(seg)) {
 		if (!(cache_mode = get_cache_mode_name(seg)))
 			return_0;
 		outf(f, "cache_mode = \"%s\"", cache_mode);
@@ -207,16 +208,11 @@ static int _target_present(struct cmd_context *cmd,
 		uint32_t maj;
 		uint32_t min;
 		unsigned cache_feature;
-		unsigned cache_alias;
 		const char feature[12];
 		const char module[12]; /* check dm-%s */
-		const char *aliasing;
 	} _features[] = {
-		/* Assumption: cache >=1.9 always aliases MQ policy */
-		{ 1, 9, CACHE_FEATURE_POLICY_SMQ, CACHE_FEATURE_POLICY_MQ, "policy_smq", "cache-smq",
-		" and aliases cache-mq" },
-		{ 1, 8, CACHE_FEATURE_POLICY_SMQ, 0, "policy_smq", "cache-smq" },
-		{ 1, 3, CACHE_FEATURE_POLICY_MQ, 0, "policy_mq", "cache-mq" },
+		{ 1, 3, CACHE_FEATURE_POLICY_MQ, "policy_mq", "cache-mq" },
+		{ 1, 8, CACHE_FEATURE_POLICY_SMQ, "policy_smq", "cache-smq" },
 	};
 	static const char _lvmconf[] = "global/cache_disabled_features";
 	static unsigned _attrs = 0;
@@ -234,8 +230,10 @@ static int _target_present(struct cmd_context *cmd,
 	if (!_cache_checked) {
 		_cache_checked = 1;

-		if (!(_cache_present = target_present_version(cmd, TARGET_NAME_CACHE, 1,
-							      &maj, &min, &patchlevel)))
+		if (!(_cache_present = target_present(cmd, TARGET_NAME_CACHE, 1)))
+			return 0;
+
+		if (!target_version(TARGET_NAME_CACHE, &maj, &min, &patchlevel))
 			return_0;

 		if ((maj < 1) ||
@@ -247,17 +245,13 @@ static int _target_present(struct cmd_context *cmd,
 			return 0;
 		}

+
 		for (i = 0; i < DM_ARRAY_SIZE(_features); ++i) {
-			if (_attrs & _features[i].cache_feature)
-				continue; /* already present */
 			if (((maj > _features[i].maj) ||
 			     (maj == _features[i].maj && min >= _features[i].min)) &&
-			    module_present(cmd, _features[i].module)) {
-				log_debug_activation("Cache policy %s is available%s.",
-						     _features[i].module,
-						     _features[i].aliasing ? : "");
-				_attrs |= (_features[i].cache_feature | _features[i].cache_alias);
-			} else if (!_features[i].cache_alias)
+			    (!_features[i].module[0] || module_present(cmd, _features[i].module)))
+				_attrs |= _features[i].cache_feature;
+			else
 				log_very_verbose("Target %s does not support %s.",
 						 _cache_module, _features[i].feature);
 		}
@@ -357,9 +351,9 @@ static int _cache_text_import(struct lv_segment *seg,
 	if (!attach_pool_lv(seg, pool_lv, NULL, NULL, NULL))
 		return_0;

-	/* load order is unknown, could be cache origin or pool LV, so check for both */
-	if (!dm_list_empty(&pool_lv->segments))
-		_fix_missing_defaults(first_seg(pool_lv));
+	if (!dm_list_empty(&pool_lv->segments) &&
+	    !_fix_missing_defaults(first_seg(pool_lv)))
+		return_0;

 	return 1;
 }
@@ -398,7 +392,6 @@ static int _cache_add_target_line(struct dev_manager *dm,
 {
 	struct lv_segment *cache_pool_seg;
 	char *metadata_uuid, *data_uuid, *origin_uuid;
-	uint64_t feature_flags = 0;

 	if (!seg->pool_lv || !seg_is_cache(seg)) {
 		log_error(INTERNAL_ERROR "Passed segment is not cache.");
@@ -406,25 +399,6 @@ static int _cache_add_target_line(struct dev_manager *dm,
 	}

 	cache_pool_seg = first_seg(seg->pool_lv);
-	if (seg->cleaner_policy)
-		/* With cleaner policy always pass writethrough */
-		feature_flags |= DM_CACHE_FEATURE_WRITETHROUGH;
-	else
-		switch (cache_pool_seg->cache_mode) {
-		default:
-			log_error(INTERNAL_ERROR "LV %s has unknown cache mode %d.",
-				  display_lvname(seg->lv), cache_pool_seg->cache_mode);
-			/* Fall through */
-		case CACHE_MODE_WRITETHROUGH:
-			feature_flags |= DM_CACHE_FEATURE_WRITETHROUGH;
-			break;
-		case CACHE_MODE_WRITEBACK:
-			feature_flags |= DM_CACHE_FEATURE_WRITEBACK;
-			break;
-		case CACHE_MODE_PASSTHROUGH:
-			feature_flags |= DM_CACHE_FEATURE_PASSTHROUGH;
-			break;
-		}

 	if (!(metadata_uuid = build_dm_uuid(mem, cache_pool_seg->metadata_lv, NULL)))
 		return_0;
@@ -436,7 +410,7 @@ static int _cache_add_target_line(struct dev_manager *dm,
 		return_0;

 	if (!dm_tree_node_add_cache_target(node, len,
-					   feature_flags,
+					   cache_pool_seg->feature_flags,
 					   metadata_uuid,
 					   data_uuid,
 					   origin_uuid,
--- a/lib/commands/toolcontext.c
+++ b/lib/commands/toolcontext.c
@@ -365,7 +365,7 @@ static void _init_logging(struct cmd_context *cmd)
 	/* Tell device-mapper about our logging */
 #ifdef DEVMAPPER_SUPPORT
 	if (!dm_log_is_non_default())
-		dm_log_with_errno_init(print_log_libdm);
+		dm_log_with_errno_init(print_log);
 #endif
 	reset_log_duplicated();
 	reset_lvm_errno(1);
@@ -950,9 +950,6 @@ static void _destroy_config(struct cmd_context *cmd)
 		 * they will get loaded again automatically.
 		 */
 		dm_list_iterate_items_safe(profile, tmp_profile, &cmd->profile_params->profiles) {
-			if (cmd->is_interactive && (profile == cmd->profile_params->shell_profile))
-				continue;
-
 			config_destroy(profile->cft);
 			profile->cft = NULL;
 			dm_list_move(&cmd->profile_params->profiles_to_load, &profile->list);
@@ -1056,7 +1053,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
 	return 1;
 }

-#define MAX_FILTERS 9
+#define MAX_FILTERS 8

 static struct dev_filter *_init_lvmetad_filter_chain(struct cmd_context *cmd)
 {
@@ -1081,13 +1078,6 @@ static struct dev_filter *_init_lvmetad_filter_chain(struct cmd_context *cmd)
 			nr_filt++;
 	}

-	/* internal filter used by command processing. */
-	if (!(filters[nr_filt] = internal_filter_create())) {
-		log_error("Failed to create internal device filter");
-		goto bad;
-	}
-	nr_filt++;
-
 	/* global regex filter. Optional. */
 	if ((cn = find_config_tree_node(cmd, devices_global_filter_CFG, NULL))) {
 		if (!(filters[nr_filt] = regex_filter_create(cn->v))) {
@@ -1169,7 +1159,7 @@ bad:
 * If lvmetad is used, there are three filter chains:
 *
 *   - cmd->lvmetad_filter - the lvmetad filter chain used when scanning devs for lvmetad update:
- *     sysfs filter -> internal filter -> global regex filter -> type filter ->
+ *     sysfs filter -> global regex filter -> type filter ->
 *     usable device filter(FILTER_MODE_PRE_LVMETAD) ->
 *     mpath component filter -> partitioned filter ->
 *     md component filter -> fw raid filter
@@ -1183,7 +1173,7 @@ bad:
 * If lvmetad is not used, there's just one filter chain:
 *
 *   - cmd->filter == cmd->full_filter:
- *     persistent filter -> sysfs filter -> internal filter -> global regex filter ->
+ *     persistent filter -> sysfs filter -> global regex filter ->
 *     regex_filter -> type filter -> usable device filter(FILTER_MODE_NO_LVMETAD) ->
 *     mpath component filter -> partitioned filter -> md component filter -> fw raid filter
 *
@@ -1653,24 +1643,35 @@ static void _init_globals(struct cmd_context *cmd)
 }

 /*
- * init_connections();
- *   _init_lvmetad();
- *     lvmetad_disconnect();  (close previous connection)
- *     lvmetad_set_socket();  (set path from config)
- *     lvmetad_set_token();   (set token from filter config)
- *     if (find_config(use_lvmetad))
- *       lvmetad_connect();
- *
- * If lvmetad_connect() is successful, lvmetad_used() will
- * return 1.
- *
- * If the config has use_lvmetad=0, then lvmetad_connect()
- * will not be called, and lvmetad_used() will return 0.
- *
- * Other code should use lvmetad_used() to check if the
- * command is using lvmetad.
- *
+ * Close and reopen stream on file descriptor fd.
 */
+static int _reopen_stream(FILE *stream, int fd, const char *mode, const char *name, FILE **new_stream)
+{
+	int fd_copy, new_fd;
+
+	if ((fd_copy = dup(fd)) < 0) {
+		log_sys_error("dup", name);
+		return 0;
+	}
+
+	if (fclose(stream))
+		log_sys_error("fclose", name);
+
+	if ((new_fd = dup2(fd_copy, fd)) < 0)
+		log_sys_error("dup2", name);
+	else if (new_fd != fd)
+		log_error("dup2(%d, %d) returned %d", fd_copy, fd, new_fd);
+
+	if (close(fd_copy) < 0)
+		log_sys_error("close", name);
+
+	if (!(*new_stream = fdopen(fd, mode))) {
+		log_sys_error("fdopen", name);
+		return 0;
+	}
+
+	return 1;
+}

 static int _init_lvmetad(struct cmd_context *cmd)
 {
@@ -1694,29 +1695,13 @@ static int _init_lvmetad(struct cmd_context *cmd)

 	if (find_config_tree_int(cmd, global_locking_type_CFG, NULL) == 3 &&
 	    find_config_tree_bool(cmd, global_use_lvmetad_CFG, NULL)) {
-		log_warn("WARNING: Not using lvmetad because locking_type is 3 (clustered).");
-		return 1;
-	}
-
-	if (!find_config_tree_bool(cmd, global_use_lvmetad_CFG, NULL)) {
-		if (lvmetad_pidfile_present()) {
-			log_warn("WARNING: Not using lvmetad because config setting use_lvmetad=0.");
-			log_warn("WARNING: To avoid corruption, rescan devices to make changes visible (pvscan --cache).");
-		}
-		return 1;
-	}
-
-	if (!lvmetad_connect(cmd)) {
-		log_warn("WARNING: Failed to connect to lvmetad. Falling back to device scanning.");
-		return 1;
-	}
-
-	if (!lvmetad_used()) {
-		/* This should never happen. */
-		log_error(INTERNAL_ERROR "lvmetad setup incorrect");
-		return 0;
-	}
+		log_warn("WARNING: configuration setting use_lvmetad overridden to 0 due to locking_type 3. "
+			 "Clustered environment not supported by lvmetad yet.");
+		lvmetad_set_active(NULL, 0);
+	} else
+		lvmetad_set_active(NULL, find_config_tree_bool(cmd, global_use_lvmetad_CFG, NULL));

+	lvmetad_init(cmd);
 	return 1;
 }

@@ -1755,49 +1740,6 @@ bad:
 	return 0;
 }

-void destroy_config_context(struct cmd_context *cmd)
-{
-	_destroy_config(cmd);
-
-	if (cmd->mem)
-		dm_pool_destroy(cmd->mem);
-	if (cmd->libmem)
-		dm_pool_destroy(cmd->libmem);
-
-	dm_free(cmd);
-}
-
-/*
- * A "config context" is a very light weight toolcontext that
- * is only used for reading config settings from lvm.conf.
- */
-struct cmd_context *create_config_context(void)
-{
-	struct cmd_context *cmd;
-
-	if (!(cmd = dm_zalloc(sizeof(*cmd))))
-		goto_out;
-
-	strcpy(cmd->system_dir, DEFAULT_SYS_DIR);
-
-	if (!_get_env_vars(cmd))
-		goto_out;
-
-	if (!(cmd->libmem = dm_pool_create("library", 4 * 1024)))
-		goto_out;
-
-	dm_list_init(&cmd->config_files);
-
-	if (!_init_lvm_conf(cmd))
-		goto_out;
-
-	return cmd;
-out:
-	if (cmd)
-		destroy_config_context(cmd);
-	return NULL;
-}
-
 /* Entry point */
 struct cmd_context *create_toolcontext(unsigned is_long_lived,
 				       const char *system_dir,
@@ -1807,6 +1749,7 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 				       unsigned set_filters)
 {
 	struct cmd_context *cmd;
+	FILE *new_stream;
 	int flags;

 #ifdef M_MMAP_MAX
@@ -1856,8 +1799,9 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 		if (is_valid_fd(STDIN_FILENO) &&
 		    ((flags = fcntl(STDIN_FILENO, F_GETFL)) > 0) &&
 		    (flags & O_ACCMODE) != O_WRONLY) {
-			if (!reopen_standard_stream(&stdin, "r"))
+			if (!_reopen_stream(stdin, STDIN_FILENO, "r", "stdin", &new_stream))
 				goto_out;
+			stdin = new_stream;
 			if (setvbuf(stdin, cmd->linebuffer, _IOLBF, linebuffer_size)) {
 				log_sys_error("setvbuf", "");
 				goto out;
@@ -1867,8 +1811,9 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 		if (is_valid_fd(STDOUT_FILENO) &&
 		    ((flags = fcntl(STDOUT_FILENO, F_GETFL)) > 0) &&
 		    (flags & O_ACCMODE) != O_RDONLY) {
-			if (!reopen_standard_stream(&stdout, "w"))
+			if (!_reopen_stream(stdout, STDOUT_FILENO, "w", "stdout", &new_stream))
 				goto_out;
+			stdout = new_stream;
 			if (setvbuf(stdout, cmd->linebuffer + linebuffer_size,
 				     _IOLBF, linebuffer_size)) {
 				log_sys_error("setvbuf", "");
@@ -1880,6 +1825,7 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 		/* Without buffering, must not use stdin/stdout */
 		init_silent(1);
 #endif
+
 	/*
 	 * Environment variable LVM_SYSTEM_DIR overrides this below.
 	 */
@@ -1952,8 +1898,6 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 	if (!init_lvmcache_orphans(cmd))
 		goto_out;

-	dm_list_init(&cmd->unused_duplicate_devs);
-
 	if (!_init_segtypes(cmd))
 		goto_out;

@@ -1965,7 +1909,7 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 	_init_globals(cmd);

 	if (set_connections && !init_connections(cmd))
-		goto_out;
+		return_0;

 	if (set_filters && !init_filters(cmd, 1))
 		goto_out;
@@ -2195,6 +2139,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
 void destroy_toolcontext(struct cmd_context *cmd)
 {
 	struct dm_config_tree *cft_cmdline;
+	FILE *new_stream;
 	int flags;

 	if (cmd->dump_filter && cmd->filter && cmd->filter->dump &&
@@ -2230,18 +2175,20 @@ void destroy_toolcontext(struct cmd_context *cmd)
 		if (is_valid_fd(STDIN_FILENO) &&
 		    ((flags = fcntl(STDIN_FILENO, F_GETFL)) > 0) &&
 		    (flags & O_ACCMODE) != O_WRONLY) {
-			if (reopen_standard_stream(&stdin, "r"))
+			if (_reopen_stream(stdin, STDIN_FILENO, "r", "stdin", &new_stream)) {
+				stdin = new_stream;
 				setlinebuf(stdin);
-			else
+			} else
 				cmd->linebuffer = NULL;	/* Leave buffer in place (deliberate leak) */
 		}

 		if (is_valid_fd(STDOUT_FILENO) &&
 		    ((flags = fcntl(STDOUT_FILENO, F_GETFL)) > 0) &&
 		    (flags & O_ACCMODE) != O_RDONLY) {
-			if (reopen_standard_stream(&stdout, "w"))
+			if (_reopen_stream(stdout, STDOUT_FILENO, "w", "stdout", &new_stream)) {
+				stdout = new_stream;
 				setlinebuf(stdout);
-			else
+			} else
 				cmd->linebuffer = NULL;	/* Leave buffer in place (deliberate leak) */
 		}

--- a/lib/commands/toolcontext.h
+++ b/lib/commands/toolcontext.h
@@ -66,15 +66,6 @@ struct cmd_context_initialized_parts {
 	unsigned connections:1;
 };

-struct cmd_report {
-	int log_only;
-	dm_report_group_type_t report_group_type;
-	struct dm_report_group *report_group;
-	struct dm_report *log_rh;
-	const char *log_name;
-	log_report_t saved_log_report_state;
-};
-
 /* FIXME Split into tool & library contexts */
 /* command-instance-related variables needed by library */
 struct cmd_context {
@@ -122,7 +113,6 @@ struct cmd_context {
 	 * Switches.
 	 */
 	unsigned is_long_lived:1;		/* optimises persistent_filter handling */
-	unsigned is_interactive:1;
 	unsigned check_pv_dev_sizes:1;
 	unsigned handles_missing_pvs:1;
 	unsigned handles_unknown_segments:1;
@@ -194,11 +184,6 @@ struct cmd_context {
 	char dev_dir[PATH_MAX];
 	char proc_dir[PATH_MAX];

-	/*
-	 * Reporting.
-	 */
-	struct cmd_report cmd_report;
-
 	/*
 	 * Buffers.
 	 */
@@ -212,7 +197,6 @@ struct cmd_context {
 	const char *report_list_item_separator;
 	const char *time_format;
 	unsigned rand_seed;
-	struct dm_list unused_duplicate_devs; /* save preferences between lvmcache instances */
 };

 /*
@@ -234,14 +218,6 @@ int init_lvmcache_orphans(struct cmd_context *cmd);
 int init_filters(struct cmd_context *cmd, unsigned load_persistent_cache);
 int init_connections(struct cmd_context *cmd);

-/*
- * A config context is a very light weight cmd struct that
- * is only used for reading config settings from lvm.conf,
- * which are at cmd->cft.
- */
-struct cmd_context *create_config_context(void);
-void destroy_config_context(struct cmd_context *cmd);
-
 struct format_type *get_format_by_name(struct cmd_context *cmd, const char *format);

 const char *system_id_from_string(struct cmd_context *cmd, const char *str);
--- a/lib/config/config.c
+++ b/lib/config/config.c
@@ -385,13 +385,6 @@ int override_config_tree_from_string(struct cmd_context *cmd,
 		return 0;
 	}

-	if (cmd->is_interactive &&
-	    !config_force_check(cmd, CONFIG_STRING, cft_new)) {
-		log_error("Ignoring invalid configuration string.");
-		dm_config_destroy(cft_new);
-		return_0;
-	}
-
 	if (!(cs = dm_pool_zalloc(cft_new->mem, sizeof(struct config_source)))) {
 		log_error("Failed to allocate config source.");
 		dm_config_destroy(cft_new);
@@ -991,20 +984,6 @@ static int _config_def_check_node_is_profilable(struct cft_check_handle *handle,
 	return 1;
 }

-static int _config_def_check_node_is_allowed(struct cft_check_handle *handle,
-					     const char *rp, struct dm_config_node *cn,
-					     const cfg_def_item_t *def)
-{
-	if (handle->disallowed_flags & def->flags) {
-		log_warn_suppress(handle->suppress_messages,
-				  "Configuration %s \"%s\" is not allowed here.",
-				  cn->v ? "option" : "section", rp);
-		return 0;
-	}
-
-	return 1;
-}
-
 static int _config_def_check_node(struct cft_check_handle *handle,
 				  const char *vp, char *pvp, char *rp, char *prp,
 				  size_t buf_size, struct dm_config_node *cn)
@@ -1055,9 +1034,6 @@ static int _config_def_check_node(struct cft_check_handle *handle,
 	    !_config_def_check_node_is_profilable(handle, rp, cn, def))
 		return_0;

-	if (!_config_def_check_node_is_allowed(handle, rp, cn, def))
-		return_0;
-
 	handle->status[def->id] |= CFG_VALID;
 	return 1;
 }
@@ -2137,7 +2113,7 @@ bad:
 	return NULL;
 }

-int config_force_check(struct cmd_context *cmd, config_source_t source, struct dm_config_tree *cft)
+static int _check_profile(struct cmd_context *cmd, struct profile *profile)
 {
 	struct cft_check_handle *handle;
 	int r;
@@ -2148,19 +2124,13 @@ int config_force_check(struct cmd_context *cmd, config_source_t source, struct d
 	}

 	handle->cmd = cmd;
-	handle->cft = cft;
-	handle->source = source;
+	handle->cft = profile->cft;
+	handle->source = profile->source;
+	/* the check is compulsory - allow only profilable items in a profile config! */
 	handle->force_check = 1;
 	/* provide warning messages only if config/checks=1 */
 	handle->suppress_messages = !find_config_tree_bool(cmd, config_checks_CFG, NULL);

-	/*
-	 * Some settings can't be changed if we're running commands interactively
-	 * within lvm shell so check for them in case we're in this interactive mode.
-	 */
-	if (cmd->is_interactive)
-		handle->disallowed_flags |= CFG_DISALLOW_INTERACTIVE;
-
 	r = config_def_check(handle);

 	dm_pool_free(cmd->libmem, handle);
@@ -2282,7 +2252,7 @@ int load_profile(struct cmd_context *cmd, struct profile *profile) {
 	 * messages to be suppressed, but the check itself is always done
 	 * for profiles!
 	 */
-	if (!config_force_check(cmd, profile->source, profile->cft)) {
+	if (!_check_profile(cmd, profile)) {
 		log_error("Ignoring invalid %s %s.",
 			  _config_source_names[profile->source], profile->name);
 		config_destroy(profile->cft);
@@ -2461,25 +2431,3 @@ int get_default_allocation_cache_pool_chunk_size_CFG(struct cmd_context *cmd, st
 {
 	return DEFAULT_CACHE_POOL_CHUNK_SIZE * 2;
 }
-
-uint64_t get_default_allocation_cache_pool_max_chunks_CFG(struct cmd_context *cmd, struct profile *profile)
-{
-	static int _warn_max_chunks = 0;
-	/*
-	 * TODO: In future may depend on the cache target version,
-	 *       newer targets may scale better.
-	 */
-	uint64_t default_max_chunks = DEFAULT_CACHE_POOL_MAX_CHUNKS;
-	uint64_t max_chunks = find_config_tree_int(cmd, allocation_cache_pool_max_chunks_CFG, profile);
-
-	if (!max_chunks)
-		max_chunks = default_max_chunks;
-	else if (max_chunks > default_max_chunks)
-		/* Still warn the user when the value is tweaked above recommended level */
-		/* Maybe drop to log_verbose... */
-		log_warn_suppress(_warn_max_chunks++, "WARNING: Configured cache_pool_max_chunks value "
-				  FMTu64 " is higher then recommended " FMTu64 ".",
-				  max_chunks, default_max_chunks);
-
-	return max_chunks;
-}
--- a/lib/config/config.h
+++ b/lib/config/config.h
@@ -48,7 +48,6 @@ struct profile_params {
 	struct profile *global_metadata_profile; /* profile (as given by --metadataprofile cmd arg) that overrides any other VG/LV-based profile */
 	struct dm_list profiles_to_load;         /* list of profiles which are only added, but still need to be loaded for any use */
 	struct dm_list profiles;                 /* list of profiles which are loaded already and which are ready for use */
-	struct profile *shell_profile;           /* master profile used in interactive/shell mode */
 };

 #define CFG_PATH_MAX_LEN 128
@@ -99,34 +98,31 @@ typedef union {


 /* whether the configuration item name is variable */
-#define CFG_NAME_VARIABLE        0x0001
+#define CFG_NAME_VARIABLE	0x001
 /* whether empty value is allowed */
-#define CFG_ALLOW_EMPTY          0x0002
+#define CFG_ALLOW_EMPTY		0x002
 /* whether the configuration item is for advanced use only */
-#define CFG_ADVANCED             0x0004
+#define CFG_ADVANCED		0x004
 /* whether the configuration item is not officially supported */
-#define CFG_UNSUPPORTED          0x0008
+#define CFG_UNSUPPORTED		0x008
 /* whether the configuration item is customizable by a profile */
-#define CFG_PROFILABLE           0x0010
-/* whether the configuration item is customizable by a profile
- * and whether it can be attached to VG/LV metadata at the same time
+#define CFG_PROFILABLE		0x010
+/* whether the configuration item is customizable by a profile */
+/* and whether it can be attached to VG/LV metadata at the same time
 * The CFG_PROFILABLE_METADATA flag incorporates CFG_PROFILABLE flag!!! */
-#define CFG_PROFILABLE_METADATA  0x0030
+#define CFG_PROFILABLE_METADATA 0x030
 /* whether the default value is undefned */
-#define CFG_DEFAULT_UNDEFINED    0x0040
+#define CFG_DEFAULT_UNDEFINED	0x040
 /* whether the default value is commented out on output */
-#define CFG_DEFAULT_COMMENTED    0x0080
+#define CFG_DEFAULT_COMMENTED	0x080
 /* whether the default value is calculated during run time */
-#define CFG_DEFAULT_RUN_TIME     0x0100
+#define CFG_DEFAULT_RUN_TIME	0x100
 /* whether the configuration setting is disabled (and hence defaults always used) */
-#define CFG_DISABLED             0x0200
+#define CFG_DISABLED		0x200
 /* whether to print integers in octal form (prefixed by "0") */
-#define CFG_FORMAT_INT_OCTAL     0x0400
+#define CFG_FORMAT_INT_OCTAL	0x400
 /* whether to disable checks for the whole config section subtree */
-#define CFG_SECTION_NO_CHECK     0x0800
-/* whether to disallow a possibility to override configuration
- * setting for commands run interactively (e.g. in lvm shell) */
-#define CFG_DISALLOW_INTERACTIVE 0x1000
+#define CFG_SECTION_NO_CHECK	0x800

 /* configuration definition item structure */
 typedef struct cfg_def_item {
@@ -216,15 +212,11 @@ struct cft_check_handle {
 	unsigned check_diff:1;		/* check if the value used differs from default one */
 	unsigned ignoreadvanced:1;	/* do not include advnced configs */
 	unsigned ignoreunsupported:1;	/* do not include unsupported configs */
-	uint16_t disallowed_flags;	/* set of disallowed flags */
 	uint8_t status[CFG_COUNT];	/* flags for each configuration item - the result of the check */
 };

 int config_def_get_path(char *buf, size_t buf_size, int id);
-/* Checks config using given handle - the handle may be reused. */
 int config_def_check(struct cft_check_handle *handle);
-/* Forces config check and automatically creates a new handle inside with defaults and discards the handle after the check. */
-int config_force_check(struct cmd_context *cmd, config_source_t source, struct dm_config_tree *cft);

 int override_config_tree_from_string(struct cmd_context *cmd, const char *config_settings);
 int override_config_tree_from_profile(struct cmd_context *cmd, struct profile *profile);
@@ -307,6 +299,5 @@ int get_default_allocation_cache_pool_chunk_size_CFG(struct cmd_context *cmd, st
 #define get_default_unconfigured_allocation_cache_pool_chunk_size_CFG NULL
 const char *get_default_allocation_cache_policy_CFG(struct cmd_context *cmd, struct profile *profile);
 #define get_default_unconfigured_allocation_cache_policy_CFG NULL
-uint64_t get_default_allocation_cache_pool_max_chunks_CFG(struct cmd_context *cmd, struct profile *profile);

 #endif
--- a/lib/config/config_settings.h
+++ b/lib/config/config_settings.h
@@ -23,11 +23,6 @@
 * - define a configuration array of one or more types:
 *   cfg_array(id, name, parent, flags, types, default_value, since_version, unconfigured_default_value, deprecated_since_version, deprecation_comment, comment)
 *
- * - define a configuration setting where the default value is evaluated in runtime
- *   cfg_runtime(id, name, parent, flags, type, since_version, deprecated_since_version, deprecation_comment, comment)
- *   (for each cfg_runtime, you need to define 'get_default_<name>(struct cmd_context *cmd, struct profile *profile)' function
- *    to get the default value in runtime - usually, these functions are placed in config.[ch] file)
- *
 *
 * If default value can't be assigned statically because it depends on some
 * run-time checks or if it depends on other settings already defined,
@@ -57,7 +52,6 @@
 *                                 CFG_DISABLED - configuration is disabled (defaults always used)
 *                                 CFG_FORMAT_INT_OCTAL - print integer number in octal form (also prefixed by "0")
 *                                 CFG_SECTION_NO_CHECK - do not check content of the section at all - use with care!!!
- *                                 CFG_DISALLOW_INTERACTIVE - disallow configuration node for use in interactive environment (e.g. cmds run in lvm shell)
 *
 * type:		       Allowed type for the value of simple configuation setting, one of:
 *                                 CFG_TYPE_BOOL
@@ -130,7 +124,7 @@ cfg_section(devices_CFG_SECTION, "devices", root_CFG_SECTION, 0, vsn(1, 0, 0), 0
 cfg_section(allocation_CFG_SECTION, "allocation", root_CFG_SECTION, CFG_PROFILABLE, vsn(2, 2, 77), 0, NULL,
 	"How LVM selects space and applies properties to LVs.\n")

-cfg_section(log_CFG_SECTION, "log", root_CFG_SECTION, CFG_PROFILABLE, vsn(1, 0, 0), 0, NULL,
+cfg_section(log_CFG_SECTION, "log", root_CFG_SECTION, 0, vsn(1, 0, 0), 0, NULL,
 	"How LVM log information is reported.\n")

 cfg_section(backup_CFG_SECTION, "backup", root_CFG_SECTION, 0, vsn(1, 0, 0), 0, NULL,
@@ -172,7 +166,7 @@ cfg(config_checks_CFG, "checks", config_CFG_SECTION, 0, CFG_TYPE_BOOL, 1, vsn(2,
 cfg(config_abort_on_errors_CFG, "abort_on_errors", config_CFG_SECTION, 0, CFG_TYPE_BOOL, 0, vsn(2,2,99), NULL, 0, NULL,
 	"Abort the LVM process if a configuration mismatch is found.\n")

-cfg_runtime(config_profile_dir_CFG, "profile_dir", config_CFG_SECTION, CFG_DISALLOW_INTERACTIVE, CFG_TYPE_STRING, vsn(2, 2, 99), 0, NULL,
+cfg_runtime(config_profile_dir_CFG, "profile_dir", config_CFG_SECTION, 0, CFG_TYPE_STRING, vsn(2, 2, 99), 0, NULL,
 	"Directory where LVM looks for configuration profiles.\n")

 cfg(devices_dir_CFG, "dir", devices_CFG_SECTION, CFG_ADVANCED, CFG_TYPE_STRING, DEFAULT_DEV_DIR, vsn(1, 0, 0), NULL, 0, NULL,
@@ -401,18 +395,6 @@ cfg(devices_issue_discards_CFG, "issue_discards", devices_CFG_SECTION, 0, CFG_TY
 	"generally do. If enabled, discards will only be issued if both the\n"
 	"storage and kernel provide support.\n")

-cfg(devices_allow_changes_with_duplicate_pvs_CFG, "allow_changes_with_duplicate_pvs", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_ALLOW_CHANGES_WITH_DUPLICATE_PVS, vsn(2, 2, 153), NULL, 0, NULL,
-	"Allow VG modification while a PV appears on multiple devices.\n"
-	"When a PV appears on multiple devices, LVM attempts to choose the\n"
-	"best device to use for the PV. If the devices represent the same\n"
-	"underlying storage, the choice has minimal consequence. If the\n"
-	"devices represent different underlying storage, the wrong choice\n"
-	"can result in data loss if the VG is modified. Disabling this\n"
-	"setting is the safest option because it prevents modifying a VG\n"
-	"or activating LVs in it while a PV appears on multiple devices.\n"
-	"Enabling this setting allows the VG to be used as usual even with\n"
-	"uncertain devices.\n")
-
 cfg_array(allocation_cling_tag_list_CFG, "cling_tag_list", allocation_CFG_SECTION, CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(2, 2, 77), NULL, 0, NULL,
 	"Advise LVM which PVs to use when searching for new space.\n"
 	"When searching for free space to extend an LV, the 'cling' allocation\n"
@@ -467,12 +449,6 @@ cfg(allocation_mirror_logs_require_separate_pvs_CFG, "mirror_logs_require_separa
 	"Mirror logs and images will always use different PVs.\n"
 	"The default setting changed in version 2.02.85.\n")

-cfg(allocation_raid_stripe_all_devices_CFG, "raid_stripe_all_devices", allocation_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_ALLOCATION_STRIPE_ALL_DEVICES, vsn(2, 2, 162), NULL, 0, NULL,
-	"Stripe across all PVs when RAID stripes are not specified.\n"
-	"If enabled, all PVs in the VG or on the command line are used for raid0/4/5/6/10\n"
-	"when the command does not specify the number of stripes to use.\n"
-	"This was the default behaviour until release 2.02.162.\n")
-
 cfg(allocation_cache_pool_metadata_require_separate_pvs_CFG, "cache_pool_metadata_require_separate_pvs", allocation_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_CACHE_POOL_METADATA_REQUIRE_SEPARATE_PVS, vsn(2, 2, 106), NULL, 0, NULL,
 	"Cache pool metadata and data will always use different PVs.\n")

@@ -516,11 +492,6 @@ cfg_runtime(allocation_cache_pool_chunk_size_CFG, "cache_pool_chunk_size", alloc
 	"on the smaller end of the spectrum. Supported values range from\n"
 	"32KiB to 1GiB in multiples of 32.\n")

-cfg(allocation_cache_pool_max_chunks_CFG, "cache_pool_max_chunks", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_UNDEFINED, CFG_TYPE_INT, 0, vsn(2, 2, 165), NULL, 0, NULL,
-	"The maximum number of chunks in a cache pool.\n"
-	"For cache target v1.9 the recommended maximumm is 1000000 chunks.\n"
-	"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")

@@ -564,47 +535,6 @@ cfg_runtime(allocation_thin_pool_chunk_size_CFG, "thin_pool_chunk_size", allocat
 cfg(allocation_physical_extent_size_CFG, "physical_extent_size", allocation_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_EXTENT_SIZE, vsn(2, 2, 112), NULL, 0, NULL,
 	"Default physical extent size in KiB to use for new VGs.\n")

-cfg(log_report_command_log_CFG, "report_command_log", log_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED | CFG_DISALLOW_INTERACTIVE, CFG_TYPE_BOOL, DEFAULT_COMMAND_LOG_REPORT, vsn(2, 2, 158), NULL, 0, NULL,
-	"Enable or disable LVM log reporting.\n"
-	"If enabled, LVM will collect a log of operations, messages,\n"
-	"per-object return codes with object identification and associated\n"
-	"error numbers (errnos) during LVM command processing. Then the\n"
-	"log is either reported solely or in addition to any existing\n"
-	"reports, depending on LVM command used. If it is a reporting command\n"
-	"(e.g. pvs, vgs, lvs, lvm fullreport), then the log is reported in\n"
-	"addition to any existing reports. Otherwise, there's only log report\n"
-	"on output. For all applicable LVM commands, you can request that\n"
-	"the output has only log report by using --logonly command line\n"
-	"option. Use log/command_log_cols and log/command_log_sort settings\n"
-	"to define fields to display and sort fields for the log report.\n"
-	"You can also use log/command_log_selection to define selection\n"
-	"criteria used each time the log is reported.\n")
-
-cfg(log_command_log_sort_CFG, "command_log_sort", log_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED | CFG_DISALLOW_INTERACTIVE, CFG_TYPE_STRING, DEFAULT_COMMAND_LOG_SORT, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to sort by when reporting command log.\n"
-	"See <lvm command> --logonly --configreport log -o help\n"
-	"for the list of possible fields.\n")
-
-cfg(log_command_log_cols_CFG, "command_log_cols", log_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED | CFG_DISALLOW_INTERACTIVE, CFG_TYPE_STRING, DEFAULT_COMMAND_LOG_COLS, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to report when reporting command log.\n"
-	"See <lvm command> --logonly --configreport log -o help\n"
-	"for the list of possible fields.\n")
-
-cfg(log_command_log_selection_CFG, "command_log_selection", log_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED | CFG_DISALLOW_INTERACTIVE, CFG_TYPE_STRING, DEFAULT_COMMAND_LOG_SELECTION, vsn(2, 2, 158), NULL, 0, NULL,
-	"Selection criteria used when reporting command log.\n"
-	"You can define selection criteria that are applied each\n"
-	"time log is reported. This way, it is possible to control the\n"
-	"amount of log that is displayed on output and you can select\n"
-	"only parts of the log that are important for you. To define\n"
-	"selection criteria, use fields from log report. See also\n"
-	"<lvm command> --logonly --configreport log -S help for the\n"
-	"list of possible fields and selection operators. You can also\n"
-	"define selection criteria for log report on command line directly\n"
-	"using <lvm command> --configreport log -S <selection criteria>\n"
-	"which has precedence over log/command_log_selection setting.\n"
-	"For more information about selection criteria in general, see\n"
-	"lvm(8) man page.\n")
-
 cfg(log_verbose_CFG, "verbose", log_CFG_SECTION, 0, CFG_TYPE_INT, DEFAULT_VERBOSE, vsn(1, 0, 0), NULL, 0, NULL,
 	"Controls the messages sent to stdout or stderr.\n")

@@ -924,20 +854,12 @@ cfg(global_use_lvmetad_CFG, "use_lvmetad", global_CFG_SECTION, 0, CFG_TYPE_BOOL,
 	"scanning from the LVM system entirely, including lvmetad, use\n"
 	"devices/global_filter.\n")

-cfg(global_lvmetad_update_wait_time_CFG, "lvmetad_update_wait_time", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_LVMETAD_UPDATE_WAIT_TIME, vsn(2, 2, 151), NULL, 0, NULL,
-	"The number of seconds a command will wait for lvmetad update to finish.\n"
-	"After waiting for this period, a command will not use lvmetad, and\n"
-	"will revert to disk scanning.\n")
-
 cfg(global_use_lvmlockd_CFG, "use_lvmlockd", global_CFG_SECTION, 0, CFG_TYPE_BOOL, 0, vsn(2, 2, 124), NULL, 0, NULL,
 	"Use lvmlockd for locking among hosts using LVM on shared storage.\n"
-	"Applicable only if LVM is compiled with lockd support in which\n"
-	"case there is also lvmlockd(8) man page available for more\n"
-	"information.\n")
+	"See lvmlockd(8) for more information.\n")

 cfg(global_lvmlockd_lock_retries_CFG, "lvmlockd_lock_retries", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_LVMLOCKD_LOCK_RETRIES, vsn(2, 2, 125), NULL, 0, NULL,
-	"Retry lvmlockd lock requests this many times.\n"
-	"Applicable only if LVM is compiled with lockd support\n")
+	"Retry lvmlockd lock requests this many times.\n")

 cfg(global_sanlock_lv_extend_CFG, "sanlock_lv_extend", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_SANLOCK_LV_EXTEND_MB, vsn(2, 2, 124), NULL, 0, NULL,
 	"Size in MiB to extend the internal LV holding sanlock locks.\n"
@@ -945,8 +867,7 @@ cfg(global_sanlock_lv_extend_CFG, "sanlock_lv_extend", global_CFG_SECTION, CFG_D
 	"LVs have been created, the internal LV needs to be extended. lvcreate\n"
 	"will automatically extend the internal LV when needed by the amount\n"
 	"specified here. Setting this to 0 disables the automatic extension\n"
-	"and can cause lvcreate to fail. Applicable only if LVM is compiled\n"
-	"with lockd support\n")
+	"and can cause lvcreate to fail.\n")

 cfg(global_thin_check_executable_CFG, "thin_check_executable", global_CFG_SECTION, CFG_ALLOW_EMPTY | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, THIN_CHECK_CMD, vsn(2, 2, 94), "@THIN_CHECK_CMD@", 0, NULL,
 	"The full path to the thin_check command.\n"
@@ -1072,8 +993,7 @@ cfg(global_use_lvmpolld_CFG, "use_lvmpolld", global_CFG_SECTION, 0, CFG_TYPE_BOO
 	"manage the progress of ongoing operations. lvmpolld can be used as\n"
 	"a native systemd service, which allows it to be started on demand,\n"
 	"and to use its own control group. When this option is disabled, LVM\n"
-	"commands will supervise long running operations by forking themselves.\n"
-	"Applicable only if LVM is compiled with lvmpolld support.\n")
+	"commands will supervise long running operations by forking themselves.\n")

 cfg(global_notify_dbus_CFG, "notify_dbus", global_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_NOTIFY_DBUS, vsn(2, 2, 145), NULL, 0, NULL,
 	"Enable D-Bus notification from LVM commands.\n"
@@ -1520,20 +1440,6 @@ cfg(disk_area_start_sector_CFG, "start_sector", disk_area_CFG_SUBSECTION, CFG_UN
 cfg(disk_area_size_CFG, "size", disk_area_CFG_SUBSECTION, CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(1, 0, 0), NULL, 0, NULL, NULL)
 cfg(disk_area_id_CFG, "id", disk_area_CFG_SUBSECTION, CFG_UNSUPPORTED | CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 0), NULL, 0, NULL, NULL)

-cfg(report_output_format_CFG, "output_format", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED | CFG_DISALLOW_INTERACTIVE, CFG_TYPE_STRING, DEFAULT_REP_OUTPUT_FORMAT, vsn(2, 2, 158), NULL, 0, NULL,
-	"Format of LVM command's report output.\n"
-	"If there is more than one report per command, then the format\n"
-	"is applied for all reports. You can also change output format\n"
-	"directly on command line using --reportformat option which\n"
-	"has precedence over log/output_format setting.\n"
-	"Accepted values:\n"
-	"  basic\n"
-	"    Original format with columns and rows. If there is more than\n"
-	"    one report per command, each report is prefixed with report's\n"
-	"    name for identification.\n"
-	"  json\n"
-	"    JSON format.\n")
-
 cfg(report_compact_output_CFG, "compact_output", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_REP_COMPACT_OUTPUT, vsn(2, 2, 115), NULL, 0, NULL,
 	"Do not print empty values for all report fields.\n"
 	"If enabled, all fields that don't have a value set for any of the\n"
@@ -1576,7 +1482,7 @@ cfg(report_prefixes_CFG, "prefixes", report_CFG_SECTION, CFG_PROFILABLE | CFG_DE
 cfg(report_quoted_CFG, "quoted", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_REP_QUOTED, vsn(2, 2, 39), NULL, 0, NULL,
 	"Quote field values when using field name prefixes.\n")

-cfg(report_columns_as_rows_CFG, "columns_as_rows", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_REP_COLUMNS_AS_ROWS, vsn(1, 0, 0), NULL, 0, NULL,
+cfg(report_colums_as_rows_CFG, "colums_as_rows", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_REP_COLUMNS_AS_ROWS, vsn(1, 0, 0), NULL, 0, NULL,
 	"Output each column as a row.\n"
 	"If set, this also implies report/prefixes=1.\n")

@@ -1790,46 +1696,6 @@ cfg(report_pvsegs_cols_verbose_CFG, "pvsegs_cols_verbose", report_CFG_SECTION, C
 	"List of columns to sort by when reporting 'pvs --segments' command in verbose mode.\n"
 	"See 'pvs --segments -o help' for the list of possible fields.\n")

-cfg(report_vgs_cols_full_CFG, "vgs_cols_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_VGS_COLS_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to report for lvm fullreport's 'vgs' subreport.\n"
-	"See 'vgs -o help' for the list of possible fields.\n")
-
-cfg(report_pvs_cols_full_CFG, "pvs_cols_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_PVS_COLS_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to report for lvm fullreport's 'vgs' subreport.\n"
-	"See 'pvs -o help' for the list of possible fields.\n")
-
-cfg(report_lvs_cols_full_CFG, "lvs_cols_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_LVS_COLS_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to report for lvm fullreport's 'lvs' subreport.\n"
-	"See 'lvs -o help' for the list of possible fields.\n")
-
-cfg(report_pvsegs_cols_full_CFG, "pvsegs_cols_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_PVSEGS_COLS_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to report for lvm fullreport's 'pvseg' subreport.\n"
-	"See 'pvs --segments -o help' for the list of possible fields.\n")
-
-cfg(report_segs_cols_full_CFG, "segs_cols_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_SEGS_COLS_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to report for lvm fullreport's 'seg' subreport.\n"
-	"See 'lvs --segments -o help' for the list of possible fields.\n")
-
-cfg(report_vgs_sort_full_CFG, "vgs_sort_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_VGS_SORT_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to sort by when reporting lvm fullreport's 'vgs' subreport.\n"
-	"See 'vgs -o help' for the list of possible fields.\n")
-
-cfg(report_pvs_sort_full_CFG, "pvs_sort_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_PVS_SORT_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to sort by when reporting lvm fullreport's 'vgs' subreport.\n"
-	"See 'pvs -o help' for the list of possible fields.\n")
-
-cfg(report_lvs_sort_full_CFG, "lvs_sort_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_LVS_SORT_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to sort by when reporting lvm fullreport's 'lvs' subreport.\n"
-	"See 'lvs -o help' for the list of possible fields.\n")
-
-cfg(report_pvsegs_sort_full_CFG, "pvsegs_sort_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_PVSEGS_SORT_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to sort by when reporting for lvm fullreport's 'pvseg' subreport.\n"
-	"See 'pvs --segments -o help' for the list of possible fields.\n")
-
-cfg(report_segs_sort_full_CFG, "segs_sort_full", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_SEGS_SORT_FULL, vsn(2, 2, 158), NULL, 0, NULL,
-	"List of columns to sort by when reporting lvm fullreport's 'seg' subreport.\n"
-	"See 'lvs --segments -o help' for the list of possible fields.\n")
-
 cfg(report_mark_hidden_devices_CFG, "mark_hidden_devices", report_CFG_SECTION, CFG_PROFILABLE | CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, 1, vsn(2, 2, 140), NULL, 0, NULL,
 	"Use brackets [] to mark hidden devices.\n")

@@ -1913,7 +1779,6 @@ cfg_array(local_extra_system_ids_CFG, "extra_system_ids", local_CFG_SECTION, CFG

 cfg(local_host_id_CFG, "host_id", local_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(2, 2, 124), NULL, 0, NULL,
 	"The lvmlockd sanlock host_id.\n"
-	"This must be unique among all hosts, and must be between 1 and 2000.\n"
-	"Applicable only if LVM is compiled with lockd support\n")
+	"This must be unique among all hosts, and must be between 1 and 2000.\n")

 cfg(CFG_COUNT, NULL, root_CFG_SECTION, 0, CFG_TYPE_INT, 0, vsn(0, 0, 0), NULL, 0, NULL, NULL)
--- a/lib/config/defaults.h
+++ b/lib/config/defaults.h
@@ -45,7 +45,6 @@
 #define DEFAULT_DATA_ALIGNMENT_DETECTION 1
 #define DEFAULT_ISSUE_DISCARDS 0
 #define DEFAULT_PV_MIN_SIZE_KB 2048
-#define DEFAULT_ALLOW_CHANGES_WITH_DUPLICATE_PVS 0

 #define DEFAULT_LOCKING_LIB "liblvm2clusterlock.so"
 #define DEFAULT_ERROR_WHEN_FULL 0
@@ -53,7 +52,6 @@
 #define DEFAULT_FALLBACK_TO_CLUSTERED_LOCKING 1
 #define DEFAULT_WAIT_FOR_LOCKS 1
 #define DEFAULT_LVMLOCKD_LOCK_RETRIES 3
-#define DEFAULT_LVMETAD_UPDATE_WAIT_TIME 10
 #define DEFAULT_PRIORITISE_WRITE_LOCKS 1
 #define DEFAULT_USE_MLOCKALL 0
 #define DEFAULT_METADATA_READ_ONLY 0
@@ -66,14 +64,7 @@
 #define DEFAULT_MIRROR_LOG_FAULT_POLICY "allocate"
 #define DEFAULT_MIRROR_IMAGE_FAULT_POLICY "remove"
 #define DEFAULT_MIRROR_MAX_IMAGES 8 /* limited by kernel DM_KCOPYD_MAX_REGIONS */
-/* Limited by kernel failed devices bitfield in superblock (raid4/5/6 MD max 253) */
-/*
- * FIXME: Increase these to 64 and further to the MD maximum
- *	  once the SubLVs split and name shift got enhanced
- */
-#define DEFAULT_RAID1_MAX_IMAGES 10
-#define DEFAULT_RAID_MAX_IMAGES 64
-#define DEFAULT_ALLOCATION_STRIPE_ALL_DEVICES 0 /* Don't stripe across all devices if not -i/--stripes given */
+#define DEFAULT_RAID_MAX_IMAGES 8

 #define DEFAULT_RAID_FAULT_POLICY "warn"

@@ -127,7 +118,6 @@
 #define DEFAULT_CACHE_REPAIR_OPTIONS_CONFIG "#S" DEFAULT_CACHE_REPAIR_OPTION1
 #define DEFAULT_CACHE_POOL_METADATA_REQUIRE_SEPARATE_PVS 0
 #define DEFAULT_CACHE_POOL_CHUNK_SIZE 64 /* KB */
-#define DEFAULT_CACHE_POOL_MAX_CHUNKS 1000000
 #define DEFAULT_CACHE_POOL_MIN_METADATA_SIZE 2048  /* KB */
 #define DEFAULT_CACHE_POOL_MAX_METADATA_SIZE (16 * 1024 * 1024)  /* KB */
 #define DEFAULT_CACHE_POLICY "mq"
@@ -168,7 +158,6 @@
 #  define DEFAULT_LOG_FACILITY LOG_USER
 #endif

-#define DEFAULT_COMMAND_LOG_REPORT 0
 #define DEFAULT_SYSLOG 1
 #define DEFAULT_VERBOSE 0
 #define DEFAULT_SILENT 0
@@ -216,18 +205,14 @@
 #define DEFAULT_REP_LIST_ITEM_SEPARATOR ","
 #define DEFAULT_TIME_FORMAT "%Y-%m-%d %T %z"

-#define DEFAULT_REP_OUTPUT_FORMAT "basic"
 #define DEFAULT_COMPACT_OUTPUT_COLS ""

-#define DEFAULT_COMMAND_LOG_SELECTION "!(log_type=status && message=success)"
-
 #define DEFAULT_LVS_COLS "lv_name,vg_name,lv_attr,lv_size,pool_lv,origin,data_percent,metadata_percent,move_pv,mirror_log,copy_percent,convert_lv"
 #define DEFAULT_VGS_COLS "vg_name,pv_count,lv_count,snap_count,vg_attr,vg_size,vg_free"
 #define DEFAULT_PVS_COLS "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free"
 #define DEFAULT_SEGS_COLS "lv_name,vg_name,lv_attr,stripes,segtype,seg_size"
 #define DEFAULT_PVSEGS_COLS "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size"
 #define DEFAULT_DEVTYPES_COLS "devtype_name,devtype_max_partitions,devtype_description"
-#define DEFAULT_COMMAND_LOG_COLS "log_seq_num,log_type,log_context,log_object_type,log_object_name,log_object_id,log_object_group,log_object_group_id,log_message,log_errno,log_ret_code"

 #define DEFAULT_LVS_COLS_VERB "lv_name,vg_name,seg_count,lv_attr,lv_size,lv_major,lv_minor,lv_kernel_major,lv_kernel_minor,pool_lv,origin,data_percent,metadata_percent,move_pv,copy_percent,mirror_log,convert_lv,lv_uuid,lv_profile"
 #define DEFAULT_VGS_COLS_VERB "vg_name,vg_attr,vg_extent_size,pv_count,lv_count,snap_count,vg_size,vg_free,vg_uuid,vg_profile"
@@ -236,25 +221,12 @@
 #define DEFAULT_PVSEGS_COLS_VERB "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size,lv_name,seg_start_pe,segtype,seg_pe_ranges"
 #define DEFAULT_DEVTYPES_COLS_VERB "devtype_name,devtype_max_partitions,devtype_description"

-#define DEFAULT_VGS_COLS_FULL "vg_all"
-#define DEFAULT_PVS_COLS_FULL "pv_all"
-#define DEFAULT_LVS_COLS_FULL "lv_all"
-#define DEFAULT_PVSEGS_COLS_FULL "pvseg_all,pv_uuid,lv_uuid"
-#define DEFAULT_SEGS_COLS_FULL "seg_all,lv_uuid"
-
 #define DEFAULT_LVS_SORT "vg_name,lv_name"
 #define DEFAULT_VGS_SORT "vg_name"
 #define DEFAULT_PVS_SORT "pv_name"
 #define DEFAULT_SEGS_SORT "vg_name,lv_name,seg_start"
 #define DEFAULT_PVSEGS_SORT "pv_name,pvseg_start"
 #define DEFAULT_DEVTYPES_SORT "devtype_name"
-#define DEFAULT_COMMAND_LOG_SORT "log_seq_num"
-
-#define DEFAULT_VGS_SORT_FULL "vg_name"
-#define DEFAULT_PVS_SORT_FULL "pv_name"
-#define DEFAULT_LVS_SORT_FULL "vg_name,lv_name"
-#define DEFAULT_PVSEGS_SORT_FULL "pv_uuid,pvseg_start"
-#define DEFAULT_SEGS_SORT_FULL "lv_uuid,seg_start"

 #define DEFAULT_MIRROR_DEVICE_FAULT_POLICY "remove"
 #define DEFAULT_MIRROR_LOG_FAULT_POLICY "allocate"
--- a/lib/datastruct/str_list.c
+++ b/lib/datastruct/str_list.c
@@ -92,15 +92,7 @@ void str_list_del(struct dm_list *sll, const char *str)

 	dm_list_iterate_safe(slh, slht, sll)
 		if (!strcmp(str, dm_list_item(slh, struct dm_str_list)->str))
-			dm_list_del(slh);
-}
-
-void str_list_wipe(struct dm_list *sll)
-{
-	struct dm_list *slh, *slht;
-
-	dm_list_iterate_safe(slh, slht, sll)
-		dm_list_del(slh);
+			 dm_list_del(slh);
 }

 int str_list_dup(struct dm_pool *mem, struct dm_list *sllnew,
@@ -126,8 +118,8 @@ int str_list_match_item(const struct dm_list *sll, const char *str)
 	struct dm_str_list *sl;

 	dm_list_iterate_items(sl, sll)
-		if (!strcmp(str, sl->str))
-			return 1;
+	    if (!strcmp(str, sl->str))
+		return 1;

 	return 0;
 }
@@ -161,8 +153,8 @@ int str_list_lists_equal(const struct dm_list *sll, const struct dm_list *sll2)
 		return 0;

 	dm_list_iterate_items(sl, sll)
-		if (!str_list_match_item(sll2, sl->str))
-			return 0;
+	    if (!str_list_match_item(sll2, sl->str))
+		return 0;

 	return 1;
 }
--- a/lib/datastruct/str_list.h
+++ b/lib/datastruct/str_list.h
@@ -25,7 +25,6 @@ int str_list_add_list(struct dm_pool *mem, struct dm_list *sll, struct dm_list *
 int str_list_add_no_dup_check(struct dm_pool *mem, struct dm_list *sll, const char *str);
 int str_list_add_h_no_dup_check(struct dm_pool *mem, struct dm_list *sll, const char *str);
 void str_list_del(struct dm_list *sll, const char *str);
-void str_list_wipe(struct dm_list *sll);
 int str_list_match_item(const struct dm_list *sll, const char *str);
 int str_list_match_list(const struct dm_list *sll, const struct dm_list *sll2, const char **tag_matched);
 int str_list_lists_equal(const struct dm_list *sll, const struct dm_list *sll2);
--- a/lib/device/dev-cache.c
+++ b/lib/device/dev-cache.c
@@ -42,7 +42,6 @@ static struct {
 	struct dm_hash_table *names;
 	struct dm_hash_table *vgid_index;
 	struct dm_hash_table *lvid_index;
-	struct btree *sysfs_only_devices; /* see comments in _get_device_for_sysfs_dev_name_using_devno */
 	struct btree *devices;
 	struct dm_regex *preferred_names_matcher;
 	const char *dev_dir;
@@ -363,7 +362,7 @@ static int _add_alias(struct device *dev, const char *path)
 	return 1;
 }

-static int _get_sysfs_value(const char *path, char *buf, size_t buf_size, int error_if_no_value)
+static int _get_sysfs_value(const char *path, char *buf, size_t buf_size)
 {
 	FILE *fp;
 	size_t len;
@@ -379,13 +378,15 @@ static int _get_sysfs_value(const char *path, char *buf, size_t buf_size, int er
 		goto out;
 	}

-	if ((len = strlen(buf)) && buf[len - 1] == '\n')
-		buf[--len] = '\0';
-
-	if (!len && error_if_no_value)
+	if (!(len = strlen(buf)) || (len == 1 && buf[0] == '\n')) {
 		log_error("_get_sysfs_value: %s: no value", path);
-	else
-		r = 1;
+		goto out;
+	}
+
+	if (buf[len - 1] == '\n')
+		buf[len - 1] = '\0';
+
+	r = 1;
 out:
 	if (fclose(fp))
 		log_sys_error("fclose", path);
@@ -402,7 +403,7 @@ static int _get_dm_uuid_from_sysfs(char *buf, size_t buf_size, int major, int mi
 		return 0;
 	}

-	return _get_sysfs_value(path, buf, buf_size, 0);
+	return _get_sysfs_value(path, buf, buf_size);
 }

 static struct dm_list *_get_or_add_list_by_index_key(struct dm_hash_table *idx, const char *key)
@@ -427,89 +428,26 @@ static struct dm_list *_get_or_add_list_by_index_key(struct dm_hash_table *idx,
 	return list;
 }

-static struct device *_insert_sysfs_dev(dev_t devno, const char *devname)
-{
-	static struct device _fake_dev = { .flags = DEV_USED_FOR_LV };
-	struct stat stat0;
-	char path[PATH_MAX];
-	char *path_copy;
-	struct device *dev;
-
-	if (dm_snprintf(path, sizeof(path), "%s%s", _cache.dev_dir, devname) < 0) {
-		log_error("_insert_sysfs_dev: %s: dm_snprintf failed", devname);
-		return NULL;
-	}
-
-	if (lstat(path, &stat0) < 0) {
-		/* When device node does not exist return fake entry.
-		 * This may happen when i.e. lvm2 device dir != /dev */
-		log_debug("%s: Not available device node", path);
-		return &_fake_dev;
-	}
-
-	if (!(dev = _dev_create(devno)))
-		return_NULL;
-
-	if (!(path_copy = dm_pool_strdup(_cache.mem, path))) {
-		log_error("_insert_sysfs_dev: %s: dm_pool_strdup failed", devname);
-		return NULL;
-	}
-
-	if (!_add_alias(dev, path_copy)) {
-		log_error("Couldn't add alias to dev cache.");
-		_free(dev);
-		return NULL;
-	}
-
-	if (!btree_insert(_cache.sysfs_only_devices, (uint32_t) devno, dev)) {
-		log_error("Couldn't add device to binary tree of sysfs-only devices in dev cache.");
-		_free(dev);
-		return NULL;
-	}
-
-	return dev;
-}
-
 static struct device *_get_device_for_sysfs_dev_name_using_devno(const char *devname)
 {
 	char path[PATH_MAX];
 	char buf[PATH_MAX];
 	int major, minor;
-	dev_t devno;
-	struct device *dev;

 	if (dm_snprintf(path, sizeof(path), "%sblock/%s/dev", dm_sysfs_dir(), devname) < 0) {
-		log_error("_get_device_for_sysfs_dev_name_using_devno: %s: dm_snprintf failed", devname);
+		log_error("_get_device_for_non_dm_dev: %s: dm_snprintf failed", devname);
 		return NULL;
 	}

-	if (!_get_sysfs_value(path, buf, sizeof(buf), 1))
+	if (!_get_sysfs_value(path, buf, sizeof(buf)))
 		return_NULL;

 	if (sscanf(buf, "%d:%d", &major, &minor) != 2) {
-		log_error("_get_device_for_sysfs_dev_name_using_devno: %s: failed to get major and minor number", devname);
+		log_error("_get_device_for_non_dm_dev: %s: failed to get major and minor number", devname);
 		return NULL;
 	}

-	devno = MKDEV((dev_t)major, (dev_t)minor);
-	if (!(dev = (struct device *) btree_lookup(_cache.devices, (uint32_t) devno))) {
-		/*
-		 * If we get here, it means the device is referenced in sysfs, but it's not yet in /dev.
-		 * This may happen in some rare cases right after LVs get created - we sync with udev
-		 * (or alternatively we create /dev content ourselves) while VG lock is held. However,
-		 * dev scan is done without VG lock so devices may already be in sysfs, but /dev may
-		 * not be updated yet if we call LVM command right after LV creation. This is not a
-		 * problem with devtmpfs as there's at least kernel name for device in /dev as soon
-		 * as the sysfs item exists, but we still support environments without devtmpfs or
-		 * where different directory for dev nodes is used (e.g. our test suite). So track
-		 * such devices in _cache.sysfs_only_devices hash for the vgid/lvid check to work still.
-		 */
-		if (!(dev = (struct device *) btree_lookup(_cache.sysfs_only_devices, (uint32_t) devno)) &&
-		    !(dev = _insert_sysfs_dev(devno, devname)))
-			return_NULL;
-	}
-
-	return dev;
+	return (struct device *) btree_lookup(_cache.devices, (uint32_t) MKDEV(major, minor));
 }

 #define NOT_LVM_UUID "-"
@@ -556,10 +494,6 @@ static int _index_dev_by_vgid_and_lvid(struct device *dev)
 	struct device_list *dl_vgid, *dl_lvid;
 	int r = 0;

-	if (dev->flags & DEV_USED_FOR_LV)
-		/* already indexed */
-		return 1;
-
 	/* Get holders for device. */
 	if (dm_snprintf(path, sizeof(path), "%sdev/block/%d:%d/holders/", dm_sysfs_dir(), (int) MAJOR(dev->dev), (int) MINOR(dev->dev)) < 0) {
 		log_error("%s: dm_snprintf failed for path to holders directory.", devname);
@@ -689,15 +623,14 @@ static int _insert_dev(const char *path, dev_t d)
 	}

 	/* is this device already registered ? */
-	if (!(dev = (struct device *) btree_lookup(_cache.devices, (uint32_t) d))) {
-		if (!(dev = (struct device *) btree_lookup(_cache.sysfs_only_devices, (uint32_t) d))) {
-			/* create new device */
-			if (loopfile) {
-				if (!(dev = dev_create_file(path, NULL, NULL, 0)))
-					return_0;
-			} else if (!(dev = _dev_create(d)))
+	if (!(dev = (struct device *) btree_lookup(_cache.devices,
+						   (uint32_t) d))) {
+		/* create new device */
+		if (loopfile) {
+			if (!(dev = dev_create_file(path, NULL, NULL, 0)))
 				return_0;
-		}
+		} else if (!(dev = _dev_create(d)))
+			return_0;

 		if (!(btree_insert(_cache.devices, (uint32_t) d, dev))) {
 			log_error("Couldn't insert device into binary tree.");
@@ -805,108 +738,6 @@ static int _insert_file(const char *path)
 	return 1;
 }

-static int _dev_cache_iterate_devs_for_index(void)
-{
-	struct btree_iter *iter = btree_first(_cache.devices);
-	struct device *dev;
-	int r = 1;
-
-	while (iter) {
-		dev = btree_get_data(iter);
-
-		if (!_index_dev_by_vgid_and_lvid(dev))
-			r = 0;
-
-		iter = btree_next(iter);
-	}
-
-	return r;
-}
-
-static int _dev_cache_iterate_sysfs_for_index(const char *path)
-{
-	char devname[PATH_MAX];
-	DIR *d;
-	struct dirent *dirent;
-	int major, minor;
-	dev_t devno;
-	struct device *dev;
-	int partial_failure = 0;
-	int r = 0;
-
-	if (!(d = opendir(path))) {
-		log_sys_error("opendir", path);
-		return 0;
-	}
-
-	while ((dirent = readdir(d))) {
-		if (!strcmp(".", dirent->d_name) ||
-		    !strcmp("..", dirent->d_name))
-			continue;
-
-		if (sscanf(dirent->d_name, "%d:%d", &major, &minor) != 2) {
-			log_error("_dev_cache_iterate_sysfs_for_index: %s: failed "
-				  "to get major and minor number", dirent->d_name);
-			partial_failure = 1;
-			continue;
-		}
-
-		devno = MKDEV((dev_t)major, (dev_t)minor);
-		if (!(dev = (struct device *) btree_lookup(_cache.devices, (uint32_t) devno)) &&
-		    !(dev = (struct device *) btree_lookup(_cache.sysfs_only_devices, (uint32_t) devno))) {
-			if (!dm_device_get_name(major, minor, 1, devname, sizeof(devname)) ||
-			    !(dev = _insert_sysfs_dev(devno, devname))) {
-				partial_failure = 1;
-				continue;
-			}
-		}
-
-		if (!_index_dev_by_vgid_and_lvid(dev))
-			partial_failure = 1;
-	}
-
-	r = !partial_failure;
-
-	if (closedir(d))
-		log_sys_error("closedir", path);
-
-	return r;
-}
-
-int dev_cache_index_devs(void)
-{
-	static int sysfs_has_dev_block = -1;
-	char path[PATH_MAX];
-
-	if (dm_snprintf(path, sizeof(path), "%sdev/block", dm_sysfs_dir()) < 0) {
-		log_error("dev_cache_index_devs: dm_snprintf failed.");
-		return 0;
-	}
-
-	/* Skip indexing if /sys/dev/block is not available.*/
-	if (sysfs_has_dev_block == -1) {
-		struct stat info;
-		if (stat(path, &info) == 0)
-			sysfs_has_dev_block = 1;
-		else {
-			if (errno == ENOENT) {
-				sysfs_has_dev_block = 0;
-				return 1;
-			} else {
-				log_sys_error("stat", path);
-				return 0;
-			}
-		}
-	} else if (!sysfs_has_dev_block)
-		return 1;
-
-	if (obtain_device_list_from_udev() &&
-	    udev_get_library_context())
-		return _dev_cache_iterate_devs_for_index();  /* with udev */
-
-	return _dev_cache_iterate_sysfs_for_index(path);
-}
-
 #ifdef UDEV_SYNC_SUPPORT

 static int _device_in_udev_db(const dev_t d)
@@ -984,6 +815,24 @@ bad:
 	return 0;
 }

+static int _add_devs_to_index(void)
+{
+	struct btree_iter *iter = btree_first(_cache.devices);
+	struct device *dev;
+	int r = 1;
+
+	while (iter) {
+		dev = btree_get_data(iter);
+
+		if (!_index_dev_by_vgid_and_lvid(dev))
+			r = 0;
+
+		iter = btree_next(iter);
+	}
+
+	return r;
+}
+
 static void _insert_dirs(struct dm_list *dirs)
 {
 	struct dir_list *dl;
@@ -1004,6 +853,8 @@ static void _insert_dirs(struct dm_list *dirs)
 			log_debug_devs("%s: Failed to insert devices to "
 				       "device cache fully", dl->dir);
 	}
+
+	(void) _add_devs_to_index();
 }

 #else	/* UDEV_SYNC_SUPPORT */
@@ -1077,8 +928,6 @@ static void _full_scan(int dev_scan)

 	_insert_dirs(&_cache.dirs);

-	(void) dev_cache_index_devs();
-
 	dm_list_iterate_items(dl, &_cache.files)
 		_insert_file(dl->dir);

@@ -1180,11 +1029,6 @@ int dev_cache_init(struct cmd_context *cmd)
 		goto bad;
 	}

-	if (!(_cache.sysfs_only_devices = btree_create(_cache.mem))) {
-		log_error("Couldn't create binary tree for sysfs-only devices in dev cache.");
-		goto bad;
-	}
-
 	if (!(_cache.dev_dir = _strdup(cmd->dev_dir))) {
 		log_error("strdup dev_dir failed.");
 		goto bad;
--- a/lib/device/dev-cache.h
+++ b/lib/device/dev-cache.h
@@ -31,7 +31,6 @@ struct dev_filter {
 	unsigned use_count;
 };

-int dev_cache_index_devs(void);
 struct dm_list *dev_cache_get_dev_list_for_vgid(const char *vgid);
 struct dm_list *dev_cache_get_dev_list_for_lvid(const char *lvid);

--- a/lib/device/dev-ext-udev-constants.h
+++ b/lib/device/dev-ext-udev-constants.h
@@ -36,9 +36,6 @@
 #define DEV_EXT_UDEV_DEVTYPE			"DEVTYPE"
 #define DEV_EXT_UDEV_DEVTYPE_DISK		"disk"

-/* the list of symlinks associated with device node */
-#define DEV_EXT_UDEV_DEVLINKS			"DEVLINKS"
-
 /*
 * DEV_EXT_UDEV_MPATH_DEVICE_PATH is set by multipath in udev db
 * with value either 0 or 1. The same functionality as
--- a/lib/device/dev-io.c
+++ b/lib/device/dev-io.c
@@ -494,22 +494,11 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)

 #ifdef O_NOATIME
 	/* Don't update atime on device inodes */
-	if (!(dev->flags & DEV_REGULAR) && !(dev->flags & DEV_NOT_O_NOATIME))
+	if (!(dev->flags & DEV_REGULAR))
 		flags |= O_NOATIME;
 #endif

 	if ((dev->fd = open(name, flags, 0777)) < 0) {
-#ifdef O_NOATIME
-		if ((errno == EPERM) && (flags & O_NOATIME)) {
-			flags &= ~O_NOATIME;
-			dev->flags |= DEV_NOT_O_NOATIME;
-			if ((dev->fd = open(name, flags, 0777)) >= 0) {
-				log_debug_devs("%s: Not using O_NOATIME", name);
-				goto opened;
-			}
-		}
-#endif
-
 #ifdef O_DIRECT_SUPPORT
 		if (direct && !(dev->flags & DEV_O_DIRECT_TESTED)) {
 			flags &= ~O_DIRECT;
--- a/lib/device/dev-type.c
+++ b/lib/device/dev-type.c
@@ -125,9 +125,6 @@ struct dev_types *create_dev_types(const char *proc_dir,
 		if (!strncmp("emcpower", line + i, 8) && isspace(*(line + i + 8)))
 			dt->emcpower_major = line_maj;

-		if (!strncmp("loop", line + i, 4) && isspace(*(line + i + 4)))
-			dt->loop_major = line_maj;
-
 		if (!strncmp("power2", line + i, 6) && isspace(*(line + i + 6)))
 			dt->power2_major = line_maj;

@@ -249,9 +246,6 @@ const char *dev_subsystem_name(struct dev_types *dt, struct device *dev)
 	if (MAJOR(dev->dev) == dt->blkext_major)
 		return "BLKEXT";

-	if (MAJOR(dev->dev) == dt->loop_major)
-		return "LOOP";
-
 	return "";
 }

@@ -271,38 +265,6 @@ int major_is_scsi_device(struct dev_types *dt, int major)
 	return (dt->dev_type_array[major].flags & PARTITION_SCSI_DEVICE) ? 1 : 0;
 }

-
-static int _loop_is_with_partscan(struct device *dev)
-{
-	FILE *fp;
-	int partscan = 0;
-	char path[PATH_MAX];
-	char buffer[64];
-
-	if (dm_snprintf(path, sizeof(path), "%sdev/block/%d:%d/loop/partscan",
-			dm_sysfs_dir(),
-			(int) MAJOR(dev->dev),
-			(int) MINOR(dev->dev)) < 0) {
-		log_warn("Sysfs path for partscan is too long.");
-		return 0;
-	}
-
-	if (!(fp = fopen(path, "r")))
-		return 0; /* not there -> no partscan */
-
-	if (!fgets(buffer, sizeof(buffer), fp)) {
-		log_warn("Failed to read %s.", path);
-	} else if (sscanf(buffer, "%d", &partscan) != 1) {
-		log_warn("Failed to parse %s '%s'.", path, buffer);
-		partscan = 0;
-	}
-
-	if (fclose(fp))
-		log_sys_debug("fclose", path);
-
-	return partscan;
-}
-
 /* See linux/genhd.h and fs/partitions/msdos */
 #define PART_MAGIC 0xAA55
 #define PART_MAGIC_OFFSET UINT64_C(0x1FE)
@@ -332,11 +294,6 @@ static int _is_partitionable(struct dev_types *dt, struct device *dev)
 	if (MAJOR(dev->dev) == dt->md_major)
 		return 1;

-	/* All loop devices are partitionable via blkext (as of 3.2) */
-	if ((MAJOR(dev->dev) == dt->loop_major) &&
-	    _loop_is_with_partscan(dev))
-		return 1;
-
 	if ((parts <= 1) || (MINOR(dev->dev) % parts))
 		return 0;

@@ -976,100 +933,3 @@ int dev_is_rotational(struct dev_types *dt, struct device *dev)
 	return 1;
 }
 #endif
-
-#ifdef UDEV_SYNC_SUPPORT
-
-/*
- * Udev daemon usually has 30s timeout to process each event by default.
- * But still, that value can be changed in udev configuration and we
- * don't have libudev API to read the actual timeout value used.
- */
-
-/* FIXME: Is this long enough to wait for udev db to get initialized?
- *
- *        Take also into consideration that this check is done for each
- *        device that is scanned so we don't want to wait for a long time
- *        if there's something wrong with udev, e.g. timeouts! With current
- *        libudev API, we can't recognize whether the event processing has
- *        not finished yet and it's still being processed or whether it has
- *        failed already due to timeout in udev - in both cases the
- *        udev_device_get_is_initialized returns 0.
- */
-#define UDEV_DEV_IS_MPATH_COMPONENT_ITERATION_COUNT 100
-#define UDEV_DEV_IS_MPATH_COMPONENT_USLEEP 100000
-
-int udev_dev_is_mpath_component(struct device *dev)
-{
-	struct udev *udev_context = udev_get_library_context();
-	struct udev_device *udev_device = NULL;
-	const char *value;
-	int initialized = 0;
-	unsigned i = 0;
-	int ret = 0;
-
-	if (!udev_context) {
-		log_warn("WARNING: No udev context available to check if device %s is multipath component.", dev_name(dev));
-		return_0;
-	}
-
-	while (1) {
-		if (i >= UDEV_DEV_IS_MPATH_COMPONENT_ITERATION_COUNT)
-			break;
-
-		if (udev_device)
-			udev_device_unref(udev_device);
-
-		if (!(udev_device = udev_device_new_from_devnum(udev_context, 'b', dev->dev))) {
-			log_warn("WARNING: Failed to get udev device handler for device %s.", dev_name(dev));
-			return 0;
-		}
-
-#ifdef HAVE_LIBUDEV_UDEV_DEVICE_GET_IS_INITIALIZED
-		if ((initialized = udev_device_get_is_initialized(udev_device)))
-			break;
-#else
-		if ((initialized = (udev_device_get_property_value(udev_device, DEV_EXT_UDEV_DEVLINKS) != NULL)))
-			break;
-#endif
-
-		log_debug("Device %s not initialized in udev database (%u/%u, %u microseconds).", dev_name(dev),
-			   i + 1, UDEV_DEV_IS_MPATH_COMPONENT_ITERATION_COUNT,
-			   i * UDEV_DEV_IS_MPATH_COMPONENT_USLEEP);
-
-		usleep(UDEV_DEV_IS_MPATH_COMPONENT_USLEEP);
-		i++;
-	}
-
-	if (!initialized) {
-		log_warn("WARNING: Device %s not initialized in udev database even after waiting %u microseconds.",
-			  dev_name(dev), i * UDEV_DEV_IS_MPATH_COMPONENT_USLEEP);
-		goto out;
-	}
-
-	value = udev_device_get_property_value(udev_device, DEV_EXT_UDEV_BLKID_TYPE);
-	if (value && !strcmp(value, DEV_EXT_UDEV_BLKID_TYPE_MPATH)) {
-		log_debug("Device %s is multipath component based on blkid variable in udev db (%s=\"%s\").",
-			   dev_name(dev), DEV_EXT_UDEV_BLKID_TYPE, value);
-		ret = 1;
-		goto out;
-	}
-
-	value = udev_device_get_property_value(udev_device, DEV_EXT_UDEV_MPATH_DEVICE_PATH);
-	if (value && !strcmp(value, "1")) {
-		log_debug("Device %s is multipath component based on multipath variable in udev db (%s=\"%s\").",
-			   dev_name(dev), DEV_EXT_UDEV_MPATH_DEVICE_PATH, value);
-		ret = 1;
-		goto out;
-	}
-out:
-	udev_device_unref(udev_device);
-	return ret;
-}
-#else
-
-int udev_dev_is_mpath_component(struct device *dev)
-{
-	return 0;
-}
-
-#endif
--- a/lib/device/dev-type.h
+++ b/lib/device/dev-type.h
@@ -21,7 +21,9 @@
 #define NUMBER_OF_MAJORS 4096

 #ifdef __linux__
-#  include "kdev_t.h"
+#  define MAJOR(dev)	(((dev) & 0xfff00) >> 8)
+#  define MINOR(dev)	(((dev) & 0xff) | (((dev) >> 12) & 0xfff00))
+#  define MKDEV(ma,mi)	(((mi) & 0xff) | ((ma) << 8) | (((mi) & ~0xff) << 12))
 #else
 #  define MAJOR(x) major((x))
 #  define MINOR(x) minor((x))
@@ -43,7 +45,6 @@ struct dev_types {
 	int emcpower_major;
 	int power2_major;
 	int dasd_major;
-	int loop_major;
 	struct dev_type_def dev_type_array[NUMBER_OF_MAJORS];
 };

@@ -59,7 +60,6 @@ int dev_is_md(struct device *dev, uint64_t *sb);
 int dev_is_swap(struct device *dev, uint64_t *signature);
 int dev_is_luks(struct device *dev, uint64_t *signature);
 int dasd_is_cdl_formatted(struct device *dev);
-int udev_dev_is_mpath_component(struct device *dev);

 /* Signature wiping. */
 #define TYPE_LVM1_MEMBER	0x001
--- a/lib/device/device.h
+++ b/lib/device/device.h
@@ -30,7 +30,6 @@
 #define DEV_OPEN_FAILURE	0x00000080	/* Has last open failed? */
 #define DEV_USED_FOR_LV		0x00000100	/* Is device used for an LV */
 #define DEV_ASSUMED_FOR_LV	0x00000200	/* Is device assumed for an LV */
-#define DEV_NOT_O_NOATIME	0x00000400	/* Don't use O_NOATIME */

 /*
 * Support for external device info.
--- a/lib/display/display.c
+++ b/lib/display/display.c
@@ -121,29 +121,19 @@ const char *get_percent_string(percent_type_t def)
 	return _percent_types[def];
 }

-static const char *_lv_name(const struct logical_volume *lv)
-{
-	/* Never try to display names of the internal snapshot structures. */
-	if (lv_is_snapshot(lv))
-		return find_cow(lv)->name;
-
-	return lv->name;
-}
-
 const char *display_lvname(const struct logical_volume *lv)
 {
 	char *name;
-	const char *lv_name = _lv_name(lv);
 	int r;

 	if ((lv->vg->cmd->display_lvname_idx + NAME_LEN) >= sizeof((lv->vg->cmd->display_buffer)))
 		lv->vg->cmd->display_lvname_idx = 0;

 	name = lv->vg->cmd->display_buffer + lv->vg->cmd->display_lvname_idx;
-	r = dm_snprintf(name, NAME_LEN, "%s/%s", lv->vg->name, lv_name);
+	r = dm_snprintf(name, NAME_LEN, "%s/%s", lv->vg->name, lv->name);

 	if (r < 0) {
-		log_error("Full LV name \"%s/%s\" is too long.", lv->vg->name, lv_name);
+		log_error("Full LV name \"%s/%s\" is too long.", lv->vg->name, lv->name);
 		return NULL;
 	}

@@ -831,102 +821,50 @@ void display_name_error(name_error_t name_error)
 * Prompt for y or n from stdin.
 * Defaults to 'no' in silent mode.
 * All callers should support --yes and/or --force to override this.
- *
- * Accepted are either _yes[] or _no[] strings or just their outset.
- * When running without 'tty' stdin is printed to stderr.
- * 'Yes' is accepted ONLY with '\n'.
 */
 char yes_no_prompt(const char *prompt, ...)
 {
-	/* Lowercase Yes/No strings */
-	static const char _yes[] = "yes";
-	static const char _no[] = "no";
-	const char *answer = NULL;
-	int c = silent_mode() ? EOF : 0;
-	int i = 0, ret = 0, sig = 0;
-	char buf[12];
+	int c = 0, ret = 0, cb = 0;
 	va_list ap;

 	sigint_allow();
-
-	for (;;) {
-		if (!ret) {
-			/* Show prompt */
+	do {
+		if (c == '\n' || !c) {
 			va_start(ap, prompt);
 			vfprintf(stderr, prompt, ap);
 			va_end(ap);
 			fflush(stderr);
-
-			if (c == EOF)
+			if (silent_mode()) {
+				fputc('n', stderr);
+				ret = 'n';
 				break;
-
-			i = 0;
-			answer = NULL;
+			}
+			ret = 0;
 		}

-	nextchar:
-		if ((sig = sigint_caught()))
-			break;	/* Check if already interrupted before getchar() */
-
 		if ((c = getchar()) == EOF) {
-			/* SIGNAL or no chars on stdin (missing '\n') or ^D */
-			if (!i)
-				break; /* Just shown prompt,-> print [n]\n */
-
-			goto invalid; /* Note:  c holds EOF */
+			ret = 'n'; /* SIGINT */
+			cb = 1;
+			break;
 		}

-		if ((i < (sizeof(buf) - 4)) && isprint(c))
-			buf[i++] = c;
-
 		c = tolower(c);
-
-		if ((ret > 0) && (c == answer[0]))
-			answer++;	/* Matching, next char */
-		else if (c == '\n') {
-			if (feof(stdin))
-				fputc('\n', stderr);
-			if (ret > 0)
-				break;	/* Answered */
-	invalid:
-			if (i >= (sizeof(buf) - 4)) {
-				/* '...'  for missing input */
-				i = sizeof(buf) - 1;
-				buf[i - 1] = buf[i - 2] = buf[i - 3] = '.';
-			}
-			buf[i] = 0;
-			log_warn("WARNING: Invalid input '%s'.", buf);
-			ret = 0;	/* Otherwise refresh prompt */
-		} else if (!ret && (c == _yes[0])) {
-			ret = 'y';
-			answer = _yes + 1;	/* Expecting 'Yes' */
-		} else if (!ret && (c == _no[0])) {
-			ret = 'n';
-			answer = _no + 1;	/* Expecting 'No' */
-		} else if (!ret && isspace(c)) {
-			/* Ignore any whitespace before */
-			--i;
-			goto nextchar;
-		} else if ((ret > 0) && isspace(c)) {
-			/* Ignore any whitespace after */
-			while (*answer)
-				answer++; /* jump to end-of-word */
-		} else
-			ret = -1;	/* Read till '\n' and refresh */
-	}
+		if ((c == 'y') || (c == 'n')) {
+			/* If both 'y' and 'n' given, begin again. */
+			if (ret && c != ret)
+				ret = -1;
+			else
+				ret = c;
+		}
+	} while (ret < 1 || c != '\n');

 	sigint_restore();

-	/* For other then Yes answer check there is really no interrupt */
-	if (sig || sigint_caught()) {
-		stack;
-		ret = 'n';
-	} else if (c == EOF) {
-		fputs("[n]\n", stderr);
-		ret = 'n';
-	} else
-		/* Not knowing if it's terminal, makes this hard.... */
-		log_verbose("Accepted input: [%c]", ret);
+	if (cb && !sigint_caught())
+		fputc(ret, stderr);
+
+	if (c != '\n')
+		fputc('\n', stderr);

 	return ret;
 }
--- a/lib/filters/filter-internal.c
+++ b/lib/filters/filter-internal.c
@@ -1,81 +0,0 @@
-/*
- * Copyright (C) 2006 Red Hat, Inc. All rights reserved.
- *
- * This file is part of LVM2.
- *
- * 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 Lesser General Public License v.2.1.
- *
- * You should have received a copy of the GNU Lesser 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
- */
-
-#include "lib.h"
-#include "filter.h"
-
-static DM_LIST_INIT(_allow_devs);
-
-int internal_filter_allow(struct dm_pool *mem, struct device *dev)
-{
-	struct device_list *devl;
-
-	if (!(devl = dm_pool_alloc(mem, sizeof(*devl)))) {
-		log_error("device_list element allocation failed");
-		return 0;
-	}
-	devl->dev = dev;
-
-	dm_list_add(&_allow_devs, &devl->list);
-	return 1;
-}
-
-void internal_filter_clear(void)
-{
-	dm_list_init(&_allow_devs);
-}
-
-static int _passes_internal(struct dev_filter *f __attribute__((unused)),
-			    struct device *dev)
-{
-	struct device_list *devl;
-
-	if (!internal_filtering())
-		return 1;
-	
-	dm_list_iterate_items(devl, &_allow_devs) {
-		if (devl->dev == dev)
-			return 1;
-	}
-	
-	log_debug_devs("%s: Skipping for internal filtering.", dev_name(dev));
-	return 0;
-}
-
-static void _destroy(struct dev_filter *f)
-{
-	if (f->use_count)
-		log_error(INTERNAL_ERROR "Destroying internal filter while in use %u times.", f->use_count);
-
-	dm_free(f);
-}
-
-struct dev_filter *internal_filter_create(void)
-{
-	struct dev_filter *f;
-
-	if (!(f = dm_zalloc(sizeof(*f)))) {
-		log_error("md filter allocation failed");
-		return NULL;
-	}
-
-	f->passes_filter = _passes_internal;
-	f->destroy = _destroy;
-	f->use_count = 0;
-
-	log_debug_devs("internal filter initialised.");
-
-	return f;
-}
-
--- a/lib/filters/filter-persistent.c
+++ b/lib/filters/filter-persistent.c
@@ -129,8 +129,6 @@ int persistent_filter_load(struct dev_filter *f, struct dm_config_tree **cft_out
 	if (dm_hash_get_num_entries(pf->devices)) {
 		/* We populated dev_cache ourselves */
 		dev_cache_scan(0);
-		if (!dev_cache_index_devs())
-			stack;
 		r = 1;
 	}

--- a/lib/filters/filter-sysfs.c
+++ b/lib/filters/filter-sysfs.c
@@ -17,7 +17,6 @@

 #ifdef __linux__

-#include <sys/sysmacros.h>
 #include <dirent.h>

 static int _locate_sysfs_blocks(const char *sysfs_dir, char *path, size_t len,
--- a/lib/filters/filter.h
+++ b/lib/filters/filter.h
@@ -32,10 +32,6 @@ struct dev_filter *persistent_filter_create(struct dev_types *dt,
 					    const char *file);
 struct dev_filter *sysfs_filter_create(void);

-struct dev_filter *internal_filter_create(void);
-int internal_filter_allow(struct dm_pool *mem, struct device *dev);
-void internal_filter_clear(void);
-
 /*
 * patterns must be an array of strings of the form:
 * [ra]<sep><regex><sep>, eg,
--- a/lib/format_pool/disk_rep.c
+++ b/lib/format_pool/disk_rep.c
@@ -60,8 +60,7 @@ static void _add_pl_to_list(struct cmd_context *cmd, struct dm_list *head, struc
 		if (id_equal(&data->pv_uuid, &pl->pv_uuid)) {
 			char uuid[ID_LEN + 7] __attribute__((aligned(8)));

-			if (!id_write_format(&pl->pv_uuid, uuid, ID_LEN + 7))
-				stack;
+			id_write_format(&pl->pv_uuid, uuid, ID_LEN + 7);

 			if (!dev_subsystem_part_major(cmd->dev_types, data->dev)) {
 				log_very_verbose("Ignoring duplicate PV %s on "
@@ -91,13 +90,11 @@ int read_pool_label(struct pool_list *pl, struct labeller *l,
 	pool_label_in(pd, buf);

 	get_pool_pv_uuid(&pvid, pd);
-	if (!id_write_format(&pvid, uuid, ID_LEN + 7))
-		stack;
+	id_write_format(&pvid, uuid, ID_LEN + 7);
 	log_debug_metadata("Calculated uuid %s for %s", uuid, dev_name(dev));

 	get_pool_vg_uuid(&vgid, pd);
-	if (!id_write_format(&vgid, uuid, ID_LEN + 7))
-		stack;
+	id_write_format(&vgid, uuid, ID_LEN + 7);
 	log_debug_metadata("Calculated uuid %s for %s", uuid, pd->pl_pool_name);

 	if (!(info = lvmcache_add(l, (char *) &pvid, dev, pd->pl_pool_name,
--- a/lib/format_pool/import_export.c
+++ b/lib/format_pool/import_export.c
@@ -181,7 +181,7 @@ static int _add_stripe_seg(struct dm_pool *mem,
 	unsigned j;
 	uint32_t area_len;

-	if (!is_power_of_2(usp->striping)) {
+	if (usp->striping & (usp->striping - 1)) {
 		log_error("Stripe size must be a power of 2");
 		return 0;
 	}
--- a/lib/format_text/archiver.c
+++ b/lib/format_text/archiver.c
@@ -339,12 +339,7 @@ static int _restore_vg_should_write_pv(struct physical_volume *pv, int do_pvcrea
 	if (!(pv->fmt->features & FMT_PV_FLAGS))
 		return 0;

-	if (!pv->dev) {
-		log_error("Failed to find device for PV.");
-		return -1;
-	}
-
-	if (!(info = lvmcache_info_from_pvid(pv->dev->pvid, pv->dev, 0))) {
+	if (!(info = lvmcache_info_from_pvid(pv->dev->pvid, 0))) {
 		log_error("Failed to find cached info for PV %s.", pv_dev_name(pv));
 		return -1;
 	}
@@ -364,7 +359,9 @@ static int _restore_vg_should_write_pv(struct physical_volume *pv, int do_pvcrea

 /* ORPHAN and VG locks held before calling this */
 int backup_restore_vg(struct cmd_context *cmd, struct volume_group *vg,
-		      int do_pvcreate, struct pv_create_args *pva)
+		      int drop_lvmetad,
+		      int do_pvcreate,
+		      struct pv_create_args *pva)
 {
 	struct dm_list new_pvs;
 	struct pv_list *pvl, *new_pvl;
@@ -505,6 +502,16 @@ int backup_restore_vg(struct cmd_context *cmd, struct volume_group *vg,
 	if (!vg_write(vg))
 		return_0;

+	if (drop_lvmetad && lvmetad_active()) {
+		struct volume_group *vg_lvmetad = lvmetad_vg_lookup(cmd, vg->name, NULL);
+		if (vg_lvmetad) {
+			/* FIXME Cope with failure to update lvmetad */
+			if (!lvmetad_vg_remove(vg_lvmetad))
+				stack;
+			release_vg(vg_lvmetad);
+		}
+	}
+
 	if (!vg_commit(vg))
 		return_0;

@@ -543,7 +550,7 @@ int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name,

 	missing_pvs = vg_missing_pv_count(vg);
 	if (missing_pvs == 0)
-		r = backup_restore_vg(cmd, vg, 0, NULL);
+		r = backup_restore_vg(cmd, vg, 1, 0, NULL);
 	else
 		log_error("Cannot restore Volume Group %s with %i PVs "
 			  "marked as missing.", vg->name, missing_pvs);
--- a/lib/format_text/archiver.h
+++ b/lib/format_text/archiver.h
@@ -53,7 +53,9 @@ struct volume_group *backup_read_vg(struct cmd_context *cmd,
 				    const char *vg_name, const char *file);

 int backup_restore_vg(struct cmd_context *cmd, struct volume_group *vg,
-                      int do_pvcreate, struct pv_create_args *pva);
+                      int drop_lvmetad,
+                      int do_pvcreate,
+		      struct pv_create_args *pva);

 int backup_restore_from_file(struct cmd_context *cmd, const char *vg_name,
 			     const char *file, int force);
--- a/lib/format_text/export.c
+++ b/lib/format_text/export.c
@@ -621,7 +621,6 @@ int out_areas(struct formatter *f, const struct lv_segment *seg,
 			     (s == seg->area_count - 1) ? "" : ",");
 			break;
 		case AREA_LV:
-			/* FIXME This helper code should be target-independent! Check for metadata LV property. */
 			if (!(seg->status & RAID)) {
 				outf(f, "\"%s\", %u%s",
 				     seg_lv(seg, s)->name,
@@ -631,19 +630,15 @@ int out_areas(struct formatter *f, const struct lv_segment *seg,
 			}

 			/* RAID devices are laid-out in metadata/data pairs */
-			/* FIXME Validation should be elsewhere, not here! */
 			if (!lv_is_raid_image(seg_lv(seg, s)) ||
-			    (seg->meta_areas && seg_metalv(seg, s) && !lv_is_raid_metadata(seg_metalv(seg, s)))) {
+			    !lv_is_raid_metadata(seg_metalv(seg, s))) {
 				log_error("RAID segment has non-RAID areas");
 				return 0;
 			}

-			if (seg->meta_areas && seg_metalv(seg,s))
-				outf(f, "\"%s\", \"%s\"%s",
-				     (seg->meta_areas && seg_metalv(seg, s)) ? seg_metalv(seg, s)->name : "",
-				     seg_lv(seg, s)->name, (s == seg->area_count - 1) ? "" : ",");
-			else
-				outf(f, "\"%s\"%s", seg_lv(seg, s)->name, (s == seg->area_count - 1) ? "" : ",");
+			outf(f, "\"%s\", \"%s\"%s",
+			     seg_metalv(seg, s)->name, seg_lv(seg, s)->name,
+			     (s == seg->area_count - 1) ? "" : ",");

 			break;
 		case AREA_UNASSIGNED:
@@ -858,7 +853,7 @@ static int _print_historical_lv(struct formatter *f, struct historical_logical_v
 	if (!_alloc_printed_indirect_descendants(&hlv->indirect_glvs, &descendants_buffer))
 		goto_out;

-	outnlgo(f);
+	outnl(f);
 	outfgo(f, "%s {", hlv->name);
 	_inc_indent(f);

--- a/lib/format_text/format-text.c
+++ b/lib/format_text/format-text.c
@@ -453,7 +453,7 @@ static struct raw_locn *_find_vg_rlocn(struct device_area *dev_area,
 				   "not match expected name %s.", vgname);

      bad:
-	if ((info = lvmcache_info_from_pvid(dev_area->dev->pvid, dev_area->dev, 0)) &&
+	if ((info = lvmcache_info_from_pvid(dev_area->dev->pvid, 0)) &&
 	    !lvmcache_update_vgname_and_id(info, &vgsummary_orphan))
 		stack;

@@ -985,8 +985,8 @@ static int _vg_write_file(struct format_instance *fid __attribute__((unused)),
 	if (lvm_fclose(fp, tc->path_edit))
 		return_0;

-	log_debug_metadata("Renaming %s to %s", temp_file, tc->path_edit);
 	if (rename(temp_file, tc->path_edit)) {
+		log_debug_metadata("Renaming %s to %s", temp_file, tc->path_edit);
 		log_error("%s: rename to %s failed: %s", temp_file,
 			  tc->path_edit, strerror(errno));
 		return 0;
@@ -1153,6 +1153,7 @@ int vgname_from_mda(const struct format_type *fmt,
 	uint32_t wrap = 0;
 	unsigned int len = 0;
 	char buf[NAME_LEN + 1] __attribute__((aligned(8)));
+	char uuid[64] __attribute__((aligned(8)));
 	uint64_t buffer_size, current_usage;
 	unsigned used_cached_metadata = 0;

@@ -1209,7 +1210,7 @@ int vgname_from_mda(const struct format_type *fmt,
 		used_cached_metadata = 1;

 	/* FIXME 64-bit */
-	if (!text_vgsummary_import(fmt, dev_area->dev,
+	if (!text_vgname_import(fmt, dev_area->dev,
 				(off_t) (dev_area->start + rlocn->offset),
 				(uint32_t) (rlocn->size - wrap),
 				(off_t) (dev_area->start + MDA_HEADER_SIZE),
@@ -1221,14 +1222,16 @@ int vgname_from_mda(const struct format_type *fmt,
 	if (!validate_name(vgsummary->vgname))
 		return_0;

+	if (!id_write_format((struct id *)&vgsummary->vgid, uuid, sizeof(uuid)))
+		return_0;
+
 	log_debug_metadata("%s: %s metadata at %" PRIu64 " size %" PRIu64
 			   " (in area at %" PRIu64 " size %" PRIu64
-			   ") for %s (" FMTVGID ")",
+			   ") for %s (%s)",
 			   dev_name(dev_area->dev),
 			   used_cached_metadata ? "Using cached" : "Found",
 			   dev_area->start + rlocn->offset,
-			   rlocn->size, dev_area->start, dev_area->size, vgsummary->vgname,
-			   (char *)&vgsummary->vgid);
+			   rlocn->size, dev_area->start, dev_area->size, vgsummary->vgname, uuid);

 	if (mda_free_sectors) {
 		current_usage = (rlocn->size + SECTOR_SIZE - UINT64_C(1)) -
@@ -1447,7 +1450,7 @@ static int _text_pv_needs_rewrite(const struct format_type *fmt, struct physical
 	if (!pv->is_labelled)
 		return 1;

-	if (!(info = lvmcache_info_from_pvid((const char *)&pv->id, pv->dev, 0))) {
+	if (!(info = lvmcache_info_from_pvid((const char *)&pv->id, 0))) {
 		log_error("Failed to find cached info for PV %s.", pv_dev_name(pv));
 		return 0;
 	}
@@ -1525,11 +1528,11 @@ static int _text_pv_read(const struct format_type *fmt, const char *pv_name,
 	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter)))
 		return_0;

-	if (lvmetad_used()) {
-		info = lvmcache_info_from_pvid(dev->pvid, dev, 0);
+	if (lvmetad_active()) {
+		info = lvmcache_info_from_pvid(dev->pvid, 0);
 		if (!info && !lvmetad_pv_lookup_by_dev(fmt->cmd, dev, NULL))
 			return 0;
-		info = lvmcache_info_from_pvid(dev->pvid, dev, 0);
+		info = lvmcache_info_from_pvid(dev->pvid, 0);
 	} else {
 		struct label *label;
 		if (!(label_read(dev, &label, UINT64_C(0))))
@@ -1815,7 +1818,7 @@ static int _text_pv_setup(const struct format_type *fmt,
 	 */
 	else {
 		if (!pv->dev ||
-		    !(info = lvmcache_info_from_pvid(pv->dev->pvid, pv->dev, 0))) {
+		    !(info = lvmcache_info_from_pvid(pv->dev->pvid, 0))) {
 			log_error("PV %s missing from cache", pv_dev_name(pv));
 			return 0;
 		}
--- a/lib/format_text/import-export.h
+++ b/lib/format_text/import-export.h
@@ -51,9 +51,9 @@ struct text_vg_version_ops {
 					 unsigned allow_lvmetad_extensions);
 	void (*read_desc) (struct dm_pool * mem, const struct dm_config_tree *cf,
 			   time_t *when, char **desc);
-	int (*read_vgsummary) (const struct format_type *fmt,
-			       const struct dm_config_tree *cft,
-			       struct lvmcache_vgsummary *vgsummary);
+	int (*read_vgname) (const struct format_type *fmt,
+			    const struct dm_config_tree *cft,
+			    struct lvmcache_vgsummary *vgsummary);
 };

 struct text_vg_version_ops *text_vg_vsn1_init(void);
@@ -78,7 +78,7 @@ struct volume_group *text_vg_import_fd(struct format_instance *fid,
 				       uint32_t checksum,
 				       time_t *when, char **desc);

-int text_vgsummary_import(const struct format_type *fmt,
+int text_vgname_import(const struct format_type *fmt,
 		       struct device *dev,
 		       off_t offset, uint32_t size,
 		       off_t offset2, uint32_t size2,
--- a/lib/format_text/import.c
+++ b/lib/format_text/import.c
@@ -35,7 +35,7 @@ static void _init_text_import(void)
 /*
 * Find out vgname on a given device.
 */
-int text_vgsummary_import(const struct format_type *fmt,
+int text_vgname_import(const struct format_type *fmt,
 		       struct device *dev,
 		       off_t offset, uint32_t size,
 		       off_t offset2, uint32_t size2,
@@ -74,7 +74,7 @@ int text_vgsummary_import(const struct format_type *fmt,
 		if (!(*vsn)->check_version(cft))
 			continue;

-		if (!(*vsn)->read_vgsummary(fmt, cft, vgsummary))
+		if (!(*vsn)->read_vgname(fmt, cft, vgsummary))
 			goto_out;

 		r = 1;
--- a/lib/format_text/import_vsn1.c
+++ b/lib/format_text/import_vsn1.c
@@ -63,7 +63,7 @@ static int _vsn1_check_version(const struct dm_config_tree *cft)
 	const struct dm_config_value *cv;

 	// TODO if this is pvscan --cache, we want this check back.
-	if (lvmetad_used())
+	if (lvmetad_active())
 		return 1;

 	/*
@@ -241,8 +241,8 @@ static int _read_pv(struct format_instance *fid,
 		return 0;
 	}

-	/* TODO is the !lvmetad_used() too coarse here? */
-	if (!pv->dev && !lvmetad_used())
+	/* TODO is the !lvmetad_active() too coarse here? */
+	if (!pv->dev && !lvmetad_active())
 		pv->status |= MISSING_PV;

 	if ((pv->status & MISSING_PV) && pv->dev && pv_mda_used_count(pv) == 0) {
@@ -569,11 +569,8 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
 	if (!(lv->name = dm_pool_strdup(mem, lvn->key)))
 		return_0;

-	log_debug_metadata("Importing logical volume %s.", display_lvname(lv));
-
 	if (!(lvn = lvn->child)) {
-		log_error("Empty logical volume section for %s.",
-			  display_lvname(lv));
+		log_error("Empty logical volume section.");
 		return 0;
 	}

@@ -1232,16 +1229,12 @@ static void _read_desc(struct dm_pool *mem,
 }

 /*
+ * It would be more accurate to call this _read_vgsummary().
 * It is used to read vgsummary information about a VG
 * before locking and reading the VG via vg_read().
- * read_vgsummary: read VG metadata before VG is locked
- *                 and save the data in struct vgsummary
- * read_vg: read VG metadata after VG is locked
- *          and save the data in struct volume_group
- * FIXME: why are these separate?
 */
-static int _read_vgsummary(const struct format_type *fmt, const struct dm_config_tree *cft, 
-			   struct lvmcache_vgsummary *vgsummary)
+static int _read_vgname(const struct format_type *fmt, const struct dm_config_tree *cft, 
+			struct lvmcache_vgsummary *vgsummary)
 {
 	const struct dm_config_node *vgn;
 	struct dm_pool *mem = fmt->cmd->mem;
@@ -1292,7 +1285,7 @@ static struct text_vg_version_ops _vsn1_ops = {
 	.check_version = _vsn1_check_version,
 	.read_vg = _read_vg,
 	.read_desc = _read_desc,
-	.read_vgsummary = _read_vgsummary
+	.read_vgname = _read_vgname,
 };

 struct text_vg_version_ops *text_vg_vsn1_init(void)
--- a/lib/format_text/text_export.h
+++ b/lib/format_text/text_export.h
@@ -22,7 +22,6 @@
 #define outf(args...) do {if (!out_text(args)) return_0;} while (0)
 #define outfgo(args...) do {if (!out_text(args)) goto_out;} while (0)
 #define outnl(f) do {if (!out_newline(f)) return_0;} while (0)
-#define outnlgo(f) do {if (!out_newline(f)) goto_out;} while (0)

 struct formatter;
 struct lv_segment;
--- a/lib/label/label.c
+++ b/lib/label/label.c
@@ -184,7 +184,7 @@ static struct labeller *_find_labeller(struct device *dev, char *buf,

      out:
 	if (!found) {
-		if ((info = lvmcache_info_from_pvid(dev->pvid, dev, 0)))
+		if ((info = lvmcache_info_from_pvid(dev->pvid, 0)))
 			_update_lvmcache_orphan(info);
 		log_very_verbose("%s: No label detected", dev_name(dev));
 	}
@@ -271,18 +271,16 @@ int label_read(struct device *dev, struct label **result,
 	struct lvmcache_info *info;
 	int r = 0;

-	if ((info = lvmcache_info_from_pvid(dev->pvid, dev, 1))) {
-		log_debug_devs("Reading label from lvmcache for %s", dev_name(dev));
+	if ((info = lvmcache_info_from_pvid(dev->pvid, 1))) {
+		log_debug_devs("Using cached label for %s", dev_name(dev));
 		*result = lvmcache_get_label(info);
 		return 1;
 	}

-	log_debug_devs("Reading label from device %s", dev_name(dev));
-
 	if (!dev_open_readonly(dev)) {
 		stack;

-		if ((info = lvmcache_info_from_pvid(dev->pvid, dev, 0)))
+		if ((info = lvmcache_info_from_pvid(dev->pvid, 0)))
 			_update_lvmcache_orphan(info);

 		return r;
@@ -357,7 +355,7 @@ int label_verify(struct device *dev)
 	int r = 0;

 	if (!dev_open_readonly(dev)) {
-		if ((info = lvmcache_info_from_pvid(dev->pvid, dev, 0)))
+		if ((info = lvmcache_info_from_pvid(dev->pvid, 0)))
 			_update_lvmcache_orphan(info);
 		return_0;
 	}
--- a/lib/locking/file_locking.c
+++ b/lib/locking/file_locking.c
@@ -148,11 +148,13 @@ int init_file_locking(struct locking_type *locking, struct cmd_context *cmd,

 	/* Get lockfile directory from config file */
 	locking_dir = find_config_tree_str(cmd, global_locking_dir_CFG, NULL);
-	if (!dm_strncpy(_lock_dir, locking_dir, sizeof(_lock_dir))) {
+	if (strlen(locking_dir) >= sizeof(_lock_dir)) {
 		log_error("Path for locking_dir %s is invalid.", locking_dir);
 		return 0;
 	}

+	strcpy(_lock_dir, locking_dir);
+
 	(void) dm_prepare_selinux_context(_lock_dir, S_IFDIR);
 	r = dm_create_dir(_lock_dir);
 	(void) dm_prepare_selinux_context(NULL, 0);
--- a/lib/locking/locking.h
+++ b/lib/locking/locking.h
@@ -198,10 +198,8 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
 	rr; \
 })

-#define unlock_vg(cmd, vg, vol)	\
+#define unlock_vg(cmd, vol)	\
 	do { \
-		if (vg && !lvmetad_vg_update_finish(vg)) \
-			stack; \
 		if (is_real_vg(vol) && !sync_dev_names(cmd)) \
 			stack; \
 		if (!lock_vol(cmd, vol, LCK_VG_UNLOCK, NULL)) \
@@ -209,7 +207,7 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
 	} while (0)
 #define unlock_and_release_vg(cmd, vg, vol) \
 	do { \
-		unlock_vg(cmd, vg, vol); \
+		unlock_vg(cmd, vol); \
 		release_vg(vg); \
 	} while (0)

--- a/lib/locking/lvmlockd.c
+++ b/lib/locking/lvmlockd.c
@@ -367,16 +367,20 @@ static int _extend_sanlock_lv(struct cmd_context *cmd, struct volume_group *vg,
 {
 	struct logical_volume *lv = vg->sanlock_lv;
 	struct lvresize_params lp = {
+		.lv_name = vg->sanlock_lv->name,
 		.sign = SIGN_NONE,
-		.size = lv->size + ((extend_mb * 1024 * 1024) / SECTOR_SIZE),
 		.percent = PERCENT_NONE,
 		.resize = LV_EXTEND,
-		.force = 1,
+		.ac_force = 1,
+		.sizeargs = 1,
 	};

-	if (!lv_resize(lv, &lp, &vg->pvs)) {
-		log_error("Extend LV %s to size %s failed.",
-			  display_lvname(lv), display_size(cmd, lp.size));
+	lp.size = lv->size + ((extend_mb * 1024 * 1024) / SECTOR_SIZE);
+
+	if (!lv_resize_prepare(cmd, lv, &lp, &vg->pvs) ||
+	    !lv_resize(cmd, lv, &lp, &vg->pvs)) {
+		log_error("Extend LV %s/%s to size %llu failed.",
+			  vg->name, lv->name, (unsigned long long)lp.size);
 		return 0;
 	}

@@ -387,7 +391,7 @@ static int _extend_sanlock_lv(struct cmd_context *cmd, struct volume_group *vg,

 static int _refresh_sanlock_lv(struct cmd_context *cmd, struct volume_group *vg)
 {
-	if (!lv_refresh_suspend_resume(vg->sanlock_lv)) {
+	if (!lv_refresh_suspend_resume(cmd, vg->sanlock_lv)) {
 		log_error("Failed to refresh %s.", vg->sanlock_lv->name);
 		return 0;
 	}
@@ -969,7 +973,6 @@ int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_i
 {
 	char uuid[64] __attribute__((aligned(8)));
 	daemon_reply reply;
-	uint32_t lockd_flags = 0;
 	int host_id = 0;
 	int result;
 	int ret;
@@ -1019,16 +1022,13 @@ int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_i
 				"opts = %s", start_init ? "start_init" : "none",
 				NULL);

-	if (!_lockd_result(reply, &result, &lockd_flags)) {
+	if (!_lockd_result(reply, &result, NULL)) {
 		ret = 0;
 		result = -ELOCKD;
 	} else {
 		ret = (result < 0) ? 0 : 1;
 	}

-	if (lockd_flags & LD_RF_WARN_GL_REMOVED)
-		cmd->lockd_gl_removed = 1;
-
 	switch (result) {
 	case 0:
 		log_print_unless_silent("VG %s starting %s lockspace", vg->name, vg->lock_type);
@@ -1144,11 +1144,6 @@ int lockd_start_wait(struct cmd_context *cmd)

 	daemon_reply_destroy(reply);

-	if (cmd->lockd_gl_removed) {
-		log_error("Missing global lock: global lock was lost by removing a previous VG.");
-		log_error("To enable the global lock in another VG, see lvmlockctl --gl-enable.");
-	}
-
 	return ret;
 }

@@ -1565,12 +1560,6 @@ int lockd_gl(struct cmd_context *cmd, const char *def_mode, uint32_t flags)
 			goto allow;
 		}

-		if ((lockd_flags & LD_RF_NO_GL_LS) && (lockd_flags & LD_RF_WARN_GL_REMOVED)) {
-			log_warn("Skipping global lock: VG with global lock was removed");
-			force_cache_update = 1;
-			goto allow;
-		}
-
 		if ((lockd_flags & LD_RF_NO_GL_LS) || (lockd_flags & LD_RF_NO_LOCKSPACES)) {
 			log_warn("Skipping global lock: lockspace not found or started");
 			force_cache_update = 1;
@@ -1986,9 +1975,8 @@ int lockd_lv_name(struct cmd_context *cmd, struct volume_group *vg,
 		mode = def_mode;

 	if (mode && !strcmp(mode, "sh") && (flags & LDLV_MODE_NO_SH)) {
-		struct logical_volume *lv = find_lv(vg, lv_name);
-		log_error("Shared activation not compatible with LV type %s of %s/%s",
-			  lv ? lvseg_name(first_seg(lv)) : "", vg->name, lv_name);
+		log_error("Shared activation not compatible with LV type: %s/%s",
+			  vg->name, lv_name);
 		return 0;
 	}

--- a/lib/log/log.c
+++ b/lib/log/log.c
@@ -17,8 +17,6 @@
 #include "device.h"
 #include "memlock.h"
 #include "defaults.h"
-#include "report.h"
-#include "lvm-file.h"

 #include <stdio.h>
 #include <stdarg.h>
@@ -32,8 +30,6 @@ static struct dm_str_list _log_dev_alias;

 static int _syslog = 0;
 static int _log_to_file = 0;
-static uint64_t _log_file_max_lines = 0;
-static uint64_t _log_file_lines = 0;
 static int _log_direct = 0;
 static int _log_while_suspended = 0;
 static int _indent = 1;
@@ -51,163 +47,6 @@ static size_t _lvm_errmsg_size = 0;
 static size_t _lvm_errmsg_len = 0;
 #define MAX_ERRMSG_LEN (512 * 1024)  /* Max size of error buffer 512KB */

-static log_report_t _log_report = {
-	.report = NULL,
-	.context = LOG_REPORT_CONTEXT_NULL,
-	.object_type = LOG_REPORT_OBJECT_TYPE_NULL,
-	.object_id = NULL,
-	.object_name = NULL,
-	.object_group = NULL
-};
-
-#define LOG_STREAM_BUFFER_SIZE 4096
-
-struct log_stream_item {
-	FILE *stream;
-	char *buffer;
-};
-
-struct log_stream {
-	struct log_stream_item out;
-	struct log_stream_item err;
-	struct log_stream_item report;
-} _log_stream = {{NULL, NULL},
-		 {NULL, NULL},
-		 {NULL, NULL}};
-
-#define out_stream (_log_stream.out.stream ? : stdout)
-#define err_stream (_log_stream.err.stream ? : stderr)
-#define report_stream (_log_stream.report.stream ? : stdout)
-
-static int _set_custom_log_stream(struct log_stream_item *stream_item, int custom_fd)
-{
-	FILE *final_stream = NULL;
-	int flags;
-	int r = 1;
-
-	if (custom_fd < 0)
-		goto out;
-
-	if (is_valid_fd(custom_fd)) {
-		if ((flags = fcntl(custom_fd, F_GETFL)) > 0) {
-			if ((flags & O_ACCMODE) == O_RDONLY) {
-				log_error("File descriptor %d already open in read-only "
-					  "mode, expected write-only or read-write mode.",
-					   (int) custom_fd);
-				r = 0;
-				goto out;
-			}
-		}
-
-		if (custom_fd == STDIN_FILENO) {
-			log_error("Can't set standard input for log output.");
-			r = 0;
-			goto out;
-		}
-
-		if (custom_fd == STDOUT_FILENO) {
-			final_stream = stdout;
-			goto out;
-		}
-
-		if (custom_fd == STDERR_FILENO) {
-			final_stream = stderr;
-			goto out;
-		}
-	}
-
-	if (!(final_stream = fdopen(custom_fd, "w"))) {
-		log_error("Failed to open stream for file descriptor %d.",
-			  (int) custom_fd);
-		r = 0;
-		goto out;
-	}
-
-	if (!(stream_item->buffer = dm_malloc(LOG_STREAM_BUFFER_SIZE))) {
-		log_error("Failed to allocate buffer for stream on file "
-			  "descriptor %d.", (int) custom_fd);
-	} else {
-		if (setvbuf(final_stream, stream_item->buffer, _IOLBF, LOG_STREAM_BUFFER_SIZE)) {
-			log_sys_error("setvbuf", "");
-			dm_free(stream_item->buffer);
-			stream_item->buffer = NULL;
-		}
-	}
-out:
-	stream_item->stream = final_stream;
-	return r;
-}
-
-int init_custom_log_streams(struct custom_fds *custom_fds)
-{
-	return _set_custom_log_stream(&_log_stream.out, custom_fds->out) &&
-	       _set_custom_log_stream(&_log_stream.err, custom_fds->err) &&
-	       _set_custom_log_stream(&_log_stream.report, custom_fds->report);
-}
-
-static void _check_and_replace_standard_log_streams(FILE *old_stream, FILE *new_stream)
-{
-	if (_log_stream.out.stream == old_stream)
-		_log_stream.out.stream = new_stream;
-
-	if (_log_stream.err.stream == old_stream)
-		_log_stream.err.stream = new_stream;
-
-	if (_log_stream.report.stream == old_stream)
-		_log_stream.report.stream = new_stream;
-}
-
-/*
- * Close and reopen standard stream on file descriptor fd.
- */
-int reopen_standard_stream(FILE **stream, const char *mode)
-{
-	int fd, fd_copy, new_fd;
-	const char *name;
-	FILE *old_stream = *stream;
-	FILE *new_stream;
-
-	if (old_stream == stdin) {
-		fd = STDIN_FILENO;
-		name = "stdin";
-	} else if (old_stream == stdout) {
-		fd = STDOUT_FILENO;
-		name = "stdout";
-	} else if (old_stream == stderr) {
-		fd = STDERR_FILENO;
-		name = "stderr";
-	} else {
-		log_error(INTERNAL_ERROR "reopen_standard_stream called on non-standard stream");
-		return 0;
-	}
-
-	if ((fd_copy = dup(fd)) < 0) {
-		log_sys_error("dup", name);
-		return 0;
-	}
-
-	if (fclose(old_stream))
-		log_sys_error("fclose", name);
-
-	if ((new_fd = dup2(fd_copy, fd)) < 0)
-		log_sys_error("dup2", name);
-	else if (new_fd != fd)
-		log_error("dup2(%d, %d) returned %d", fd_copy, fd, new_fd);
-
-	if (close(fd_copy) < 0)
-		log_sys_error("close", name);
-
-	if (!(new_stream = fdopen(fd, mode))) {
-		log_sys_error("fdopen", name);
-		return 0;
-	}
-
-	_check_and_replace_standard_log_streams(old_stream, new_stream);
-
-	*stream = new_stream;
-	return 1;
-}
-
 void init_log_fn(lvm2_log_fn_t log_fn)
 {
 	_lvm2_log_fn = log_fn;
@@ -251,7 +90,7 @@ void init_log_file(const char *log_file, int append)
 			log_warn("WARNING: Cannot parse content of %s.", statfile);
 		} else {
 			if (dm_snprintf(_log_file_path, sizeof(_log_file_path),
-					"%s_%s_%d_%llu", log_file, env, pid, starttime) < 0) {
+					"%s_%s_%d_%lld", log_file, env, pid, starttime) < 0) {
 				log_warn("WARNING: Debug log file path is too long for epoch.");
 				_log_file_path[0] = '\0';
 			} else {
@@ -262,14 +101,6 @@ void init_log_file(const char *log_file, int append)

 		if (st && fclose(st))
 			log_sys_debug("fclose", statfile);
-
-		if ((env = getenv("LVM_LOG_FILE_MAX_LINES"))) {
-			if (sscanf(env, FMTu64, &_log_file_max_lines) != 1) {
-				log_warn("WARNING: Ignoring invalid LVM_LOG_MAX_LINES envvar \"%s\".", env);
-				_log_file_max_lines = 0;
-			}
-			_log_file_lines = 0;
-		}
 	}

 no_epoch:
@@ -356,10 +187,10 @@ void fin_log(void)
 	if (_log_to_file) {
 		if (dm_fclose(_log_file)) {
 			if (errno)
-			      fprintf(err_stream, "failed to write log file: %s\n",
+			      fprintf(stderr, "failed to write log file: %s\n",
 				      strerror(errno));
 			else
-			      fprintf(err_stream, "failed to write log file\n");
+			      fprintf(stderr, "failed to write log file\n");

 		}
 		_log_to_file = 0;
@@ -429,47 +260,8 @@ void reset_log_duplicated(void) {
 	}
 }

-static const char *_get_log_level_name(int use_stderr, int level)
-{
-	static const char *log_level_names[] = {"",      /* unassigned */
-						"",      /* unassigned */
-						"fatal", /* _LOG_FATAL */
-						"error", /* _LOG_ERROR */
-						"warn",  /* _LOG_WARN */
-						"notice",/* _LOG_NOTICE */
-						"info",  /* _LOG_INFO */
-						"debug"  /* _LOG_DEBUG */
-						};
-	if (level == _LOG_WARN && !use_stderr)
-		return "print";
-
-	return log_level_names[level];
-}
-
-const char *log_get_report_context_name(log_report_context_t context)
-{
-	static const char *log_context_names[LOG_REPORT_CONTEXT_COUNT] = {[LOG_REPORT_CONTEXT_NULL] = "",
-									  [LOG_REPORT_CONTEXT_SHELL] = "shell",
-									  [LOG_REPORT_CONTEXT_PROCESSING] = "processing"};
-	return log_context_names[context];
-}
-
-
-const char *log_get_report_object_type_name(log_report_object_type_t object_type)
-{
-	static const char *log_object_type_names[LOG_REPORT_OBJECT_TYPE_COUNT] = {[LOG_REPORT_OBJECT_TYPE_NULL] = "",
-										  [LOG_REPORT_OBJECT_TYPE_CMD] = "cmd",
-										  [LOG_REPORT_OBJECT_TYPE_ORPHAN] = "orphan",
-										  [LOG_REPORT_OBJECT_TYPE_PV] = "pv",
-										  [LOG_REPORT_OBJECT_TYPE_LABEL] = "label",
-										  [LOG_REPORT_OBJECT_TYPE_VG] = "vg",
-										  [LOG_REPORT_OBJECT_TYPE_LV] = "lv"};
-	return log_object_type_names[object_type];
-}
-
-__attribute__ ((format(printf, 5, 0)))
-static void _vprint_log(int level, const char *file, int line, int dm_errno_or_class,
-			const char *format, va_list orig_ap)
+void print_log(int level, const char *file, int line, int dm_errno_or_class,
+	       const char *format, ...)
 {
 	va_list ap;
 	char buf[1024], message[4096];
@@ -478,7 +270,6 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 	char *newbuf;
 	int use_stderr = level & _LOG_STDERR;
 	int log_once = level & _LOG_ONCE;
-	int log_bypass_report = level & _LOG_BYPASS_REPORT;
 	int fatal_internal_error = 0;
 	size_t msglen;
 	const char *indent_spaces = "";
@@ -486,10 +277,8 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 	static int _abort_on_internal_errors_env_present = -1;
 	static int _abort_on_internal_errors_env = 0;
 	char *env_str;
-	struct dm_report *orig_report;
-	int logged_via_report = 0;

-	level &= ~(_LOG_STDERR|_LOG_ONCE|_LOG_BYPASS_REPORT);
+	level &= ~(_LOG_STDERR|_LOG_ONCE);

 	if (_abort_on_internal_errors_env_present < 0) {
 		if ((env_str = getenv("DM_ABORT_ON_INTERNAL_ERRORS"))) {
@@ -520,17 +309,16 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c

 	if (_lvm2_log_fn ||
 	    (_store_errmsg && (level <= _LOG_ERR)) ||
-	    (_log_report.report && !log_bypass_report && (use_stderr || (level <=_LOG_WARN))) ||
 	    log_once) {
-		va_copy(ap, orig_ap);
+		va_start(ap, format);
 		n = vsnprintf(message, sizeof(message), trformat, ap);
 		va_end(ap);

 		/* When newer glibc returns >= sizeof(locn), we will just log what
                 * has fit into buffer, it's '\0' terminated string */
 		if (n < 0) {
-			fprintf(err_stream, _("vsnprintf failed: skipping external "
-					      "logging function"));
+			fprintf(stderr, _("vsnprintf failed: skipping external "
+					"logging function"));
 			goto log_it;
 		}
 	}
@@ -568,22 +356,6 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 		}
 	}

-	if (_log_report.report && !log_bypass_report && (use_stderr || (level <= _LOG_WARN))) {
-		orig_report = _log_report.report;
-		_log_report.report = NULL;
-		if (!report_cmdlog(orig_report, _get_log_level_name(use_stderr, level),
-				   log_get_report_context_name(_log_report.context),
-				   log_get_report_object_type_name(_log_report.object_type),
-				   _log_report.object_name, _log_report.object_id,
-				   _log_report.object_group, _log_report.object_group_id,
-				   message, _lvm_errno, 0))
-			fprintf(err_stream, _("failed to report cmdstatus"));
-		else
-			logged_via_report = 1;
-
-		_log_report.report = orig_report;
-	}
-
 	if (_lvm2_log_fn) {
 		_lvm2_log_fn(level, file, line, 0, message);
 		if (fatal_internal_error)
@@ -592,7 +364,7 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 	}

      log_it:
-	if (!logged_via_report && ((verbose_level() >= level) && !_log_suppress)) {
+	if ((verbose_level() >= level) && !_log_suppress) {
 		if (verbose_level() > _LOG_DEBUG) {
 			(void) dm_snprintf(buf, sizeof(buf), "#%s:%d ",
 					   file, line);
@@ -607,7 +379,7 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 			default: /* nothing to do */;
 			}

-		va_copy(ap, orig_ap);
+		va_start(ap, format);
 		switch (level) {
 		case _LOG_DEBUG:
 			if (verbose_level() < _LOG_DEBUG)
@@ -619,10 +391,10 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 				break;
 			/* fall through */
 		default:
-			/* Typically only log_warn goes to out_stream */
-			stream = (use_stderr || (level != _LOG_WARN)) ? err_stream : out_stream;
-			if (stream == err_stream)
-				fflush(out_stream);
+			/* Typically only log_warn goes to stdout */
+			stream = (use_stderr || (level != _LOG_WARN)) ? stderr : stdout;
+			if (stream == stderr)
+				fflush(stdout);
 			fprintf(stream, "%s%s%s%s", buf, log_command_name(),
 				_msg_prefix, indent_spaces);
 			vfprintf(stream, trformat, ap);
@@ -642,19 +414,16 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 		fprintf(_log_file, "%s:%d %s%s", file, line, log_command_name(),
 			_msg_prefix);

-		va_copy(ap, orig_ap);
+		va_start(ap, format);
 		vfprintf(_log_file, trformat, ap);
 		va_end(ap);

 		fputc('\n', _log_file);
 		fflush(_log_file);
-
-		if (_log_file_max_lines && ++_log_file_lines >= _log_file_max_lines)
-			fatal_internal_error = 1;
 	}

 	if (_syslog && (_log_while_suspended || !critical_section())) {
-		va_copy(ap, orig_ap);
+		va_start(ap, format);
 		vsyslog(level, trformat, ap);
 		va_end(ap);
 	}
@@ -674,7 +443,7 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c

 		bufused += n;		/* n does not include '\0' */

-		va_copy(ap, orig_ap);
+		va_start(ap, format);
 		n = vsnprintf(buf + bufused, sizeof(buf) - bufused,
 			      trformat, ap);
 		va_end(ap);
@@ -693,74 +462,3 @@ static void _vprint_log(int level, const char *file, int line, int dm_errno_or_c
 		_already_logging = 0;
 	}
 }
-
-void print_log(int level, const char *file, int line, int dm_errno_or_class,
-	       const char *format, ...)
-{
-	va_list ap;
-
-	va_start(ap, format);
-	_vprint_log(level, file, line, dm_errno_or_class, format, ap);
-	va_end(ap);
-}
-
-void print_log_libdm(int level, const char *file, int line, int dm_errno_or_class,
-		     const char *format, ...)
-{
-	FILE *orig_out_stream = out_stream;
-	va_list ap;
-
-	/*
-	 * Bypass report if printing output from libdm and if we have
-	 * LOG_WARN level and it's not going to stderr (so we're
-	 * printing common message that is not an error/warning).
-	*/
-	if (!(level & _LOG_STDERR) &&
-	    ((level & ~(_LOG_STDERR|_LOG_ONCE|_LOG_BYPASS_REPORT)) == _LOG_WARN))
-		level |= _LOG_BYPASS_REPORT;
-
-	_log_stream.out.stream = report_stream;
-
-	va_start(ap, format);
-	_vprint_log(level, file, line, dm_errno_or_class, format, ap);
-	va_end(ap);
-
-	_log_stream.out.stream = orig_out_stream;
-}
-
-log_report_t log_get_report_state(void)
-{
-	return _log_report;
-}
-
-void log_restore_report_state(log_report_t log_report)
-{
-	_log_report = log_report;
-}
-
-void log_set_report(struct dm_report *report)
-{
-	_log_report.report = report;
-}
-
-void log_set_report_context(log_report_context_t context)
-{
-	_log_report.context = context;
-}
-
-void log_set_report_object_type(log_report_object_type_t object_type)
-{
-	_log_report.object_type = object_type;
-}
-
-void log_set_report_object_group_and_group_id(const char *group, const char *id)
-{
-	_log_report.object_group = group;
-	_log_report.object_group_id = id;
-}
-
-void log_set_report_object_name_and_id(const char *name, const char *id)
-{
-	_log_report.object_name = name;
-	_log_report.object_id = id;
-}
--- a/lib/log/log.h
+++ b/lib/log/log.h
@@ -41,16 +41,15 @@

 #define EUNCLASSIFIED -1	/* Generic error code */

-#define _LOG_FATAL         0x0002
-#define _LOG_ERR           0x0003
-#define _LOG_WARN          0x0004
-#define _LOG_NOTICE        0x0005
-#define _LOG_INFO          0x0006
-#define _LOG_DEBUG         0x0007
-#define _LOG_STDERR        0x0080 /* force things to go to stderr, even if loglevel would make them go to stdout */
-#define _LOG_ONCE          0x0100 /* downgrade to NOTICE if this has been already logged */
-#define _LOG_BYPASS_REPORT 0x0200 /* do not log through report even if report available */
-
+#define _LOG_STDERR 128 /* force things to go to stderr, even if loglevel
+			   would make them go to stdout */
+#define _LOG_ONCE 256 /* downgrade to NOTICE if this has been already logged */
+#define _LOG_DEBUG 7
+#define _LOG_INFO 6
+#define _LOG_NOTICE 5
+#define _LOG_WARN 4
+#define _LOG_ERR 3
+#define _LOG_FATAL 2
 #define INTERNAL_ERROR "Internal error: "

 /*
--- a/lib/log/lvm-logging.h
+++ b/lib/log/lvm-logging.h
@@ -16,16 +16,10 @@
 #ifndef _LVM_LOGGING_H
 #define _LVM_LOGGING_H

-#include "lvm-file.h"
-
 __attribute__ ((format(printf, 5, 6)))
 void print_log(int level, const char *file, int line, int dm_errno_or_class,
 	       const char *format, ...);

-__attribute__ ((format(printf, 5, 6)))
-void print_log_libdm(int level, const char *file, int line, int dm_errno_or_class,
-		     const char *format, ...);
-
 #define LOG_LINE(l, x...) \
    print_log(l, __FILE__, __LINE__ , 0, ## x)

@@ -37,9 +31,6 @@ void print_log_libdm(int level, const char *file, int line, int dm_errno_or_clas

 #include "log.h"

-int init_custom_log_streams(struct custom_fds *custom_fds);
-int reopen_standard_stream(FILE **stream, const char *mode);
-
 typedef void (*lvm2_log_fn_t) (int level, const char *file, int line,
 			       int dm_errno_or_class, const char *message);

@@ -74,49 +65,4 @@ int log_suppress(int suppress);
 /* Suppress messages to syslog */
 void syslog_suppress(int suppress);

-/* Hooks to handle logging through report. */
-typedef enum {
-	LOG_REPORT_CONTEXT_NULL,
-	LOG_REPORT_CONTEXT_SHELL,
-	LOG_REPORT_CONTEXT_PROCESSING,
-	LOG_REPORT_CONTEXT_COUNT
-} log_report_context_t;
-
-typedef enum {
-	LOG_REPORT_OBJECT_TYPE_NULL,
-	LOG_REPORT_OBJECT_TYPE_CMD,
-	LOG_REPORT_OBJECT_TYPE_ORPHAN,
-	LOG_REPORT_OBJECT_TYPE_PV,
-	LOG_REPORT_OBJECT_TYPE_LABEL,
-	LOG_REPORT_OBJECT_TYPE_VG,
-	LOG_REPORT_OBJECT_TYPE_LV,
-	LOG_REPORT_OBJECT_TYPE_COUNT
-} log_report_object_type_t;
-
-typedef struct log_report {
-	struct dm_report *report;
-	log_report_context_t context;
-	log_report_object_type_t object_type;
-	const char *object_name;
-	const char *object_id;
-	const char *object_group;
-	const char *object_group_id;
-} log_report_t;
-
-#define LOG_STATUS_NAME "status"
-#define LOG_STATUS_SUCCESS "success"
-#define LOG_STATUS_FAILURE "failure"
-
-log_report_t log_get_report_state(void);
-void log_restore_report_state(log_report_t log_report);
-
-void log_set_report(struct dm_report *report);
-void log_set_report_context(log_report_context_t context);
-void log_set_report_object_type(log_report_object_type_t object_type);
-void log_set_report_object_group_and_group_id(const char *group, const char *group_id);
-void log_set_report_object_name_and_id(const char *name, const char *id);
-
-const char *log_get_report_context_name(log_report_context_t context);
-const char *log_get_report_object_type_name(log_report_object_type_t object_type);
-
 #endif
--- a/lib/metadata/cache_manip.c
+++ b/lib/metadata/cache_manip.c
@@ -29,91 +29,77 @@
 #define DM_HINT_OVERHEAD_PER_BLOCK	8  /* bytes */
 #define DM_MAX_HINT_WIDTH		(4+16)  /* bytes.  FIXME Configurable? */

-const char *display_cache_mode(const struct lv_segment *seg)
+int cache_mode_is_set(const struct lv_segment *seg)
 {
 	if (seg_is_cache(seg))
 		seg = first_seg(seg->pool_lv);

-	if (!seg_is_cache_pool(seg) ||
-	    (seg->cache_mode == CACHE_MODE_UNDEFINED))
-		return "";
-
-	return get_cache_mode_name(seg);
+	return (seg->feature_flags & (DM_CACHE_FEATURE_WRITEBACK |
+				      DM_CACHE_FEATURE_WRITETHROUGH |
+				      DM_CACHE_FEATURE_PASSTHROUGH)) ? 1 : 0;
 }

-
-const char *get_cache_mode_name(const struct lv_segment *pool_seg)
+const char *get_cache_mode_name(const struct lv_segment *seg)
 {
-	switch (pool_seg->cache_mode) {
-	default:
-		log_error(INTERNAL_ERROR "Cache pool %s has undefined cache mode, using writethrough instead.",
-			  display_lvname(pool_seg->lv));
-		/* Fall through */
-	case CACHE_MODE_WRITETHROUGH:
-		return "writethrough";
-	case CACHE_MODE_WRITEBACK:
+	if (seg->feature_flags & DM_CACHE_FEATURE_WRITEBACK)
 		return "writeback";
-	case CACHE_MODE_PASSTHROUGH:
+
+	if (seg->feature_flags & DM_CACHE_FEATURE_WRITETHROUGH)
+		return "writethrough";
+
+	if (seg->feature_flags & DM_CACHE_FEATURE_PASSTHROUGH)
 		return "passthrough";
-	}
+
+	log_error(INTERNAL_ERROR "LV %s has uknown feature flags %" PRIu64 ".",
+		  display_lvname(seg->lv), seg->feature_flags);
+
+	return NULL;
 }

-int set_cache_mode(cache_mode_t *mode, const char *cache_mode)
-{
-	if (!strcasecmp(cache_mode, "writethrough"))
-		*mode = CACHE_MODE_WRITETHROUGH;
-	else if (!strcasecmp(cache_mode, "writeback"))
-		*mode = CACHE_MODE_WRITEBACK;
-	else if (!strcasecmp(cache_mode, "passthrough"))
-		*mode = CACHE_MODE_PASSTHROUGH;
-	else {
-		log_error("Unknown cache mode: %s.", cache_mode);
-		return 0;
-	}
-
-	return 1;
-}
-
-int cache_set_cache_mode(struct lv_segment *seg, cache_mode_t mode)
+int cache_set_mode(struct lv_segment *seg, const char *str)
 {
 	struct cmd_context *cmd = seg->lv->vg->cmd;
-	const char *str;
 	int id;
+	uint64_t mode;
+
+	if (!str && !seg_is_cache(seg))
+		return 1;			/* Defaults only for cache */

 	if (seg_is_cache(seg))
 		seg = first_seg(seg->pool_lv);
-	else if (seg_is_cache_pool(seg)) {
-		if (mode == CACHE_MODE_UNDEFINED)
-			return 1;	/* Defaults only for cache */
-	} else {
-		log_error(INTERNAL_ERROR "Cannot set cache mode for non cache volume %s.",
-			  display_lvname(seg->lv));
+
+	if (!str) {
+		if (cache_mode_is_set(seg))
+			return 1;               /* Default already set in cache pool */
+
+		id = allocation_cache_mode_CFG;
+
+		/* If present, check backward compatible settings */
+		if (!find_config_node(cmd, cmd->cft, id) &&
+		    find_config_node(cmd, cmd->cft, allocation_cache_pool_cachemode_CFG))
+			id = allocation_cache_pool_cachemode_CFG;
+
+		if (!(str = find_config_tree_str(cmd, id, NULL))) {
+			log_error(INTERNAL_ERROR "Cache mode is not determined.");
+			return 0;
+		}
+	}
+
+	if (!strcmp(str, "writeback"))
+		mode = DM_CACHE_FEATURE_WRITEBACK;
+	else if (!strcmp(str, "writethrough"))
+		mode = DM_CACHE_FEATURE_WRITETHROUGH;
+	else if (!strcmp(str, "passthrough"))
+		mode = DM_CACHE_FEATURE_PASSTHROUGH;
+	else {
+		log_error("Cannot set unknown cache mode \"%s\".", str);
 		return 0;
 	}

-	if (mode != CACHE_MODE_UNDEFINED) {
-		seg->cache_mode = mode;
-		return 1;
-	}
-
-	if (seg->cache_mode != CACHE_MODE_UNDEFINED)
-		return 1;               /* Default already set in cache pool */
-
-	/* Figure default settings from config/profiles */
-	id = allocation_cache_mode_CFG;
-
-	/* If present, check backward compatible settings */
-	if (!find_config_node(cmd, cmd->cft, id) &&
-	    find_config_node(cmd, cmd->cft, allocation_cache_pool_cachemode_CFG))
-		id = allocation_cache_pool_cachemode_CFG;
-
-	if (!(str = find_config_tree_str(cmd, id, NULL))) {
-		log_error(INTERNAL_ERROR "Cache mode is not determined.");
-		return 0;
-	}
-
-	if (!(set_cache_mode(&seg->cache_mode, str)))
-		return_0;
+	seg->feature_flags &= ~(DM_CACHE_FEATURE_WRITEBACK |
+				DM_CACHE_FEATURE_WRITETHROUGH |
+				DM_CACHE_FEATURE_PASSTHROUGH);
+	seg->feature_flags |= mode;

 	return 1;
 }
@@ -126,7 +112,7 @@ void cache_check_for_warns(const struct lv_segment *seg)
 	struct logical_volume *origin_lv = seg_lv(seg, 0);

 	if (lv_is_raid(origin_lv) &&
-	    first_seg(seg->pool_lv)->cache_mode == CACHE_MODE_WRITEBACK)
+	    first_seg(seg->pool_lv)->feature_flags & DM_CACHE_FEATURE_WRITEBACK)
 		log_warn("WARNING: Data redundancy is lost with writeback "
 			 "caching of raid logical volume!");

@@ -135,23 +121,6 @@ void cache_check_for_warns(const struct lv_segment *seg)
 			 "resized and require manual uncache before resize!");
 }

-/*
- * Returns minimum size of cache metadata volume for give  data and chunk size
- * (all values in sector)
- * Default meta size is: (Overhead + mapping size + hint size)
- */
-static uint64_t _cache_min_metadata_size(uint64_t data_size, uint32_t chunk_size)
-{
-	uint64_t min_meta_size;
-
-	min_meta_size = data_size / chunk_size;		/* nr_chunks */
-	min_meta_size *= (DM_BYTES_PER_BLOCK + DM_MAX_HINT_WIDTH + DM_HINT_OVERHEAD_PER_BLOCK);
-	min_meta_size = (min_meta_size + (SECTOR_SIZE - 1)) >> SECTOR_SHIFT;	/* in sectors */
-	min_meta_size += DM_TRANSACTION_OVERHEAD * (1024 >> SECTOR_SHIFT);
-
-	return min_meta_size;
-}
-
 int update_cache_pool_params(const struct segment_type *segtype,
 			     struct volume_group *vg, unsigned attr,
 			     int passed_args, uint32_t pool_data_extents,
@@ -160,46 +129,22 @@ int update_cache_pool_params(const struct segment_type *segtype,
 {
 	uint64_t min_meta_size;
 	uint32_t extent_size = vg->extent_size;
-	uint64_t pool_metadata_size = (uint64_t) *pool_metadata_extents * extent_size;
-	uint64_t pool_data_size = (uint64_t) pool_data_extents * extent_size;
-	uint64_t max_chunks =
-		get_default_allocation_cache_pool_max_chunks_CFG(vg->cmd, vg->profile);
-	/* min chunk size in a multiple of DM_CACHE_MIN_DATA_BLOCK_SIZE */
-	uint64_t min_chunk_size = (((pool_data_size + max_chunks - 1) / max_chunks +
-				    DM_CACHE_MIN_DATA_BLOCK_SIZE - 1) /
-				   DM_CACHE_MIN_DATA_BLOCK_SIZE) * DM_CACHE_MIN_DATA_BLOCK_SIZE;
+	uint64_t pool_metadata_size = (uint64_t) *pool_metadata_extents * vg->extent_size;

-	if (!(passed_args & PASS_ARG_CHUNK_SIZE)) {
+	if (!(passed_args & PASS_ARG_CHUNK_SIZE))
 		*chunk_size = DEFAULT_CACHE_POOL_CHUNK_SIZE * 2;
-		if (*chunk_size < min_chunk_size) {
-			/*
-			 * When using more then 'standard' default,
-			 * keep user informed he might be using things in untintended direction
-			 */
-			log_print_unless_silent("Using %s chunk size instead of default %s, "
-						"so cache pool has less then " FMTu64 " chunks.",
-						display_size(vg->cmd, min_chunk_size),
-						display_size(vg->cmd, *chunk_size),
-						max_chunks);
-			*chunk_size = min_chunk_size;
-		} else
-			log_verbose("Setting chunk size to %s.",
-				    display_size(vg->cmd, *chunk_size));
-	} else if (*chunk_size < min_chunk_size) {
-		log_error("Chunk size %s is less then required minimal chunk size %s "
-			  "for a cache pool of %s size and limit " FMTu64 " chunks.",
-			  display_size(vg->cmd, *chunk_size),
-			  display_size(vg->cmd, min_chunk_size),
-			  display_size(vg->cmd, pool_data_size),
-			  max_chunks);
-		log_error("To allow use of more chunks, see setting allocation/cache_pool_max_chunks.");
-		return 0;
-	}

 	if (!validate_pool_chunk_size(vg->cmd, segtype, *chunk_size))
 		return_0;

-	min_meta_size = _cache_min_metadata_size((uint64_t) pool_data_extents * extent_size, *chunk_size);
+	/*
+	 * Default meta size is:
+	 * (Overhead + mapping size + hint size)
+	 */
+	min_meta_size = (uint64_t) pool_data_extents * extent_size / *chunk_size;	/* nr_chunks */
+	min_meta_size *= (DM_BYTES_PER_BLOCK + DM_MAX_HINT_WIDTH + DM_HINT_OVERHEAD_PER_BLOCK);
+	min_meta_size = (min_meta_size + (SECTOR_SIZE - 1)) >> SECTOR_SHIFT;	/* in sectors */
+	min_meta_size += DM_TRANSACTION_OVERHEAD * (1024 >> SECTOR_SHIFT);

 	/* Round up to extent size */
 	if (min_meta_size % extent_size)
@@ -229,46 +174,6 @@ int update_cache_pool_params(const struct segment_type *segtype,
 	return 1;
 }

-/*
- * Validate if existing cache-pool can be used with given chunk size
- * i.e. cache-pool metadata size fits all info.
- */
-int validate_lv_cache_chunk_size(struct logical_volume *pool_lv, uint32_t chunk_size)
-{
-	struct volume_group *vg = pool_lv->vg;
-	uint64_t max_chunks = get_default_allocation_cache_pool_max_chunks_CFG(vg->cmd, vg->profile);
-	uint64_t min_size = _cache_min_metadata_size(pool_lv->size, chunk_size);
-	uint64_t chunks = pool_lv->size / chunk_size;
-	int r = 1;
-
-	if (min_size > first_seg(pool_lv)->metadata_lv->size) {
-		log_error("Cannot use chunk size %s with cache pool %s metadata size %s.",
-			  display_size(vg->cmd, chunk_size),
-			  display_lvname(pool_lv),
-			  display_size(vg->cmd, first_seg(pool_lv)->metadata_lv->size));
-		log_error("Minimal size for cache pool %s metadata with chunk size %s would be %s.",
-			  display_lvname(pool_lv),
-			  display_size(vg->cmd, chunk_size),
-			  display_size(vg->cmd, min_size));
-		r = 0;
-	}
-
-	if (chunks > max_chunks) {
-		log_error("Cannot use too small chunk size %s with cache pool %s data volume size %s.",
-			  display_size(vg->cmd, chunk_size),
-			  display_lvname(pool_lv),
-			  display_size(pool_lv->vg->cmd, pool_lv->size));
-		log_error("Maximum configured chunks for a cache pool is " FMTu64 ".",
-			  max_chunks);
-		log_error("Use smaller cache pool (<%s) or bigger cache chunk size (>=%s) or enable higher "
-			  "values in 'allocation/cache_pool_max_chunks'.",
-			  display_size(vg->cmd, chunk_size * max_chunks),
-			  display_size(vg->cmd, pool_lv->size / max_chunks));
-		r = 0;
-	}
-
-	return r;
-}
 /*
 * Validate arguments for converting origin into cached volume with given cache pool.
 *
@@ -374,73 +279,6 @@ struct logical_volume *lv_cache_create(struct logical_volume *pool_lv,
 	return cache_lv;
 }

-/*
- * Checks cache status and loops until there are not dirty blocks
- * Set 1 to *is_clean when there are no dirty blocks on return.
- */
-int lv_cache_wait_for_clean(struct logical_volume *cache_lv, int *is_clean)
-{
-	const struct logical_volume *lock_lv = lv_lock_holder(cache_lv);
-	struct lv_segment *cache_seg = first_seg(cache_lv);
-	struct lv_status_cache *status;
-	int cleaner_policy;
-	uint64_t dirty_blocks;
-
-	*is_clean = 0;
-
-	//FIXME: use polling to do this...
-	for (;;) {
-		if (!lv_cache_status(cache_lv, &status))
-			return_0;
-
-		if (status->cache->fail) {
-			dm_pool_destroy(status->mem);
-			log_warn("WARNING: Skippping flush for failed cache %s.",
-				 display_lvname(cache_lv));
-			return 1;
-		}
-
-		cleaner_policy = !strcmp(status->cache->policy_name, "cleaner");
-		dirty_blocks = status->cache->dirty_blocks;
-
-		/* No clear policy and writeback mode means dirty */
-		if (!cleaner_policy &&
-		    (status->cache->feature_flags & DM_CACHE_FEATURE_WRITEBACK))
-			dirty_blocks++;
-		dm_pool_destroy(status->mem);
-
-		if (!dirty_blocks)
-			break;
-
-		log_print_unless_silent("Flushing " FMTu64 " blocks for cache %s.",
-					dirty_blocks, display_lvname(cache_lv));
-		if (cleaner_policy) {
-			/* TODO: Use centralized place */
-			usleep(500000);
-			continue;
-		}
-
-		/* Switch to cleaner policy to flush the cache */
-		cache_seg->cleaner_policy = 1;
-		/* Reaload kernel with "cleaner" policy */
-		if (!lv_update_and_reload_origin(cache_lv))
-			return_0;
-	}
-
-	/*
-	 * TODO: add check if extra suspend resume is necessary
-	 * ATM this is workaround for missing cache sync when cache gets clean
-	 */
-	if (1) {
-		if (!lv_refresh_suspend_resume(lock_lv))
-			return_0;
-	}
-
-	cache_seg->cleaner_policy = 0;
-	*is_clean = 1;
-
-	return 1;
-}
 /*
 * lv_cache_remove
 * @cache_lv
@@ -454,10 +292,12 @@ int lv_cache_wait_for_clean(struct logical_volume *cache_lv, int *is_clean)
 */
 int lv_cache_remove(struct logical_volume *cache_lv)
 {
+	int is_cleaner;
+	uint64_t dirty_blocks;
 	struct lv_segment *cache_seg = first_seg(cache_lv);
 	struct logical_volume *corigin_lv;
 	struct logical_volume *cache_pool_lv;
-	int is_clear;
+	struct lv_status_cache *status;

 	if (!lv_is_cache(cache_lv)) {
 		log_error(INTERNAL_ERROR "LV %s is not cache volume.",
@@ -475,15 +315,12 @@ int lv_cache_remove(struct logical_volume *cache_lv)
 	if (!lv_is_active_locally(cache_lv)) {
 		/* Give up any remote locks */
 		if (!deactivate_lv(cache_lv->vg->cmd, cache_lv)) {
-			log_error("Cannot deactivate remotely active cache volume %s.",
-				  display_lvname(cache_lv));
+			log_error("Cannot deactivate remotely active cache lv.");
 			return 0;
 		}
-
-		switch (first_seg(cache_seg->pool_lv)->cache_mode) {
-		case CACHE_MODE_WRITETHROUGH:
-		case CACHE_MODE_PASSTHROUGH:
-			/* For inactive pass/writethrough just drop cache layer */
+		/* For inactive writethrough just drop cache layer */
+		if (first_seg(cache_seg->pool_lv)->feature_flags &
+		    DM_CACHE_FEATURE_WRITETHROUGH) {
 			corigin_lv = seg_lv(cache_seg, 0);
 			if (!detach_pool_lv(cache_seg))
 				return_0;
@@ -492,17 +329,17 @@ int lv_cache_remove(struct logical_volume *cache_lv)
 			if (!lv_remove(corigin_lv))
 				return_0;
 			return 1;
-		default:
-			/* Otherwise localy activate volume to sync dirty blocks */
-			cache_lv->status |= LV_TEMPORARY;
-			if (!activate_lv_excl_local(cache_lv->vg->cmd, cache_lv) ||
-			    !lv_is_active_locally(cache_lv)) {
-				log_error("Failed to active cache locally %s.",
-					  display_lvname(cache_lv));
-				return 0;
-			}
-			cache_lv->status &= ~LV_TEMPORARY;
 		}
+
+		/* Otherwise localy active volume is need to sync dirty blocks */
+		cache_lv->status |= LV_TEMPORARY;
+		if (!activate_lv_excl_local(cache_lv->vg->cmd, cache_lv) ||
+		    !lv_is_active_locally(cache_lv)) {
+			log_error("Failed to active cache locally %s.",
+				  display_lvname(cache_lv));
+			return 0;
+		}
+		cache_lv->status &= ~LV_TEMPORARY;
 	}

 	/*
@@ -520,8 +357,45 @@ int lv_cache_remove(struct logical_volume *cache_lv)
 	 * remove the cache_pool then without waiting for the flush to
 	 * complete.
 	 */
-	if (!lv_cache_wait_for_clean(cache_lv, &is_clear))
+	if (!lv_cache_status(cache_lv, &status))
 		return_0;
+	if (!status->cache->fail) {
+		is_cleaner = !strcmp(status->cache->policy_name, "cleaner");
+		dirty_blocks = status->cache->dirty_blocks;
+		if (!(status->cache->feature_flags & DM_CACHE_FEATURE_WRITETHROUGH))
+			dirty_blocks++; /* Not writethrough - always dirty */
+	} else {
+		log_warn("WARNING: Skippping flush for failed cache.");
+		is_cleaner = 0;
+		dirty_blocks = 0;
+	}
+	dm_pool_destroy(status->mem);
+
+	if (dirty_blocks && !is_cleaner) {
+		/* Switch to cleaner policy to flush the cache */
+		log_print_unless_silent("Flushing cache for %s.", cache_lv->name);
+		cache_seg->cleaner_policy = 1;
+		/* update the kernel to put the cleaner policy in place */
+		if (!lv_update_and_reload_origin(cache_lv))
+			return_0;
+	}
+
+	//FIXME: use polling to do this...
+	while (dirty_blocks) {
+		if (!lv_cache_status(cache_lv, &status))
+			return_0;
+		if (status->cache->fail) {
+			log_warn("WARNING: Flushing of failing cache skipped.");
+			break;
+		}
+		dirty_blocks = status->cache->dirty_blocks;
+		dm_pool_destroy(status->mem);
+		if (dirty_blocks) {
+			log_print_unless_silent(FMTu64 " blocks must still be flushed.",
+						dirty_blocks);
+			sleep(1);
+		}
+	}

 	cache_pool_lv = cache_seg->pool_lv;
 	if (!detach_pool_lv(cache_seg))
@@ -551,7 +425,6 @@ int lv_cache_remove(struct logical_volume *cache_lv)

 	if (!(cache_seg->areas = dm_pool_zalloc(cache_lv->vg->vgmem, sizeof(*cache_seg->areas))))
 		return_0;
-
 	if (!set_lv_segment_area_lv(cache_seg, 0, cache_lv, 0, 0))
 		return_0;

@@ -713,40 +586,6 @@ out:
 	return r;
 }

-/*
- * Universal 'wrapper' function  do-it-all
- * to update all commonly specified cache parameters
- */
-int cache_set_params(struct lv_segment *seg,
-		     cache_mode_t mode,
-		     const char *policy_name,
-		     const struct dm_config_tree *policy_settings,
-		     uint32_t chunk_size)
-{
-	struct lv_segment *pool_seg;
-
-	if (!cache_set_cache_mode(seg, mode))
-		return_0;
-
-	if (!cache_set_policy(seg, policy_name, policy_settings))
-		return_0;
-
-	pool_seg = seg_is_cache(seg) ? first_seg(seg->pool_lv) : seg;
-
-	if (chunk_size) {
-		if (!validate_lv_cache_chunk_size(pool_seg->lv, chunk_size))
-			return_0;
-		pool_seg->chunk_size = chunk_size;
-	} else {
-		/* TODO: some calc_policy solution for cache ? */
-		if (!recalculate_pool_chunk_size_with_dev_hints(pool_seg->lv, 0,
-								THIN_CHUNK_SIZE_CALC_METHOD_GENERIC))
-			return_0;
-	}
-
-	return 1;
-}
-
 /*
 * Wipe cache pool metadata area before use.
 *
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Marian Csontos	58baffde05	WIP: Diagnostics	2016-03-23 15:50:46 +01:00
Marian Csontos	8d24736bb9	[WIP] Session bus is still not working	2016-03-23 12:28:24 +01:00
Marian Csontos	0d33cd4ac9	[WIP] More verbose...	2016-03-23 12:28:24 +01:00
Marian Csontos	9d59ac9906	test: Allow using DBus session bus When session bus does not exist create one and kill it afterwards.	2016-03-23 12:27:34 +01:00