dm-integrity support

Create a linear LV with a dm-integrity layer added
above it.  The dm-integrity layer stores checksums
of the data written to the LV, and returns an error
if data read from the LV does not match the previously
saved checksum.

lvcreate --type integrity --integrity String [options]

The --integrity String specifies if the dm-integrity
metadata (checksums) should be interleaved with data
blocks, or written to a separate external LV:

  --integrity external (default)
  Store integrity metadata on a separate LV.
  Allows removing integrity from the LV later.

  --integrity internal
  Store integrity metadata interleaved with data
  on the same LV.  Around 1% of the LV size will
  be used for integrity metadata.

  --integrity y
  Enable default integrity settings (external).

Command variations:

lvcreate --type integrity -n Name -L Size VG
  [Uses integrity external, the default.]

lvcreate --integrity external -n Name -L Size VG
  [Uses type integrity, which is implied.]

lvcreate --integrity y -n Name -L Size VG
  [Uses integrity external, the default, and
   uses type integrity, which is implied.]

lvcreate --integrity internal -n Name -L Size VG
  [Uses type integrity, which is implied.]

lvconvert --integrity none|n LV
  [Removes external integrity.]

Options:

  --integritymetadata LV
  Use the specified LV for external metadata.
  Allows specific device placement of metadata.
  Without this option, the command creates a
  hidden LV (with an _imeta suffix) to hold the
  metadata.

  --integritysettings String
  set dm-integrity parameters, e.g. to use a journal
  instead of bitmap, --integritysettings "mode=J".

Example:

$ lvcreate --integrity external -n lvex -L1G vg
$ lvs -a vg
  LV           VG Attr       LSize  Origin
  lvex         vg -wi-a-----  1.00g [lvex_iorig]
  [lvex_imeta] vg -wi-ao---- 12.00m
  [lvex_iorig] vg -wi-ao----  1.00g

$ lvcreate --integrity internal -n lvin -L1G vg
$ lvs -a vg
  LV           VG Attr       LSize Origin
  lvin         vg -wi-a----- 1.00g [lvin_iorig]
  [lvin_iorig] vg -wi-ao---- 1.00g

Zeroing:

After a new integrity LV is created, zeroes are written to
the entire LV to initialize integrity metadata (checksums).
Without this initialization, the LV will return read errors
for any unwritten (and uninitialized) data.

A large LV may take a long time to zero.  The -Zn option can
be used to disable the whole-LV zeroing, or the lvcreate
command can be canceled while zeroing the new LV.  In either
case, the user may write to the entire LV to initialize the
integrity metadata themselves.

.gitignore

@@ -25,17 +25,25 @@ make.tmpl
 
 /autom4te.cache/
 /autoscan.log
+/build/
+/config.cache
 /config.log
 /config.status
 /configure.scan
 /cscope.out
+/html/
+/reports/
 /tags
 /tmp/
 
+coverity/coverity_model.xml
 
 tools/man-generator
 tools/man-generator.c
 
+test/.lib-dir-stamp
+test/.tests-stamp
+test/lib/dmsecuretest
 test/lib/lvchange
 test/lib/lvconvert
 test/lib/lvcreate
@@ -60,6 +68,7 @@ test/lib/pvremove
 test/lib/pvresize
 test/lib/pvs
 test/lib/pvscan
+test/lib/securetest
 test/lib/vgcfgbackup
 test/lib/vgcfgrestore
 test/lib/vgchange

COPYING.BSD

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2014, Red Hat, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Makefile.in

@@ -43,16 +43,22 @@ DISTCLEAN_TARGETS += config.cache config.log config.status make.tmpl
 
 include make.tmpl
 
+include $(top_srcdir)/base/Makefile
+include $(top_srcdir)/device_mapper/Makefile
+include $(top_srcdir)/test/unit/Makefile
+
 libdm: include
 libdaemon: include
-lib: libdm libdaemon
+lib: libdaemon $(BASE_TARGET) $(DEVICE_MAPPER_TARGET)
 daemons: lib libdaemon tools
-tools: lib libdaemon device-mapper
+scripts: lib
+tools: lib libdaemon
 po: tools daemons
 man: tools
 all_man: tools
 scripts: libdm
 test: tools daemons
+unit-test  run-unit-test: test
 
 lib.device-mapper: include.device-mapper
 libdm.device-mapper: include.device-mapper
@@ -148,18 +154,8 @@ install_all_man:
 install_tmpfiles_configuration:
 	$(MAKE) -C scripts install_tmpfiles_configuration
 
-LCOV_TRACES = libdm.info lib.info tools.info \
-	libdaemon/client.info libdaemon/server.info \
-	test/unit.info \
-	daemons/clvmd.info \
-	daemons/dmeventd.info \
-	daemons/lvmlockd.info \
-	daemons/lvmpolld.info
-
-CLEAN_TARGETS += $(LCOV_TRACES)
-
 ifneq ("$(LCOV)", "")
-.PHONY: lcov-reset lcov lcov-dated $(LCOV_TRACES)
+.PHONY: lcov-reset lcov lcov-dated
 
 ifeq ($(MAKECMDGOALS),lcov-dated)
 LCOV_REPORTS_DIR := lcov_reports-$(shell date +%Y%m%d%k%M%S)
@@ -169,35 +165,22 @@ LCOV_REPORTS_DIR := lcov_reports
 endif
 
 lcov-reset:
-	$(LCOV) --zerocounters $(addprefix -d , $(basename $(LCOV_TRACES)))
-
-# maybe use subdirs processing to create tracefiles...
-$(LCOV_TRACES):
-	$(LCOV) -b $(basename $@) -d $(basename $@) \
-		--ignore-errors source -c -o - | $(SED) \
-		-e "s/\(dmeventd_lvm.[ch]\)/plugins\/lvm2\/\1/" \
-		-e "s/dmeventd_\(mirror\|snapshot\|thin\|raid\)\.c/plugins\/\1\/dmeventd_\1\.c/" \
-		>$@
+	$(LCOV) --zerocounters --directory $(top_builddir)
 
 ifneq ("$(GENHTML)", "")
-lcov: $(LCOV_TRACES)
-	$(RM) -r $(LCOV_REPORTS_DIR)
+lcov:
+	$(RM) -rf $(LCOV_REPORTS_DIR)
 	$(MKDIR_P) $(LCOV_REPORTS_DIR)
-	for i in $(LCOV_TRACES); do \
-		test -s $$i -a $$(wc -w <$$i) -ge 100 && lc="$$lc $$i"; \
-	done; \
-	test -z "$$lc" || $(GENHTML) -p @abs_top_builddir@ \
-		-o $(LCOV_REPORTS_DIR) $$lc
+	$(LCOV) --capture --directory $(top_builddir) --ignore-errors source \
+		--output-file $(LCOV_REPORTS_DIR)/out.info
+	-test ! -s $(LCOV_REPORTS_DIR)/out.info || \
+		$(GENHTML) -o $(LCOV_REPORTS_DIR) --ignore-errors source \
+		$(LCOV_REPORTS_DIR)/out.info
 endif
 
 endif
 
-# FIXME: Drop once top-level make is resolved
--include test/unit/Makefile
-include $(top_srcdir)/device_mapper/Makefile
-include $(top_srcdir)/base/Makefile
-
-ifneq ($(shell which ctags),)
+ifneq ($(shell which ctags 2>/dev/null),)
 .PHONY: tags
 tags:
 	test -z "$(shell find $(top_srcdir) -type f -name '*.[ch]' -newer tags 2>/dev/null | head -1)" || $(RM) tags

README

@@ -1,5 +1,8 @@
 This tree contains the LVM2 and device-mapper tools and libraries.
 
+This is development branch, for stable 2.02 release see 2018-06-01-stable
+branch.
+
 For more information about LVM2 read the changelog in the WHATS_NEW file.
 Installation instructions are in INSTALL.
 

VERSION

@@ -1 +1 @@
-2.02.178(2)-git (2018-05-24)
+2.03.07(2)-git (2019-10-23)

VERSION_DM

@@ -1 +1 @@
-1.02.147-git (2018-05-24)
+1.02.167-git (2019-10-23)

WHATS_NEW

@@ -1,5 +1,115 @@
-Version 3.0.0
-=============
+Version 2.03.07 - 
+===================================
+  Fix resize of thin-pool with data and metadata of different segtype.
+  Improve mirror type leg splitting.
+  Fix activation order when removing merged snapshot.
+  Experimental VDO support for lvmdbusd.
+
+Version 2.03.06 - 23rd October 2019
+===================================
+  Add _cpool suffix to cache-pool LV name when used by caching LV.
+  No longer store extra UUID for cmeta and cdata cachevol layer.
+  Enhance activation of cache devices with cachevols.
+  Add _cvol in list of protected suffixes and start use it with DM UUID.
+  Rename LV converted to cachevol to use _cvol suffix.
+  Use normal LVs for wiping of cachevols.
+  Reload cleanered cache DM only with cleaner policy.
+  Fix cmd return when zeroing of cachevol fails.
+  Extend lvs to show all VDO properties.
+  Preserve VDO write policy with vdopool.
+  Increase default vdo bio threads to 4.
+  Continue report when cache_status fails.
+  Add support for DM_DEVICE_GET_TARGET_VERSION into device_mapper.
+  Fix cmirrord usage of header files from device_mapper subdir.
+  Allow standalone activation of VDO pool just like for thin-pools.
+  Activate thin-pool layered volume as 'read-only' device.
+  Ignore crypto devices with UUID signature CRYPT-SUBDEV.
+  Enhance validation for thin and cache pool conversion and swapping.
+  Improve internal removal of cached devices.
+  Synchronize with udev when dropping snapshot.
+  Add missing device synchronization point before removing pvmove node.
+  Correctly set read_ahead for LVs when pvmove is finished.
+  Remove unsupported OPTIONS+="event_timeout" udev rule from 11-dm-lvm.rules.
+  Prevent creating VGs with PVs with different logical block sizes.
+  Fix metadata writes from corrupting with large physical block size.
+
+Version 2.03.05 - 15th June 2019
+================================
+  Fix command definition for pvchange -a.
+  Add vgck --updatemetadata command that will repair metadata problems.
+  Improve VG reading to work if one good copy of metadata is found.
+  Report/display/scan commands that read VGs will no longer write/repair.
+  Move metadata repairs from VG reading to VG writing.
+  Add config setting md_component_checks to control MD component checks.
+  Add end of device MD component checks when dev has no udev info.
+
+Version 2.03.04 - 10th June 2019
+================================
+  Remove unused_duplicate_devs from cmd causing segfault in dmeventd.
+
+Version 2.03.03 - 07th June 2019
+================================
+  Report no_discard_passdown for cache LVs with lvs -o+kernel_discards.
+  Add pvck --dump option to extract metadata.
+  Fix signal delivery checking race in libdaemon (lvmetad).
+  Add missing Before=shutdown.target to LVM2 services to fix shutdown ordering.
+  Skip autoactivation for a PV when PV size does not match device size.
+  Remove first-pvscan-initialization which should no longer be needed.
+  Add remote refresh through lvmlockd/dlm for shared LVs after lvextend.
+  Ignore foreign and shared PVs for pvscan online files.
+  Add config setting to control fields in debug file and verbose output.
+  Add command[pid] and timestamp to debug file and verbose output.
+  Fix missing growth of _pmsmare volume when extending _tmeta volume.
+  Automatically grow thin metadata, when thin data gets too big.
+  Add synchronization with udev before removing cached devices.
+  Add support for caching VDO LVs and VDOPOOL LVs.
+  Add support for vgsplit with cached devices.
+  Query mpath device only once per command for its state.
+  Use device INFO instead of STATUS when checking for mpath device uuid.
+  Change default io_memory_size from 4 to 8 MiB.
+  Add config setting io_memory_size to set bcache size.
+  Fix pvscan autoactivation for concurrent pvscans.
+  Change scan_lvs default to 0 so LVs are not scanned for PVs.
+  Thin-pool selects power-of-2 chunk size by default.
+  Cache selects power-of-2 chunk size by default.
+  Support reszing for VDOPoolLV and VDOLV.
+  Improve -lXXX%VG modifier which improves cache segment estimation.
+  Ensure migration_threshold for cache is at least 8 chunks.
+  Restore missing man info lvcreate --zero for thin-pools.
+  Drop misleadning comment for metadata minimum_io_size for VDO segment.
+  Add device hints to reduce scanning.
+  Introduce LVM_SUPPRESS_SYSLOG to suppress syslog usage by generator.
+  Fix generator quering lvmconfig unpresent config option.
+  Fix memleak on bcache error path code.
+  Fix missing unlock on lvm2 dmeventd plugin error path initialization.
+  Improve Makefile dependency tracking.
+  Move VDO support towards V2 target (6.2) support.
+
+Version 2.03.02 - 18th December 2018
+====================================
+  Fix missing proper initialization of pv_list struct when adding pv.
+  Fix (de)activation of RaidLVs with visible SubLVs.
+  Prohibit mirrored 'mirror' log via lvcreate and lvconvert.
+  Use sync io if async io_setup fails, or use_aio=0 is set in config.
+  Fix more issues reported by coverity scan.
+
+Version 2.03.01 - 31st October 2018
+===================================
+
+Version 2.03.00 - 10th October 2018
+===================================
+  Add hot fix to avoiding locking collision when monitoring thin-pools.
+  Allow raid4 -> linear conversion request.
+  Fix lvconvert striped/raid0/raid0_meta -> raid6 regression.
+  Add 'lvm2-activation-generator:' prefix for kmsg messages logged by generator.
+  Add After=rbdmap.service to {lvm2-activation-net,blk-availability}.service.
+  Reduce max concurrent aios to avoid EMFILE with many devices.
+  Fix lvconvert conversion attempts to linear.
+  Fix lvconvert raid0/raid0_meta -> striped regression.
+  Fix lvconvert --splitmirror for mirror type (2.02.178).
+  Do not pair cache policy and cache metadata format.
+  lvconvert: reject conversions on raid1 LVs with split tracked SubLVs
+  lvconvert: reject conversions on raid1 split tracked SubLVs
   Add basic creation support for VDO target.
   Never send any discard ioctl with test mode.
   Fix thin-pool alloc which needs same PV for data and metadata.
@@ -12,6 +122,7 @@ Version 3.0.0
   Avoid showing internal error in lvs output or pvmoved LVs.
   Remove clvmd
   Remove lvmlib (api)
+  Remove lvmetad
   lvconvert: provide possible layouts between linear and striped/raid
   Use versionsort to fix archive file expiry beyond 100000 files.
 

WHATS_NEW_DM

@@ -1,7 +1,51 @@
-Version 1.02.147 -
+Version 1.02.167 - 
 ====================================
+
+Version 1.02.165 - 23rd October 2019
+====================================
+  Add support for DM_DEVICE_GET_TARGET_VERSION.
+  Add debug of dmsetup udevcomplete with hexa print DM_COOKIE_COMPLETED.
+  Fix versioning of dm_stats_create_region and dm_stats_create_region.
+
+Version 1.02.163 - 15th June 2019
+=================================
+
+Version 1.02.161 - 10th June 2019
+=================================
+
+Version 1.02.159 - 07th June 2019
+=================================
+  Parsing of cache status understand no_discard_passdown.
+  Ensure migration_threshold for cache is at least 8 chunks.
+
+Version 1.02.155 - 18th December 2018
+=====================================
+  Include correct internal header inside libdm list.c.
+  Enhance ioctl flattening and add parameters only when needed.
+  Add DM_DEVICE_ARM_POLL for API completness matching kernel.
+  Do not add parameters for RESUME with DM_DEVICE_CREATE dm task.
+  Fix dmstats report printing no output.
+
+Version 1.02.153 - 31st October 2018
+====================================
+
+Version 1.02.151 - 10th October 2018
+====================================
+  Add hot fix to avoiding locking collision when monitoring thin-pools.
+
+Version 1.02.150 - 01 August 2018
+=================================
   Add vdo plugin for monitoring VDO devices.
 
+Version 1.02.149 - 19th July 2018
+=================================
+
+Version 1.02.148 - 18th June 2018
+=================================
+
+Version 1.02.147 - 13th June 2018
+=================================
+
 Version 1.02.147-rc1 - 24th May 2018
 ====================================
   Reuse uname() result for mirror target.

base/Makefile

@@ -10,22 +10,31 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
+# Uncomment this to build the simple radix tree.  You'll need to make clean too.
+# Comment to build the advanced radix tree.
+#base/data-struct/radix-tree.o: CFLAGS += -DSIMPLE_RADIX_TREE
+
+# NOTE: this Makefile only works as 'include' for toplevel Makefile
+#       which defined all top_* variables
+
 BASE_SOURCE=\
-	base/data-struct/radix-tree.c \
 	base/data-struct/hash.c \
-	base/data-struct/list.c
+	base/data-struct/list.c \
+	base/data-struct/radix-tree.c
 
-BASE_DEPENDS=$(addprefix $(top_builddir)/,$(subst .c,.d,$(BASE_SOURCE)))
-BASE_OBJECTS=$(addprefix $(top_builddir)/,$(subst .c,.o,$(BASE_SOURCE)))
-CLEAN_TARGETS+=$(BASE_DEPENDS) $(BASE_OBJECTS)
+BASE_TARGET = base/libbase.a
+BASE_DEPENDS = $(BASE_SOURCE:%.c=%.d)
+BASE_OBJECTS = $(BASE_SOURCE:%.c=%.o)
+CLEAN_TARGETS += $(BASE_DEPENDS) $(BASE_OBJECTS) \
+	$(BASE_SOURCE:%.c=%.gcda) \
+	$(BASE_SOURCE:%.c=%.gcno) \
+	$(BASE_TARGET)
 
--include $(BASE_DEPENDS)
-
-$(BASE_OBJECTS): INCLUDES+=-I$(top_srcdir)/base/
-
-$(top_builddir)/base/libbase.a: $(BASE_OBJECTS)
+$(BASE_TARGET): $(BASE_OBJECTS)
 	@echo "    [AR] $@"
 	$(Q) $(RM) $@
 	$(Q) $(AR) rsv $@ $(BASE_OBJECTS) > /dev/null
 
-CLEAN_TARGETS+=$(top_builddir)/base/libbase.a
+ifeq ("$(DEPENDS)","yes")
+-include $(BASE_DEPENDS)
+endif

base/data-struct/radix-tree-simple.c

@@ -0,0 +1,256 @@
+// Copyright (C) 2018 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 "radix-tree.h"
+
+#include "base/memory/container_of.h"
+#include "base/memory/zalloc.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+//----------------------------------------------------------------
+// This implementation is based around nested binary trees.  Very
+// simple (and hopefully correct).
+
+struct node {
+	struct node *left;
+	struct node *right;
+
+	uint8_t key;
+	struct node *center;
+
+	bool has_value;
+	union radix_value value;
+};
+
+struct radix_tree {
+	radix_value_dtr dtr;
+	void *dtr_context;
+
+	struct node *root;
+};
+
+struct radix_tree *
+radix_tree_create(radix_value_dtr dtr, void *dtr_context)
+{
+	struct radix_tree *rt = zalloc(sizeof(*rt));
+
+	if (rt) {
+		rt->dtr = dtr;
+		rt->dtr_context = dtr_context;
+	}
+
+	return rt;
+}
+
+// Returns the number of entries in the tree
+static unsigned _destroy_tree(struct node *n, radix_value_dtr dtr, void *context)
+{
+	unsigned r;
+
+	if (!n)
+		return 0;
+
+	r = _destroy_tree(n->left, dtr, context);
+	r += _destroy_tree(n->right, dtr, context);
+	r += _destroy_tree(n->center, dtr, context);
+
+	if (n->has_value) {
+		if (dtr)
+			dtr(context, n->value);
+		r++;
+	}
+
+	free(n);
+
+	return r;
+}
+
+void radix_tree_destroy(struct radix_tree *rt)
+{
+	_destroy_tree(rt->root, rt->dtr, rt->dtr_context);
+	free(rt);
+}
+
+static unsigned _count(struct node *n)
+{
+	unsigned r;
+
+	if (!n)
+		return 0;
+
+	r = _count(n->left);
+	r += _count(n->right);
+	r += _count(n->center);
+
+	if (n->has_value)
+		r++;
+
+	return r;
+}
+
+unsigned radix_tree_size(struct radix_tree *rt)
+{
+	return _count(rt->root);
+}
+
+static struct node **_lookup(struct node **pn, uint8_t *kb, uint8_t *ke)
+{
+	struct node *n = *pn;
+
+	if (!n || (kb == ke))
+		return pn;
+
+	if (*kb < n->key)
+		return _lookup(&n->left, kb, ke);
+
+	else if (*kb > n->key)
+		return _lookup(&n->right, kb, ke);
+
+	else
+		return _lookup(&n->center, kb + 1, ke);
+}
+
+static bool _insert(struct node **pn, uint8_t *kb, uint8_t *ke, union radix_value v)
+{
+	struct node *n = *pn;
+
+	if (!n) {
+		n = zalloc(sizeof(*n));
+		if (!n)
+			return false;
+
+		n->key = *kb;
+		*pn = n;
+	}
+
+	if (kb == ke) {
+		n->has_value = true;
+		n->value = v;
+		return true;
+	}
+
+	if (*kb < n->key)
+		return _insert(&n->left, kb, ke, v);
+
+	else if (*kb > n->key)
+		return _insert(&n->right, kb, ke, v);
+
+	else
+		return _insert(&n->center, kb + 1, ke, v);
+}
+
+bool radix_tree_insert(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value v)
+{
+	return _insert(&rt->root, kb, ke, v);
+}
+
+bool radix_tree_remove(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
+{
+	struct node **pn = _lookup(&rt->root, kb, ke);
+	struct node *n = *pn;
+
+	if (!n || !n->has_value)
+		return false;
+
+	else {
+		if (rt->dtr)
+			rt->dtr(rt->dtr_context, n->value);
+
+		if (n->left || n->center || n->right) {
+			n->has_value = false;
+			return true;
+
+		} else {
+			// FIXME: delete parent if this was the last entry
+			free(n);
+			*pn = NULL;
+		}
+
+		return true;
+	}
+}
+
+unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
+{
+	struct node **pn;
+	unsigned count;
+
+	pn = _lookup(&rt->root, kb, ke);
+
+	if (*pn) {
+		count = _destroy_tree(*pn, rt->dtr, rt->dtr_context);
+		*pn = NULL;
+	}
+
+	return count;
+}
+
+bool
+radix_tree_lookup(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value *result)
+{
+	struct node **pn = _lookup(&rt->root, kb, ke);
+	struct node *n = *pn;
+
+	if (n && n->has_value) {
+		*result = n->value;
+		return true;
+	} else
+		return false;
+}
+
+static void _iterate(struct node *n, struct radix_tree_iterator *it)
+{
+	if (!n)
+		return;
+
+	_iterate(n->left, it);
+
+	if (n->has_value)
+		// FIXME: fill out the key
+		it->visit(it, NULL, NULL, n->value);
+
+	_iterate(n->center, it);
+	_iterate(n->right, it);
+}
+
+void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+                        struct radix_tree_iterator *it)
+{
+	if (kb == ke)
+		_iterate(rt->root, it);
+
+	else {
+		struct node **pn = _lookup(&rt->root, kb, ke);
+		struct node *n = *pn;
+
+		if (n) {
+			if (n->has_value)
+				it->visit(it, NULL, NULL, n->value);
+			_iterate(n->center, it);
+		}
+	}
+}
+
+bool radix_tree_is_well_formed(struct radix_tree *rt)
+{
+	return true;
+}
+
+void radix_tree_dump(struct radix_tree *rt, FILE *out)
+{
+}
+
+//----------------------------------------------------------------
+

base/memory/zalloc.h

@@ -14,16 +14,12 @@
 #define BASE_MEMORY_ZALLOC_H
 
 #include <stdlib.h>
-#include <string.h>
 
 //----------------------------------------------------------------
 
 static inline void *zalloc(size_t len)
 {
-	void *ptr = malloc(len);
-	if (ptr)
-		memset(ptr, 0, len);
-	return ptr;
+	return calloc(1, len);
 }
 
 //----------------------------------------------------------------

conf/Makefile.in

@@ -49,8 +49,9 @@ install_localconf: $(CONFLOCAL)
 	fi
 
 install_profiles: $(PROFILES)
-	$(INSTALL_DIR) $(profiledir)
-	$(INSTALL_DATA) $(PROFILES) $(profiledir)/
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_DIR) $(profiledir)
+	$(Q) $(INSTALL_DATA) $(PROFILES) $(profiledir)/
 
 install_lvm2: install_conf install_localconf install_profiles
 

conf/example.conf.in

@@ -88,6 +88,22 @@ devices {
 	# 
 	external_device_info_source = "none"
 
+	# Configuration option devices/hints.
+	# Use a local file to remember which devices have PVs on them.
+	# Some commands will use this as an optimization to reduce device
+	# scanning, and will only scan the listed PVs. Removing the hint file
+	# will cause lvm to generate a new one. Disable hints if PVs will
+	# be copied onto devices using non-lvm commands, like dd.
+	# 
+	# Accepted values:
+	#   all
+	#     Use all hints.
+	#   none
+	#     Use no hints.
+	# 
+	# This configuration option has an automatic default value.
+	# hints = "all"
+
 	# Configuration option devices/preferred_names.
 	# Select which path name to display for a block device.
 	# If multiple path names exist for a block device, and LVM needs to
@@ -123,11 +139,10 @@ devices {
 	# then the device is accepted. Be careful mixing 'a' and 'r' patterns,
 	# as the combination might produce unexpected results (test changes.)
 	# Run vgscan after changing the filter to regenerate the cache.
-	# See the use_lvmetad comment for a special case regarding filters.
 	# 
 	# Example
 	# Accept every block device:
-	# filter = [ "a|.*/|" ]
+	# filter = [ "a|.*|" ]
 	# Reject the cdrom drive:
 	# filter = [ "r|/dev/cdrom|" ]
 	# Work with just loopback devices, e.g. for testing:
@@ -135,32 +150,20 @@ devices {
 	# Accept all loop devices and ide drives except hdc:
 	# filter = [ "a|loop|", "r|/dev/hdc|", "a|/dev/ide|", "r|.*|" ]
 	# Use anchors to be very specific:
-	# filter = [ "a|^/dev/hda8$|", "r|.*/|" ]
+	# filter = [ "a|^/dev/hda8$|", "r|.*|" ]
 	# 
 	# This configuration option has an automatic default value.
-	# filter = [ "a|.*/|" ]
+	# filter = [ "a|.*|" ]
 
 	# Configuration option devices/global_filter.
 	# Limit the block devices that are used by LVM system components.
 	# Because devices/filter may be overridden from the command line, it is
-	# not suitable for system-wide device filtering, e.g. udev and lvmetad.
+	# not suitable for system-wide device filtering, e.g. udev.
 	# Use global_filter to hide devices from these LVM system components.
 	# The syntax is the same as devices/filter. Devices rejected by
 	# global_filter are not opened by LVM.
 	# This configuration option has an automatic default value.
-	# global_filter = [ "a|.*/|" ]
-
-	# Configuration option devices/cache_dir.
-	# This setting is no longer used.
-	cache_dir = "@DEFAULT_SYS_DIR@/@DEFAULT_CACHE_SUBDIR@"
-
-	# Configuration option devices/cache_file_prefix.
-	# This setting is no longer used.
-	cache_file_prefix = ""
-
-	# Configuration option devices/write_cache_state.
-	# This setting is no longer used.
-	write_cache_state = 1
+	# global_filter = [ "a|.*|" ]
 
 	# Configuration option devices/types.
 	# List of additional acceptable block device types.
@@ -179,14 +182,53 @@ devices {
 	# present on the system. sysfs must be part of the kernel and mounted.)
 	sysfs_scan = 1
 
+	# Configuration option devices/scan_lvs.
+	# Scan LVM LVs for layered PVs, allowing LVs to be used as PVs.
+	# When 1, LVM will detect PVs layered on LVs, and caution must be
+	# taken to avoid a host accessing a layered VG that may not belong
+	# to it, e.g. from a guest image. This generally requires excluding
+	# the LVs with device filters. Also, when this setting is enabled,
+	# every LVM command will scan every active LV on the system (unless
+	# filtered), which can cause performance problems on systems with
+	# many active LVs. When this setting is 0, LVM will not detect or
+	# use PVs that exist on LVs, and will not allow a PV to be created on
+	# an LV. The LVs are ignored using a built in device filter that
+	# identifies and excludes LVs.
+	scan_lvs = 0
+
 	# Configuration option devices/multipath_component_detection.
 	# Ignore devices that are components of DM multipath devices.
 	multipath_component_detection = 1
 
 	# Configuration option devices/md_component_detection.
-	# Ignore devices that are components of software RAID (md) devices.
+	# Enable detection and exclusion of MD component devices.
+	# An MD component device is a block device that MD uses as part
+	# of a software RAID virtual device. When an LVM PV is created
+	# on an MD device, LVM must only use the top level MD device as
+	# the PV, and should ignore the underlying component devices.
+	# In cases where the MD superblock is located at the end of the
+	# component devices, it is more difficult for LVM to consistently
+	# identify an MD component, see the md_component_checks setting.
 	md_component_detection = 1
 
+	# Configuration option devices/md_component_checks.
+	# The checks LVM should use to detect MD component devices.
+	# MD component devices are block devices used by MD software RAID.
+	# 
+	# Accepted values:
+	#   auto
+	#     LVM will skip scanning the end of devices when it has other
+	#     indications that the device is not an MD component.
+	#   start
+	#     LVM will only scan the start of devices for MD superblocks.
+	#     This does not incur extra I/O by LVM.
+	#   full
+	#     LVM will scan the start and end of devices for MD superblocks.
+	#     This requires an extra read at the end of devices.
+	# 
+	# This configuration option has an automatic default value.
+	# md_component_checks = "auto"
+
 	# Configuration option devices/fw_raid_component_detection.
 	# Ignore devices that are components of firmware RAID devices.
 	# LVM must use an external_device_info_source other than none for this
@@ -194,19 +236,24 @@ devices {
 	fw_raid_component_detection = 0
 
 	# Configuration option devices/md_chunk_alignment.
-	# Align PV data blocks with md device's stripe-width.
+	# Align the start of a PV data area with md device's stripe-width.
 	# This applies if a PV is placed directly on an md device.
+	# default_data_alignment will be overriden if it is not aligned
+	# with the value detected for this setting.
+	# This setting is overriden by data_alignment_detection,
+	# data_alignment, and the --dataalignment option.
 	md_chunk_alignment = 1
 
 	# Configuration option devices/default_data_alignment.
-	# Default alignment of the start of a PV data area in MB.
-	# If set to 0, a value of 64KiB will be used.
-	# Set to 1 for 1MiB, 2 for 2MiB, etc.
+	# Align the start of a PV data area with this number of MiB.
+	# Set to 1 for 1MiB, 2 for 2MiB, etc. Set to 0 to disable.
+	# This setting is overriden by data_alignment and the --dataalignment
+	# option.
 	# This configuration option has an automatic default value.
 	# default_data_alignment = 1
 
 	# Configuration option devices/data_alignment_detection.
-	# Detect PV data alignment based on sysfs device information.
+	# Align the start of a PV data area with sysfs io properties.
 	# The start of a PV data area will be a multiple of minimum_io_size or
 	# optimal_io_size exposed in sysfs. minimum_io_size is the smallest
 	# request the device can perform without incurring a read-modify-write
@@ -214,27 +261,29 @@ devices {
 	# preferred unit of receiving I/O, e.g. MD stripe width.
 	# minimum_io_size is used if optimal_io_size is undefined (0).
 	# If md_chunk_alignment is enabled, that detects the optimal_io_size.
-	# This setting takes precedence over md_chunk_alignment.
+	# default_data_alignment and md_chunk_alignment will be overriden
+	# if they are not aligned with the value detected for this setting.
+	# This setting is overriden by data_alignment and the --dataalignment
+	# option.
 	data_alignment_detection = 1
 
 	# Configuration option devices/data_alignment.
-	# Alignment of the start of a PV data area in KiB.
-	# If a PV is placed directly on an md device and md_chunk_alignment or
-	# data_alignment_detection are enabled, then this setting is ignored.
-	# Otherwise, md_chunk_alignment and data_alignment_detection are
-	# disabled if this is set. Set to 0 to use the default alignment or the
-	# page size, if larger.
+	# Align the start of a PV data area with this number of KiB.
+	# When non-zero, this setting overrides default_data_alignment.
+	# Set to 0 to disable, in which case default_data_alignment
+	# is used to align the first PE in units of MiB.
+	# This setting is overriden by the --dataalignment option.
 	data_alignment = 0
 
 	# Configuration option devices/data_alignment_offset_detection.
-	# Detect PV data alignment offset based on sysfs device information.
-	# The start of a PV aligned data area will be shifted by the
+	# Shift the start of an aligned PV data area based on sysfs information.
+	# After a PV data area is aligned, it will be shifted by the
 	# alignment_offset exposed in sysfs. This offset is often 0, but may
 	# be non-zero. Certain 4KiB sector drives that compensate for windows
 	# partitioning will have an alignment_offset of 3584 bytes (sector 7
 	# is the lowest aligned logical block, the 4KiB sectors start at
 	# LBA -1, and consequently sector 63 is aligned on a 4KiB boundary).
-	# pvcreate --dataalignmentoffset will skip this detection.
+	# This setting is overriden by the --dataalignmentoffset option.
 	data_alignment_offset_detection = 1
 
 	# Configuration option devices/ignore_suspended_devices.
@@ -262,10 +311,6 @@ devices {
 	# different way, making them a better choice for VG stacking.
 	ignore_lvm_mirrors = 1
 
-	# Configuration option devices/disable_after_error_count.
-	# This setting is no longer used.
-	disable_after_error_count = 0
-
 	# Configuration option devices/require_restorefile_with_uuid.
 	# Allow use of pvcreate --uuid without requiring --restorefile.
 	require_restorefile_with_uuid = 1
@@ -302,6 +347,12 @@ devices {
 	# Enabling this setting allows the VG to be used as usual even with
 	# uncertain devices.
 	allow_changes_with_duplicate_pvs = 0
+
+	# Configuration option devices/allow_mixed_block_sizes.
+	# Allow PVs in the same VG with different logical block sizes.
+	# When allowed, the user is responsible to ensure that an LV is
+	# using PVs with matching block sizes when necessary.
+	allow_mixed_block_sizes = 0
 }
 
 # Configuration section allocation.
@@ -336,7 +387,7 @@ allocation {
 	maximise_cling = 1
 
 	# Configuration option allocation/use_blkid_wiping.
-	# Use blkid to detect existing signatures on new PVs and LVs.
+	# Use blkid to detect and erase existing signatures on new PVs and LVs.
 	# The blkid library can detect more signatures than the native LVM
 	# detection code, but may take longer. LVM needs to be compiled with
 	# blkid wiping support for this setting to apply. LVM native detection
@@ -503,10 +554,19 @@ allocation {
 	# This configuration option has an automatic default value.
 	# vdo_use_deduplication = 1
 
-	# Configuration option allocation/vdo_emulate_512_sectors.
-	# Specifies that the VDO volume is to emulate a 512 byte block device.
+	# Configuration option allocation/vdo_use_metadata_hints.
+	# Enables or disables whether VDO volume should tag its latency-critical
+	# writes with the REQ_SYNC flag. Some device mapper targets such as dm-raid5
+	# process writes with this flag at a higher priority.
+	# Default is enabled.
 	# This configuration option has an automatic default value.
-	# vdo_emulate_512_sectors = 0
+	# vdo_use_metadata_hints = 1
+
+	# Configuration option allocation/vdo_minimum_io_size.
+	# The minimum IO size for VDO volume to accept, in bytes.
+	# Valid values are 512 or 4096. The recommended and default value is 4096.
+	# This configuration option has an automatic default value.
+	# vdo_minimum_io_size = 4096
 
 	# Configuration option allocation/vdo_block_map_cache_size_mb.
 	# Specifies the amount of memory in MiB allocated for caching block map
@@ -517,10 +577,10 @@ allocation {
 	# vdo_block_map_cache_size_mb = 128
 
 	# Configuration option allocation/vdo_block_map_period.
-	# Tunes the quantity of block map updates that can accumulate
-	# before cache pages are flushed to disk. The value must be
-	# at least 1 and less then 16380.
-	# A lower value means shorter recovery time but lower performance.
+	# The speed with which the block map cache writes out modified block map pages.
+	# A smaller era length is likely to reduce the amount time spent rebuilding,
+	# at the cost of increased block map writes during normal operation.
+	# The maximum and recommended value is 16380; the minimum value is 1.
 	# This configuration option has an automatic default value.
 	# vdo_block_map_period = 16380
 
@@ -540,22 +600,6 @@ allocation {
 	# This configuration option has an automatic default value.
 	# vdo_index_memory_size_mb = 256
 
-	# Configuration option allocation/vdo_use_read_cache.
-	# Enables or disables the read cache within the VDO volume.
-	# The cache should be enabled if write workloads are expected
-	# to have high levels of deduplication, or for read intensive
-	# workloads of highly compressible data.
-	# This configuration option has an automatic default value.
-	# vdo_use_read_cache = 0
-
-	# Configuration option allocation/vdo_read_cache_size_mb.
-	# Specifies the extra VDO volume read cache size in MiB.
-	# This space is in addition to a system-defined minimum.
-	# The value must be less then 16TiB and 1.12 MiB of memory
-	# will be used per MiB of read cache specified, per bio thread.
-	# This configuration option has an automatic default value.
-	# vdo_read_cache_size_mb = 0
-
 	# Configuration option allocation/vdo_slab_size_mb.
 	# Specifies the size in MiB of the increment by which a VDO is grown.
 	# Using a smaller size constrains the total maximum physical size
@@ -577,7 +621,7 @@ allocation {
 	# Each additional thread after the first will use an additional 18MiB of RAM,
 	# plus 1.12 MiB of RAM per megabyte of configured read cache size.
 	# This configuration option has an automatic default value.
-	# vdo_bio_threads = 1
+	# vdo_bio_threads = 4
 
 	# Configuration option allocation/vdo_bio_rotation.
 	# Specifies the number of I/O operations to enqueue for each bio-submission
@@ -631,6 +675,18 @@ allocation {
 	#         Data which has not been flushed is not guaranteed to persist in this mode.
 	# This configuration option has an automatic default value.
 	# vdo_write_policy = "auto"
+
+	# Configuration option allocation/vdo_max_discard.
+	# Specified te maximum size of discard bio accepted, in 4096 byte blocks.
+	# I/O requests to a VDO volume are normally split into 4096-byte blocks,
+	# and processed up to 2048 at a time. However, discard requests to a VDO volume
+	# can be automatically split to a larger size, up to <max discard> 4096-byte blocks
+	# in a single bio, and are limited to 1500 at a time.
+	# Increasing this value may provide better overall performance, at the cost of
+	# increased latency for the individual discard requests.
+	# The default and minimum is 1. The maximum is UINT_MAX / 4096.
+	# This configuration option has an automatic default value.
+	# vdo_max_discard = 1
 }
 
 # Configuration section log.
@@ -721,7 +777,8 @@ log {
 
 	# Configuration option log/indent.
 	# Indent messages according to their severity.
-	indent = 1
+	# This configuration option has an automatic default value.
+	# indent = 0
 
 	# Configuration option log/command_names.
 	# Display the command name on each line of output.
@@ -744,9 +801,23 @@ log {
 	# Select log messages by class.
 	# Some debugging messages are assigned to a class and only appear in
 	# debug output if the class is listed here. Classes currently
-	# available: memory, devices, io, activation, allocation, lvmetad,
+	# available: memory, devices, io, activation, allocation,
 	# metadata, cache, locking, lvmpolld. Use "all" to see everything.
-	debug_classes = [ "memory", "devices", "io", "activation", "allocation", "lvmetad", "metadata", "cache", "locking", "lvmpolld", "dbus" ]
+	debug_classes = [ "memory", "devices", "io", "activation", "allocation", "metadata", "cache", "locking", "lvmpolld", "dbus" ]
+
+	# Configuration option log/debug_file_fields.
+	# The fields included in debug output written to log file.
+	# Use "all" to include everything (the default).
+	# This configuration option is advanced.
+	# This configuration option has an automatic default value.
+	# debug_file_fields = [ "time", "command", "fileline", "message" ]
+
+	# Configuration option log/debug_output_fields.
+	# The fields included in debug output written to stderr.
+	# Use "all" to include everything (the default).
+	# This configuration option is advanced.
+	# This configuration option has an automatic default value.
+	# debug_output_fields = [ "time", "command", "fileline", "message" ]
 }
 
 # Configuration section backup.
@@ -834,23 +905,6 @@ global {
 	# the error messages.
 	activation = 1
 
-	# Configuration option global/fallback_to_lvm1.
-	# This setting is no longer used.
-	# This configuration option has an automatic default value.
-	# fallback_to_lvm1 = 0
-
-	# Configuration option global/format.
-	# This setting is no longer used.
-	# This configuration option has an automatic default value.
-	# format = "lvm2"
-
-	# Configuration option global/format_libraries.
-	# This setting is no longer used.
-	# This configuration option does not have a default value defined.
-
-	# Configuration option global/segment_libraries.
-	# This configuration option does not have a default value defined.
-
 	# Configuration option global/proc.
 	# Location of proc filesystem.
 	# This configuration option is advanced.
@@ -860,22 +914,10 @@ global {
 	# Location of /etc system configuration directory.
 	etc = "@CONFDIR@"
 
-	# Configuration option global/locking_type.
-	# This setting is no longer used.
-	locking_type = 1
-
 	# Configuration option global/wait_for_locks.
 	# When disabled, fail if a lock request would block.
 	wait_for_locks = 1
 
-	# Configuration option global/fallback_to_clustered_locking.
-	# This setting is no longer used.
-	fallback_to_clustered_locking = 1
-
-	# Configuration option global/fallback_to_local_locking.
-	# This setting is no longer used.
-	fallback_to_local_locking = 1
-
 	# Configuration option global/locking_dir.
 	# Directory to use for LVM command file locks.
 	# Local non-LV directory that holds file-based locks while commands are
@@ -896,11 +938,6 @@ global {
 	# Search this directory first for shared libraries.
 	# This configuration option does not have a default value defined.
 
-	# Configuration option global/locking_library.
-	# This setting is no longer used.
-	# This configuration option has an automatic default value.
-	# locking_library = "liblvm2clusterlock.so"
-
 	# Configuration option global/abort_on_internal_errors.
 	# Abort a command that encounters an internal error.
 	# Treat any internal errors as fatal errors, aborting the process that
@@ -941,6 +978,16 @@ global {
 	# 
 	mirror_segtype_default = "@DEFAULT_MIRROR_SEGTYPE@"
 
+	# Configuration option global/support_mirrored_mirror_log.
+	# Enable mirrored 'mirror' log type for testing.
+	# 
+	# This type is deprecated to create or convert to but can
+	# be enabled to test that activation of existing mirrored
+	# logs and conversion to disk/core works.
+	# 
+	# Not supported for regular operation!
+	support_mirrored_mirror_log = 0
+
 	# Configuration option global/raid10_segtype_default.
 	# The segment type used by the -i -m combination.
 	# The --type raid10|mirror option overrides this setting.
@@ -989,41 +1036,20 @@ global {
 	# This configuration option has an automatic default value.
 	# lvdisplay_shows_full_device_path = 0
 
-	# Configuration option global/use_lvmetad.
-	# Use lvmetad to cache metadata and reduce disk scanning.
-	# When enabled (and running), lvmetad provides LVM commands with VG
-	# metadata and PV state. LVM commands then avoid reading this
-	# information from disks which can be slow. When disabled (or not
-	# running), LVM commands fall back to scanning disks to obtain VG
-	# metadata. lvmetad is kept updated via udev rules which must be set
-	# up for LVM to work correctly. (The udev rules should be installed
-	# by default.) Without a proper udev setup, changes in the system's
-	# block device configuration will be unknown to LVM, and ignored
-	# until a manual 'pvscan --cache' is run. If lvmetad was running
-	# while use_lvmetad was disabled, it must be stopped, use_lvmetad
-	# enabled, and then started. When using lvmetad, LV activation is
-	# switched to an automatic, event-based mode. In this mode, LVs are
-	# activated based on incoming udev events that inform lvmetad when
-	# PVs appear on the system. When a VG is complete (all PVs present),
-	# it is auto-activated. The auto_activation_volume_list setting
-	# controls which LVs are auto-activated (all by default.)
-	# When lvmetad is updated (automatically by udev events, or directly
-	# by pvscan --cache), devices/filter is ignored and all devices are
-	# scanned by default. lvmetad always keeps unfiltered information
-	# which is provided to LVM commands. Each LVM command then filters
-	# based on devices/filter. This does not apply to other, non-regexp,
-	# filtering settings: component filters such as multipath and MD
-	# are checked during pvscan --cache. To filter a device and prevent
-	# scanning from the LVM system entirely, including lvmetad, use
-	# devices/global_filter.
-	use_lvmetad = @DEFAULT_USE_LVMETAD@
+	# Configuration option global/event_activation.
+	# Activate LVs based on system-generated device events.
+	# When a device appears on the system, a system-generated event runs
+	# the pvscan command to activate LVs if the new PV completes the VG.
+	# Use auto_activation_volume_list to select which LVs should be
+	# activated from these events (the default is all.)
+	# When event_activation is disabled, the system will generally run
+	# a direct activation command to activate LVs in complete VGs.
+	event_activation = 1
 
-	# Configuration option global/lvmetad_update_wait_time.
-	# 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.
+	# Configuration option global/use_aio.
+	# Use async I/O when reading and writing devices.
 	# This configuration option has an automatic default value.
-	# lvmetad_update_wait_time = 10
+	# use_aio = 1
 
 	# Configuration option global/use_lvmlockd.
 	# Use lvmlockd for locking among hosts using LVM on shared storage.
@@ -1217,6 +1243,16 @@ global {
 	# When enabled, an LVM command that changes PVs, changes VG metadata,
 	# or changes the activation state of an LV will send a notification.
 	notify_dbus = 1
+
+	# Configuration option global/io_memory_size.
+	# The amount of memory in KiB that LVM allocates to perform disk io.
+	# LVM performance may benefit from more io memory when there are many
+	# disks or VG metadata is large. Increasing this size may be necessary
+	# when a single copy of VG metadata is larger than the current setting.
+	# This value should usually not be decreased from the default; setting
+	# it too low can result in lvm failing to read VGs.
+	# This configuration option has an automatic default value.
+	# io_memory_size = 8192
 }
 
 # Configuration section activation.
@@ -1705,13 +1741,19 @@ activation {
 	# vgmetadatacopies = 0
 
 	# Configuration option metadata/pvmetadatasize.
-	# Approximate number of sectors to use for each metadata copy.
-	# VGs with large numbers of PVs or LVs, or VGs containing complex LV
-	# structures, may need additional space for VG metadata. The metadata
-	# areas are treated as circular buffers, so unused space becomes filled
-	# with an archive of the most recent previous versions of the metadata.
-	# This configuration option has an automatic default value.
-	# pvmetadatasize = 255
+	# The default size of the metadata area in units of 512 byte sectors.
+	# The metadata area begins at an offset of the page size from the start
+	# of the device. The first PE is by default at 1 MiB from the start of
+	# the device. The space between these is the default metadata area size.
+	# The actual size of the metadata area may be larger than what is set
+	# here due to default_data_alignment making the first PE a MiB multiple.
+	# The metadata area begins with a 512 byte header and is followed by a
+	# circular buffer used for VG metadata text. The maximum size of the VG
+	# metadata is about half the size of the metadata buffer. VGs with large
+	# numbers of PVs or LVs, or VGs containing complex LV structures, may need
+	# additional space for VG metadata. The --metadatasize option overrides
+	# this setting.
+	# This configuration option does not have a default value defined.
 
 	# Configuration option metadata/pvmetadataignore.
 	# Ignore metadata areas on a new PV.
@@ -1726,11 +1768,6 @@ activation {
 	# This configuration option is advanced.
 	# This configuration option has an automatic default value.
 	# stripesize = 64
-
-	# Configuration option metadata/dirs.
-	# This setting is no longer used.
-	# This configuration option is advanced.
-	# This configuration option does not have a default value defined.
 # }
 
 # Configuration section report.

conf/vdo-small.profile

@@ -1,25 +1,24 @@
 # Demo configuration for 'VDO' using less memory.
-#
+# ~lvmconfig --type full | grep vdo
 
 allocation {
-	vdo_use_compression = 1
-	vdo_use_deduplication = 1
-	vdo_emulate_512_sectors = 0
-	vdo_block_map_cache_size_mb = 128
-	vdo_block_map_period = 16380
-	vdo_check_point_frequency = 0
-	vdo_use_sparse_index = 0
-	vdo_index_memory_size_mb = 256
-	vdo_use_read_cache = 0
-	vdo_read_cache_size_mb = 0
-	vdo_slab_size_mb = 2048
-
-	vdo_ack_threads = 1
-	vdo_bio_threads = 1
-	vdo_bio_rotation = 64
-	vdo_cpu_threads = 2
-	vdo_hash_zone_threads = 1
-	vdo_logical_threads = 1
-	vdo_physical_threads = 1
-	vdo_write_policy = "auto"
+	vdo_use_compression=1
+	vdo_use_deduplication=1
+	vdo_use_metadata_hints=1
+	vdo_minimum_io_size=4096
+	vdo_block_map_cache_size_mb=128
+	vdo_block_map_period=16380
+	vdo_check_point_frequency=0
+	vdo_use_sparse_index=0
+	vdo_index_memory_size_mb=256
+	vdo_slab_size_mb=2048
+	vdo_ack_threads=1
+	vdo_bio_threads=1
+	vdo_bio_rotation=64
+	vdo_cpu_threads=2
+	vdo_hash_zone_threads=1
+	vdo_logical_threads=1
+	vdo_physical_threads=1
+	vdo_write_policy="auto"
+	vdo_max_discard=1
 }

configure

@@ -728,7 +728,6 @@ DEFAULT_PID_DIR
 DEFAULT_MIRROR_SEGTYPE
 DEFAULT_LOCK_DIR
 DEFAULT_DM_RUN_DIR
-DEFAULT_DATA_ALIGNMENT
 DEFAULT_CACHE_SUBDIR
 DEFAULT_BACKUP_SUBDIR
 DEFAULT_ARCHIVE_SUBDIR
@@ -743,6 +742,7 @@ CLDNOWHOLEARCHIVE
 CLDFLAGS
 CACHE
 BUILD_DMFILEMAPD
+BUILD_LOCKDDLM_CONTROL
 BUILD_LOCKDDLM
 BUILD_LOCKDSANLOCK
 BUILD_LVMLOCKD
@@ -772,6 +772,8 @@ BLKID_LIBS
 BLKID_CFLAGS
 NOTIFY_DBUS_LIBS
 NOTIFY_DBUS_CFLAGS
+LOCKD_DLM_CONTROL_LIBS
+LOCKD_DLM_CONTROL_CFLAGS
 LOCKD_DLM_LIBS
 LOCKD_DLM_CFLAGS
 LOCKD_SANLOCK_LIBS
@@ -915,6 +917,7 @@ with_cache_restore
 enable_cache_check_needs_check
 with_vdo
 with_vdo_format
+with_writecache
 enable_readline
 enable_realtime
 enable_ocf
@@ -932,6 +935,7 @@ enable_devmapper
 enable_lvmpolld
 enable_lvmlockd_sanlock
 enable_lvmlockd_dlm
+enable_lvmlockd_dlmcontrol
 enable_use_lvmlockd
 with_lvmlockd_pidfile
 enable_use_lvmpolld
@@ -973,7 +977,6 @@ with_default_archive_subdir
 with_default_backup_subdir
 with_default_cache_subdir
 with_default_locking_dir
-with_default_data_alignment
 with_interface
 '
       ac_precious_vars='build_alias
@@ -1001,6 +1004,8 @@ LOCKD_SANLOCK_CFLAGS
 LOCKD_SANLOCK_LIBS
 LOCKD_DLM_CFLAGS
 LOCKD_DLM_LIBS
+LOCKD_DLM_CONTROL_CFLAGS
+LOCKD_DLM_CONTROL_LIBS
 NOTIFY_DBUS_CFLAGS
 NOTIFY_DBUS_LIBS
 BLKID_CFLAGS
@@ -1644,6 +1649,8 @@ Optional Features:
   --enable-lvmlockd-sanlock
                           enable the LVM lock daemon using sanlock
   --enable-lvmlockd-dlm   enable the LVM lock daemon using dlm
+  --enable-lvmlockd-dlmcontrol
+                          enable lvmlockd remote refresh using libdlmcontrol
   --disable-use-lvmlockd  disable usage of LVM lock daemon
   --disable-use-lvmpolld  disable usage of LVM Poll Daemon
   --enable-dmfilemapd     enable the dmstats filemap daemon
@@ -1708,6 +1715,7 @@ Optional Packages:
                           cache_restore tool: [autodetect]
   --with-vdo=TYPE         vdo support: internal/none [internal]
   --with-vdo-format=PATH  vdoformat tool: [autodetect]
+  --with-writecache=TYPE  writecache support: internal/none [none]
   --with-ocfdir=DIR       install OCF files in
                           [PREFIX/lib/ocf/resource.d/lvm2]
   --with-default-pid-dir=PID_DIR
@@ -1752,8 +1760,6 @@ Optional Packages:
                           default metadata cache subdir [cache]
   --with-default-locking-dir=DIR
                           default locking directory [autodetect_lock_dir/lvm]
-  --with-default-data-alignment=NUM
-                          set the default data alignment in MiB [1]
   --with-interface=IFACE  choose kernel interface (ioctl) [ioctl]
 
 Some influential environment variables:
@@ -1790,6 +1796,10 @@ Some influential environment variables:
               C compiler flags for LOCKD_DLM, overriding pkg-config
   LOCKD_DLM_LIBS
               linker flags for LOCKD_DLM, overriding pkg-config
+  LOCKD_DLM_CONTROL_CFLAGS
+              C compiler flags for LOCKD_DLM_CONTROL, overriding pkg-config
+  LOCKD_DLM_CONTROL_LIBS
+              linker flags for LOCKD_DLM_CONTROL, overriding pkg-config
   NOTIFY_DBUS_CFLAGS
               C compiler flags for NOTIFY_DBUS, overriding pkg-config
   NOTIFY_DBUS_LIBS
@@ -3067,7 +3077,7 @@ if test -z "$CFLAGS"; then :
 fi
 case "$host_os" in
 	linux*)
-		CLDFLAGS="$CLDFLAGS -Wl,--version-script,.export.sym"
+		CLDFLAGS="${CLDFLAGS-"$LDFLAGS"} -Wl,--version-script,.export.sym"
 		# equivalent to -rdynamic
 		ELDFLAGS="-Wl,--export-dynamic"
 		# FIXME Generate list and use --dynamic-list=.dlopen.sym
@@ -3079,6 +3089,7 @@ case "$host_os" in
 		BUILD_LVMPOLLD=no
 		LOCKDSANLOCK=no
 		LOCKDDLM=no
+		LOCKDDLM_CONTROL=no
 		ODIRECT=yes
 		DM_IOCTLS=yes
 		SELINUX=yes
@@ -3087,7 +3098,7 @@ case "$host_os" in
 		;;
 	darwin*)
 		CFLAGS="$CFLAGS -no-cpp-precomp -fno-common"
-		CLDFLAGS="$CLDFLAGS"
+		CLDFLAGS="${CLDFLAGS-"$LDFLAGS"}"
 		ELDFLAGS=
 		CLDWHOLEARCHIVE="-all_load"
 		CLDNOWHOLEARCHIVE=
@@ -3099,6 +3110,9 @@ case "$host_os" in
 		FSADM=no
 		BLKDEACTIVATE=no
 		;;
+	*)
+		CLDFLAGS="${CLDFLAGS-"$LDFLAGS"}"
+		;;
 esac
 
 ################################################################################
@@ -6622,9 +6636,18 @@ fi
 
 
 
+
+
+$as_echo "#define _GNU_SOURCE 1" >>confdefs.h
+
+
+$as_echo "#define _REENTRANT 1" >>confdefs.h
+
+
+
 ################################################################################
 for ac_func in ftruncate gethostname getpagesize gettimeofday localtime_r \
-  memchr memset mkdir mkfifo munmap nl_langinfo realpath rmdir setenv \
+  memchr memset mkdir mkfifo munmap nl_langinfo pselect realpath rmdir setenv \
   setlocale strcasecmp strchr strcspn strdup strerror strncasecmp strndup \
   strrchr strspn strstr strtol strtoul uname
 do :
@@ -6640,6 +6663,17 @@ else
 fi
 done
 
+for ac_func in prlimit
+do :
+  ac_fn_c_check_func "$LINENO" "prlimit" "ac_cv_func_prlimit"
+if test "x$ac_cv_func_prlimit" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_PRLIMIT 1
+_ACEOF
+
+fi
+done
+
 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
 # for constant arguments.  Useless!
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working alloca.h" >&5
@@ -9702,6 +9736,31 @@ _ACEOF
 #                           VDO_LIB=$withval, VDO_LIB="/usr/lib")
 #AC_MSG_RESULT($VDO_LIB)
 
+################################################################################
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to include writecache" >&5
+$as_echo_n "checking whether to include writecache... " >&6; }
+
+# Check whether --with-writecache was given.
+if test "${with_writecache+set}" = set; then :
+  withval=$with_writecache; WRITECACHE=$withval
+else
+  WRITECACHE="none"
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $WRITECACHE" >&5
+$as_echo "$WRITECACHE" >&6; }
+
+case "$WRITECACHE" in
+ none) ;;
+ internal)
+
+$as_echo "#define WRITECACHE_INTERNAL 1" >>confdefs.h
+
+	;;
+ *) as_fn_error $? "--with-writecache parameter invalid" "$LINENO" 5 ;;
+esac
+
 ################################################################################
 # Check whether --enable-readline was given.
 if test "${enable_readline+set}" = set; then :
@@ -10923,6 +10982,97 @@ $as_echo "#define LOCKDDLM_SUPPORT 1" >>confdefs.h
 	BUILD_LVMLOCKD=yes
 fi
 
+################################################################################
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build lvmlockddlmcontrol" >&5
+$as_echo_n "checking whether to build lvmlockddlmcontrol... " >&6; }
+# Check whether --enable-lvmlockd-dlmcontrol was given.
+if test "${enable_lvmlockd_dlmcontrol+set}" = set; then :
+  enableval=$enable_lvmlockd_dlmcontrol; LOCKDDLM_CONTROL=$enableval
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LOCKDDLM_CONTROL" >&5
+$as_echo "$LOCKDDLM_CONTROL" >&6; }
+
+BUILD_LOCKDDLM_CONTROL=$LOCKDDLM_CONTROL
+
+if test "$BUILD_LOCKDDLM_CONTROL" = yes; then
+
+pkg_failed=no
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LOCKD_DLM_CONTROL" >&5
+$as_echo_n "checking for LOCKD_DLM_CONTROL... " >&6; }
+
+if test -n "$LOCKD_DLM_CONTROL_CFLAGS"; then
+    pkg_cv_LOCKD_DLM_CONTROL_CFLAGS="$LOCKD_DLM_CONTROL_CFLAGS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libdlmcontrol >= 3.2\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libdlmcontrol >= 3.2") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_LOCKD_DLM_CONTROL_CFLAGS=`$PKG_CONFIG --cflags "libdlmcontrol >= 3.2" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
+else
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+if test -n "$LOCKD_DLM_CONTROL_LIBS"; then
+    pkg_cv_LOCKD_DLM_CONTROL_LIBS="$LOCKD_DLM_CONTROL_LIBS"
+ elif test -n "$PKG_CONFIG"; then
+    if test -n "$PKG_CONFIG" && \
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libdlmcontrol >= 3.2\""; } >&5
+  ($PKG_CONFIG --exists --print-errors "libdlmcontrol >= 3.2") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  pkg_cv_LOCKD_DLM_CONTROL_LIBS=`$PKG_CONFIG --libs "libdlmcontrol >= 3.2" 2>/dev/null`
+		      test "x$?" != "x0" && pkg_failed=yes
+else
+  pkg_failed=yes
+fi
+ else
+    pkg_failed=untried
+fi
+
+
+
+if test $pkg_failed = yes; then
+   	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+        _pkg_short_errors_supported=yes
+else
+        _pkg_short_errors_supported=no
+fi
+        if test $_pkg_short_errors_supported = yes; then
+	        LOCKD_DLM_CONTROL_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libdlmcontrol >= 3.2" 2>&1`
+        else
+	        LOCKD_DLM_CONTROL_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libdlmcontrol >= 3.2" 2>&1`
+        fi
+	# Put the nasty error message in config.log where it belongs
+	echo "$LOCKD_DLM_CONTROL_PKG_ERRORS" >&5
+
+	$bailout
+elif test $pkg_failed = untried; then
+     	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+	$bailout
+else
+	LOCKD_DLM_CONTROL_CFLAGS=$pkg_cv_LOCKD_DLM_CONTROL_CFLAGS
+	LOCKD_DLM_CONTROL_LIBS=$pkg_cv_LOCKD_DLM_CONTROL_LIBS
+        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+	HAVE_LOCKD_DLM_CONTROL=yes
+fi
+
+$as_echo "#define LOCKDDLM_CONTROL_SUPPORT 1" >>confdefs.h
+
+	BUILD_LVMLOCKD=yes
+fi
+
 ################################################################################
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build lvmlockd" >&5
 $as_echo_n "checking whether to build lvmlockd... " >&6; }
@@ -11638,7 +11788,6 @@ fi
 ################################################################################
 
 if test "$BUILD_LVMDBUSD" = yes; then
-	unset PYTHON PYTHON_CONFIG
 	unset am_cv_pathless_PYTHON ac_cv_path_PYTHON am_cv_python_platform
 	unset am_cv_python_pythondir am_cv_python_version am_cv_python_pyexecdir
 	unset ac_cv_path_PYTHON_CONFIG ac_cv_path_ac_pt_PYTHON_CONFIG
@@ -13417,7 +13566,7 @@ cat >>confdefs.h <<_ACEOF
 _ACEOF
 
 
-LVMCONFIG_PATH="$$BINDIR/lvmconfig"
+LVMCONFIG_PATH="$SBINDIR/lvmconfig"
 
 cat >>confdefs.h <<_ACEOF
 #define LVMCONFIG_PATH "$LVMCONFIG_PATH"
@@ -13560,21 +13709,6 @@ cat >>confdefs.h <<_ACEOF
 _ACEOF
 
 
-################################################################################
-
-# Check whether --with-default-data-alignment was given.
-if test "${with_default_data_alignment+set}" = set; then :
-  withval=$with_default_data_alignment; DEFAULT_DATA_ALIGNMENT=$withval
-else
-  DEFAULT_DATA_ALIGNMENT=1
-fi
-
-
-cat >>confdefs.h <<_ACEOF
-#define DEFAULT_DATA_ALIGNMENT $DEFAULT_DATA_ALIGNMENT
-_ACEOF
-
-
 ################################################################################
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for kernel interface choice" >&5
 $as_echo_n "checking for kernel interface choice... " >&6; }
@@ -13769,7 +13903,7 @@ _ACEOF
 
 
 ################################################################################
-ac_config_files="$ac_config_files Makefile make.tmpl libdm/make.tmpl daemons/Makefile daemons/cmirrord/Makefile daemons/dmeventd/Makefile daemons/dmeventd/libdevmapper-event.pc daemons/dmeventd/plugins/Makefile daemons/dmeventd/plugins/lvm2/Makefile daemons/dmeventd/plugins/raid/Makefile daemons/dmeventd/plugins/mirror/Makefile daemons/dmeventd/plugins/snapshot/Makefile daemons/dmeventd/plugins/thin/Makefile daemons/dmeventd/plugins/vdo/Makefile daemons/lvmdbusd/Makefile daemons/lvmdbusd/lvmdbusd daemons/lvmdbusd/lvmdb.py daemons/lvmdbusd/lvm_shell_proxy.py daemons/lvmdbusd/path.py daemons/lvmpolld/Makefile daemons/lvmlockd/Makefile conf/Makefile conf/example.conf conf/lvmlocal.conf conf/command_profile_template.profile conf/metadata_profile_template.profile include/Makefile lib/Makefile include/lvm-version.h libdaemon/Makefile libdaemon/client/Makefile libdaemon/server/Makefile libdm/Makefile libdm/dm-tools/Makefile libdm/libdevmapper.pc man/Makefile po/Makefile scripts/blkdeactivate.sh scripts/blk_availability_init_red_hat scripts/blk_availability_systemd_red_hat.service scripts/cmirrord_init_red_hat scripts/com.redhat.lvmdbus1.service scripts/dm_event_systemd_red_hat.service scripts/dm_event_systemd_red_hat.socket scripts/lvm2_cmirrord_systemd_red_hat.service scripts/lvm2_lvmdbusd_systemd_red_hat.service scripts/lvm2_lvmpolld_init_red_hat scripts/lvm2_lvmpolld_systemd_red_hat.service scripts/lvm2_lvmpolld_systemd_red_hat.socket scripts/lvm2_lvmlockd_systemd_red_hat.service scripts/lvm2_monitoring_init_red_hat scripts/lvm2_monitoring_systemd_red_hat.service scripts/lvm2_pvscan_systemd_red_hat@.service scripts/lvm2_tmpfiles_red_hat.conf scripts/lvmdump.sh scripts/Makefile test/Makefile tools/Makefile udev/Makefile"
+ac_config_files="$ac_config_files Makefile make.tmpl libdm/make.tmpl daemons/Makefile daemons/cmirrord/Makefile daemons/dmeventd/Makefile daemons/dmeventd/libdevmapper-event.pc daemons/dmeventd/plugins/Makefile daemons/dmeventd/plugins/lvm2/Makefile daemons/dmeventd/plugins/raid/Makefile daemons/dmeventd/plugins/mirror/Makefile daemons/dmeventd/plugins/snapshot/Makefile daemons/dmeventd/plugins/thin/Makefile daemons/dmeventd/plugins/vdo/Makefile daemons/lvmdbusd/Makefile daemons/lvmdbusd/lvmdbusd daemons/lvmdbusd/lvmdb.py daemons/lvmdbusd/lvm_shell_proxy.py daemons/lvmdbusd/path.py daemons/lvmpolld/Makefile daemons/lvmlockd/Makefile conf/Makefile conf/example.conf conf/lvmlocal.conf conf/command_profile_template.profile conf/metadata_profile_template.profile include/Makefile lib/Makefile include/lvm-version.h libdaemon/Makefile libdaemon/client/Makefile libdaemon/server/Makefile libdm/Makefile libdm/dm-tools/Makefile libdm/libdevmapper.pc man/Makefile po/Makefile scripts/lvm2-pvscan.service scripts/blkdeactivate.sh scripts/blk_availability_init_red_hat scripts/blk_availability_systemd_red_hat.service scripts/cmirrord_init_red_hat scripts/com.redhat.lvmdbus1.service scripts/dm_event_systemd_red_hat.service scripts/dm_event_systemd_red_hat.socket scripts/lvm2_cmirrord_systemd_red_hat.service scripts/lvm2_lvmdbusd_systemd_red_hat.service scripts/lvm2_lvmpolld_init_red_hat scripts/lvm2_lvmpolld_systemd_red_hat.service scripts/lvm2_lvmpolld_systemd_red_hat.socket scripts/lvmlockd.service scripts/lvmlocks.service scripts/lvm2_monitoring_init_red_hat scripts/lvm2_monitoring_systemd_red_hat.service scripts/lvm2_tmpfiles_red_hat.conf scripts/lvmdump.sh scripts/Makefile test/Makefile tools/Makefile udev/Makefile"
 
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
@@ -14501,6 +14635,7 @@ do
     "libdm/libdevmapper.pc") CONFIG_FILES="$CONFIG_FILES libdm/libdevmapper.pc" ;;
     "man/Makefile") CONFIG_FILES="$CONFIG_FILES man/Makefile" ;;
     "po/Makefile") CONFIG_FILES="$CONFIG_FILES po/Makefile" ;;
+    "scripts/lvm2-pvscan.service") CONFIG_FILES="$CONFIG_FILES scripts/lvm2-pvscan.service" ;;
     "scripts/blkdeactivate.sh") CONFIG_FILES="$CONFIG_FILES scripts/blkdeactivate.sh" ;;
     "scripts/blk_availability_init_red_hat") CONFIG_FILES="$CONFIG_FILES scripts/blk_availability_init_red_hat" ;;
     "scripts/blk_availability_systemd_red_hat.service") CONFIG_FILES="$CONFIG_FILES scripts/blk_availability_systemd_red_hat.service" ;;
@@ -14513,10 +14648,10 @@ do
     "scripts/lvm2_lvmpolld_init_red_hat") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_lvmpolld_init_red_hat" ;;
     "scripts/lvm2_lvmpolld_systemd_red_hat.service") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_lvmpolld_systemd_red_hat.service" ;;
     "scripts/lvm2_lvmpolld_systemd_red_hat.socket") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_lvmpolld_systemd_red_hat.socket" ;;
-    "scripts/lvm2_lvmlockd_systemd_red_hat.service") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_lvmlockd_systemd_red_hat.service" ;;
+    "scripts/lvmlockd.service") CONFIG_FILES="$CONFIG_FILES scripts/lvmlockd.service" ;;
+    "scripts/lvmlocks.service") CONFIG_FILES="$CONFIG_FILES scripts/lvmlocks.service" ;;
     "scripts/lvm2_monitoring_init_red_hat") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_monitoring_init_red_hat" ;;
     "scripts/lvm2_monitoring_systemd_red_hat.service") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_monitoring_systemd_red_hat.service" ;;
-    "scripts/lvm2_pvscan_systemd_red_hat@.service") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_pvscan_systemd_red_hat@.service" ;;
     "scripts/lvm2_tmpfiles_red_hat.conf") CONFIG_FILES="$CONFIG_FILES scripts/lvm2_tmpfiles_red_hat.conf" ;;
     "scripts/lvmdump.sh") CONFIG_FILES="$CONFIG_FILES scripts/lvmdump.sh" ;;
     "scripts/Makefile") CONFIG_FILES="$CONFIG_FILES scripts/Makefile" ;;

configure.ac

@@ -30,7 +30,7 @@ AC_CANONICAL_TARGET([])
 AS_IF([test -z "$CFLAGS"], [COPTIMISE_FLAG="-O2"])
 case "$host_os" in
 	linux*)
-		CLDFLAGS="$CLDFLAGS -Wl,--version-script,.export.sym"
+		CLDFLAGS="${CLDFLAGS-"$LDFLAGS"} -Wl,--version-script,.export.sym"
 		# equivalent to -rdynamic
 		ELDFLAGS="-Wl,--export-dynamic"
 		# FIXME Generate list and use --dynamic-list=.dlopen.sym
@@ -42,6 +42,7 @@ case "$host_os" in
 		BUILD_LVMPOLLD=no
 		LOCKDSANLOCK=no
 		LOCKDDLM=no
+		LOCKDDLM_CONTROL=no
 		ODIRECT=yes
 		DM_IOCTLS=yes
 		SELINUX=yes
@@ -50,7 +51,7 @@ case "$host_os" in
 		;;
 	darwin*)
 		CFLAGS="$CFLAGS -no-cpp-precomp -fno-common"
-		CLDFLAGS="$CLDFLAGS"
+		CLDFLAGS="${CLDFLAGS-"$LDFLAGS"}"
 		ELDFLAGS=
 		CLDWHOLEARCHIVE="-all_load"
 		CLDNOWHOLEARCHIVE=
@@ -62,6 +63,9 @@ case "$host_os" in
 		FSADM=no
 		BLKDEACTIVATE=no
 		;;
+	*)
+		CLDFLAGS="${CLDFLAGS-"$LDFLAGS"}"
+		;;
 esac
 
 ################################################################################
@@ -141,12 +145,18 @@ AC_TYPE_UINT64_T
 AX_GCC_BUILTIN([__builtin_clz])
 AX_GCC_BUILTIN([__builtin_clzll])
 
+
+AC_DEFINE([_GNU_SOURCE], 1, [Define to get access to GNU/Linux extension])
+AC_DEFINE([_REENTRANT], 1, [Define to use re-entrant thread safe versions])
+
+
 ################################################################################
 dnl -- Check for functions
 AC_CHECK_FUNCS([ftruncate gethostname getpagesize gettimeofday localtime_r \
-  memchr memset mkdir mkfifo munmap nl_langinfo realpath rmdir setenv \
+  memchr memset mkdir mkfifo munmap nl_langinfo pselect realpath rmdir setenv \
   setlocale strcasecmp strchr strcspn strdup strerror strncasecmp strndup \
   strrchr strspn strstr strtol strtoul uname], , [AC_MSG_ERROR(bailing out)])
+AC_CHECK_FUNCS([prlimit])
 AC_FUNC_ALLOCA
 AC_FUNC_CLOSEDIR_VOID
 AC_FUNC_CHOWN
@@ -639,6 +649,24 @@ AC_DEFINE_UNQUOTED([VDO_FORMAT_CMD], ["$VDO_FORMAT_CMD"],
 #                           VDO_LIB=$withval, VDO_LIB="/usr/lib") 
 #AC_MSG_RESULT($VDO_LIB)
 
+################################################################################
+dnl -- writecache inclusion type
+AC_MSG_CHECKING(whether to include writecache)
+AC_ARG_WITH(writecache,
+	    AC_HELP_STRING([--with-writecache=TYPE],
+			   [writecache support: internal/none [none]]),
+			   WRITECACHE=$withval, WRITECACHE="none")
+
+AC_MSG_RESULT($WRITECACHE)
+
+case "$WRITECACHE" in
+ none) ;;
+ internal) 
+	AC_DEFINE([WRITECACHE_INTERNAL], 1, [Define to 1 to include built-in support for writecache.])
+	;;
+ *) AC_MSG_ERROR([--with-writecache parameter invalid]) ;;
+esac
+
 ################################################################################
 dnl -- Disable readline
 AC_ARG_ENABLE([readline],
@@ -890,6 +918,24 @@ if test "$BUILD_LOCKDDLM" = yes; then
 	BUILD_LVMLOCKD=yes
 fi
 
+################################################################################
+dnl -- Build lvmlockddlmcontrol
+AC_MSG_CHECKING(whether to build lvmlockddlmcontrol)
+AC_ARG_ENABLE(lvmlockd-dlmcontrol,
+	      AC_HELP_STRING([--enable-lvmlockd-dlmcontrol],
+			     [enable lvmlockd remote refresh using libdlmcontrol]),
+	      LOCKDDLM_CONTROL=$enableval)
+AC_MSG_RESULT($LOCKDDLM_CONTROL)
+
+BUILD_LOCKDDLM_CONTROL=$LOCKDDLM_CONTROL
+
+dnl -- Look for libdlmcontrol libraries
+if test "$BUILD_LOCKDDLM_CONTROL" = yes; then
+	PKG_CHECK_MODULES(LOCKD_DLM_CONTROL, libdlmcontrol >= 3.2, [HAVE_LOCKD_DLM_CONTROL=yes], $bailout)
+	AC_DEFINE([LOCKDDLM_CONTROL_SUPPORT], 1, [Define to 1 to include code that uses lvmlockd dlm control option.])
+	BUILD_LVMLOCKD=yes
+fi
+
 ################################################################################
 dnl -- Build lvmlockd
 AC_MSG_CHECKING(whether to build lvmlockd)
@@ -1151,7 +1197,6 @@ AS_IF([test "$NOTIFYDBUS_SUPPORT" = yes && test "BUILD_LVMDBUSD" = yes],
 dnl -- Enable Python dbus library
 
 if test "$BUILD_LVMDBUSD" = yes; then
-	unset PYTHON PYTHON_CONFIG
 	unset am_cv_pathless_PYTHON ac_cv_path_PYTHON am_cv_python_platform
 	unset am_cv_python_pythondir am_cv_python_version am_cv_python_pyexecdir
 	unset ac_cv_path_PYTHON_CONFIG ac_cv_path_ac_pt_PYTHON_CONFIG
@@ -1494,7 +1539,7 @@ SBINDIR="$(eval echo $(eval echo $sbindir))"
 LVM_PATH="$SBINDIR/lvm"
 AC_DEFINE_UNQUOTED(LVM_PATH, ["$LVM_PATH"], [Path to lvm binary.])
 
-LVMCONFIG_PATH="$$BINDIR/lvmconfig"
+LVMCONFIG_PATH="$SBINDIR/lvmconfig"
 AC_DEFINE_UNQUOTED(LVMCONFIG_PATH, ["$LVMCONFIG_PATH"], [Path to lvmconfig binary.])
 
 USRSBINDIR="$(eval echo $(eval echo $usrsbindir))"
@@ -1577,15 +1622,6 @@ AC_ARG_WITH(default-locking-dir,
 AC_DEFINE_UNQUOTED(DEFAULT_LOCK_DIR, ["$DEFAULT_LOCK_DIR"],
 		   [Name of default locking directory.])
 
-################################################################################
-dnl -- Setup default data alignment
-AC_ARG_WITH(default-data-alignment,
-	    AC_HELP_STRING([--with-default-data-alignment=NUM],
-			   [set the default data alignment in MiB [1]]),
-	    DEFAULT_DATA_ALIGNMENT=$withval, DEFAULT_DATA_ALIGNMENT=1)
-AC_DEFINE_UNQUOTED(DEFAULT_DATA_ALIGNMENT, [$DEFAULT_DATA_ALIGNMENT],
-		   [Default data alignment.])
-
 ################################################################################
 dnl -- which kernel interface to use (ioctl only)
 AC_MSG_CHECKING(for kernel interface choice)
@@ -1626,6 +1662,7 @@ AC_SUBST(BUILD_LVMPOLLD)
 AC_SUBST(BUILD_LVMLOCKD)
 AC_SUBST(BUILD_LOCKDSANLOCK)
 AC_SUBST(BUILD_LOCKDDLM)
+AC_SUBST(BUILD_LOCKDDLM_CONTROL)
 AC_SUBST(BUILD_DMFILEMAPD)
 AC_SUBST(CACHE)
 AC_SUBST(CFLAGS)
@@ -1646,7 +1683,6 @@ AC_SUBST(DEBUG)
 AC_SUBST(DEFAULT_ARCHIVE_SUBDIR)
 AC_SUBST(DEFAULT_BACKUP_SUBDIR)
 AC_SUBST(DEFAULT_CACHE_SUBDIR)
-AC_SUBST(DEFAULT_DATA_ALIGNMENT)
 AC_SUBST(DEFAULT_DM_RUN_DIR)
 AC_SUBST(DEFAULT_LOCK_DIR)
 AC_SUBST(DEFAULT_MIRROR_SEGTYPE)
@@ -1807,6 +1843,7 @@ libdm/dm-tools/Makefile
 libdm/libdevmapper.pc
 man/Makefile
 po/Makefile
+scripts/lvm2-pvscan.service
 scripts/blkdeactivate.sh
 scripts/blk_availability_init_red_hat
 scripts/blk_availability_systemd_red_hat.service
@@ -1819,10 +1856,10 @@ scripts/lvm2_lvmdbusd_systemd_red_hat.service
 scripts/lvm2_lvmpolld_init_red_hat
 scripts/lvm2_lvmpolld_systemd_red_hat.service
 scripts/lvm2_lvmpolld_systemd_red_hat.socket
-scripts/lvm2_lvmlockd_systemd_red_hat.service
+scripts/lvmlockd.service
+scripts/lvmlocks.service
 scripts/lvm2_monitoring_init_red_hat
 scripts/lvm2_monitoring_systemd_red_hat.service
-scripts/lvm2_pvscan_systemd_red_hat@.service
 scripts/lvm2_tmpfiles_red_hat.conf
 scripts/lvmdump.sh
 scripts/Makefile

daemons/cmirrord/Makefile.in

@@ -28,9 +28,11 @@ LMLIBS += $(CPG_LIBS)
 CFLAGS += $(CPG_CFLAGS) $(EXTRA_EXEC_CFLAGS)
 LDFLAGS += $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS)
 
-cmirrord: $(OBJECTS) $(top_builddir)/lib/liblvm-internal.a
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) \
-		$(LVMLIBS) $(LMLIBS) $(INTERNAL_LIBS) $(LIBS)
+cmirrord: $(OBJECTS)
+	@echo "    [CC] $@"
+	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) \
+		$(LMLIBS) -L$(top_builddir)/libdm -ldevmapper $(LIBS)
 
 install: $(TARGETS)
-	$(INSTALL_PROGRAM) -D cmirrord $(usrsbindir)/cmirrord
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_PROGRAM) -D cmirrord $(usrsbindir)/cmirrord

daemons/cmirrord/cluster.c

@@ -17,6 +17,7 @@
 #include "link_mon.h"
 #include "local.h"
 #include "lib/mm/xlate.h"
+#include "base/memory/zalloc.h"
 
 /* FIXME: remove this and the code */
 #define CMIRROR_HAS_CHECKPOINT 0
@@ -402,13 +403,12 @@ static struct checkpoint_data *prepare_checkpoint(struct clog_cpg *entry,
 		return NULL;
 	}
 
-	new = malloc(sizeof(*new));
+	new = zalloc(sizeof(*new));
 	if (!new) {
 		LOG_ERROR("Unable to create checkpoint data for %u",
 			  cp_requester);
 		return NULL;
 	}
-	memset(new, 0, sizeof(*new));
 	new->requester = cp_requester;
 	strncpy(new->uuid, entry->name.value, entry->name.length);
 
@@ -643,13 +643,12 @@ static int export_checkpoint(struct checkpoint_data *cp)
 	rq_size += RECOVERING_REGION_SECTION_SIZE;
 	rq_size += cp->bitmap_size * 2; /* clean|sync_bits */
 
-	rq = malloc(rq_size);
+	rq = zalloc(rq_size);
 	if (!rq) {
 		LOG_ERROR("export_checkpoint: "
 			  "Unable to allocate transfer structs");
 		return -ENOMEM;
 	}
-	memset(rq, 0, rq_size);
 
 	dm_list_init(&rq->u.list);
 	rq->u_rq.request_type = DM_ULOG_CHECKPOINT_READY;
@@ -1621,12 +1620,11 @@ int create_cluster_cpg(char *uuid, uint64_t luid)
 			return -EEXIST;
 		}
 
-	new = malloc(sizeof(*new));
+	new = zalloc(sizeof(*new));
 	if (!new) {
 		LOG_ERROR("Unable to allocate memory for clog_cpg");
 		return -ENOMEM;
 	}
-	memset(new, 0, sizeof(*new));
 	dm_list_init(&new->list);
 	new->lowest_id = 0xDEAD;
 	dm_list_init(&new->startup_list);

daemons/cmirrord/cluster.h

@@ -12,8 +12,8 @@
 #ifndef _LVM_CLOG_CLUSTER_H
 #define _LVM_CLOG_CLUSTER_H
 
-#include "device_mapper/misc/dm-log-userspace.h"
-#include "device_mapper/all.h"
+#include "libdm/libdevmapper.h"
+#include "libdm/misc/dm-log-userspace.h"
 
 #define DM_ULOG_RESPONSE 0x1000U /* in last byte of 32-bit value */
 #define DM_ULOG_CHECKPOINT_READY 21

daemons/cmirrord/functions.h

@@ -12,7 +12,8 @@
 #ifndef _LVM_CLOG_FUNCTIONS_H
 #define _LVM_CLOG_FUNCTIONS_H
 
-#include "device_mapper/misc/dm-log-userspace.h"
+#include "libdm/libdevmapper.h"
+#include "libdm/misc/dm-log-userspace.h"
 #include "cluster.h"
 
 #define LOG_RESUMED   1

daemons/cmirrord/logging.h

@@ -13,9 +13,6 @@
 #ifndef _LVM_CLOG_LOGGING_H
 #define _LVM_CLOG_LOGGING_H
 
-#define _GNU_SOURCE
-
-#include "configure.h"
 #include <stdio.h>
 #include <stdint.h>
 #include <syslog.h>

daemons/dmeventd/Makefile.in

@@ -57,14 +57,16 @@ all: device-mapper
 device-mapper: $(TARGETS)
 
 CFLAGS_dmeventd.o += $(EXTRA_EXEC_CFLAGS)
-LIBS += $(PTHREAD_LIBS)
+LIBS += $(PTHREAD_LIBS) -L$(top_builddir)/libdm -ldevmapper
 
 dmeventd: $(LIB_SHARED) dmeventd.o
-	$(CC) $(CFLAGS) -L. $(LDFLAGS) $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS) dmeventd.o \
-		-o $@ $(DL_LIBS) $(DMEVENT_LIBS) $(INTERNAL_LIBS) $(LIBS) -lm
+	@echo "    [CC] $@"
+	$(Q) $(CC) $(CFLAGS) -L. $(LDFLAGS) $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS) dmeventd.o \
+		-o $@ $(DL_LIBS) $(DMEVENT_LIBS) $(LIBS) -lm
 
 dmeventd.static: $(LIB_STATIC) dmeventd.o
-	$(CC) $(CFLAGS) $(LDFLAGS) -static -L. -L$(interfacebuilddir) dmeventd.o \
+	@echo "    [CC] $@"
+	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) -static -L. -L$(interfacebuilddir) dmeventd.o \
 		-o $@ $(DL_LIBS) $(DMEVENT_LIBS) $(LIBS) $(STATIC_LIBS)
 
 ifeq ("@PKGCONFIG@", "yes")
@@ -80,23 +82,28 @@ CFLOW_SOURCES = $(addprefix $(srcdir)/, $(SOURCES))
 endif
 
 install_include: $(srcdir)/libdevmapper-event.h
-	$(INSTALL_DATA) -D $< $(includedir)/$(<F)
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_DATA) -D $< $(includedir)/$(<F)
 
 install_pkgconfig: libdevmapper-event.pc
-	$(INSTALL_DATA) -D $< $(pkgconfigdir)/devmapper-event.pc
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_DATA) -D $< $(pkgconfigdir)/devmapper-event.pc
 
 install_lib_dynamic: install_lib_shared
 
 install_lib_static: $(LIB_STATIC)
-	$(INSTALL_DATA) -D $< $(usrlibdir)/$(<F)
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_DATA) -D $< $(usrlibdir)/$(<F)
 
 install_lib: $(INSTALL_LIB_TARGETS)
 
 install_dmeventd_dynamic: dmeventd
-	$(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
 
 install_dmeventd_static: dmeventd.static
-	$(INSTALL_PROGRAM) -D $< $(staticdir)/$(<F)
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_PROGRAM) -D $< $(staticdir)/$(<F)
 
 install_dmeventd: $(INSTALL_DMEVENTD_TARGETS)
 

daemons/dmeventd/dmeventd.c

@@ -16,14 +16,12 @@
  * dmeventd - dm event daemon to monitor active mapped devices
  */
 
-#include "device_mapper/misc/dmlib.h"
-#include "base/memory/zalloc.h"
-#include "device_mapper/misc/dm-logging.h"
 
-#include "daemons/dmeventd/libdevmapper-event.h"
+#include "libdevmapper-event.h"
 #include "dmeventd.h"
 
-#include "tools/tool.h"
+#include "libdm/misc/dm-logging.h"
+#include "base/memory/zalloc.h"
 
 #include <dlfcn.h>
 #include <pthread.h>
@@ -35,6 +33,8 @@
 #include <signal.h>
 #include <arpa/inet.h>		/* for htonl, ntohl */
 #include <fcntl.h>		/* for musl libc */
+#include <unistd.h>
+#include <syslog.h>
 
 #ifdef __linux__
 /*
@@ -62,8 +62,6 @@
 
 #endif
 
-#include <syslog.h>
-
 #define DM_SIGNALED_EXIT  1
 #define DM_SCHEDULED_EXIT 2
 static volatile sig_atomic_t _exit_now = 0;	/* set to '1' when signal is given to exit */
@@ -1747,7 +1745,8 @@ static void _init_thread_signals(void)
 	sigdelset(&my_sigset, SIGHUP);
 	sigdelset(&my_sigset, SIGQUIT);
 
-	pthread_sigmask(SIG_BLOCK, &my_sigset, NULL);
+	if (pthread_sigmask(SIG_BLOCK, &my_sigset, NULL))
+		log_sys_error("pthread_sigmask", "SIG_BLOCK");
 }
 
 /*

daemons/dmeventd/libdevmapper-event.c

@@ -12,11 +12,11 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "device_mapper/misc/dmlib.h"
-#include "base/memory/zalloc.h"
-#include "device_mapper/misc/dm-logging.h"
-#include "daemons/dmeventd/libdevmapper-event.h"
+#include "libdevmapper-event.h"
 #include "dmeventd.h"
+#include "libdm/misc/dm-logging.h"
+#include "base/memory/zalloc.h"
+
 #include "lib/misc/intl.h"
 
 #include <fcntl.h>

daemons/dmeventd/libdevmapper-event.h

@@ -21,6 +21,7 @@
 #ifndef LIB_DMEVENT_H
 #define LIB_DMEVENT_H
 
+#include <stdarg.h>
 #include <stdint.h>
 
 /*

daemons/dmeventd/plugins/lvm2/Makefile.in

@@ -16,6 +16,7 @@ top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
 CLDFLAGS += -L$(top_builddir)/tools
+LIBS += $(DMEVENT_LIBS) $(PTHREAD_LIBS) @LVM2CMD_LIB@
 
 SOURCES = dmeventd_lvm.c
 
@@ -24,8 +25,6 @@ LIB_VERSION = $(LIB_VERSION_LVM)
 
 include $(top_builddir)/make.tmpl
 
-LIBS += @LVM2CMD_LIB@ $(INTERNAL_LIBS) $(PTHREAD_LIBS)
-
 install_lvm2: install_lib_shared
 
 install: install_lvm2

daemons/dmeventd/plugins/lvm2/dmeventd_lvm.c

@@ -31,6 +31,13 @@ static pthread_mutex_t _register_mutex = PTHREAD_MUTEX_INITIALIZER;
 static int _register_count = 0;
 static struct dm_pool *_mem_pool = NULL;
 static void *_lvm_handle = NULL;
+static DM_LIST_INIT(_env_registry);
+
+struct env_data {
+	struct dm_list list;
+	const char *cmd;
+	const char *data;
+};
 
 DM_EVENT_LOG_FN("#lvm")
 
@@ -100,6 +107,7 @@ void dmeventd_lvm2_exit(void)
 		lvm2_run(_lvm_handle, "_memlock_dec");
 		dm_pool_destroy(_mem_pool);
 		_mem_pool = NULL;
+		dm_list_init(&_env_registry);
 		lvm2_exit(_lvm_handle);
 		_lvm_handle = NULL;
 		log_debug("lvm plugin exited.");
@@ -124,6 +132,8 @@ int dmeventd_lvm2_command(struct dm_pool *mem, char *buffer, size_t size,
 	static char _internal_prefix[] =  "_dmeventd_";
 	char *vg = NULL, *lv = NULL, *layer;
 	int r;
+	struct env_data *env_data;
+	const char *env = NULL;
 
 	if (!dm_split_lvm_name(mem, device, &vg, &lv, &layer)) {
 		log_error("Unable to determine VG name from %s.",
@@ -137,18 +147,36 @@ int dmeventd_lvm2_command(struct dm_pool *mem, char *buffer, size_t size,
 		*layer = '\0';
 
 	if (!strncmp(cmd, _internal_prefix, sizeof(_internal_prefix) - 1)) {
-		dmeventd_lvm2_lock();
-		/* output of internal command passed via env var */
-		if (!dmeventd_lvm2_run(cmd))
-			cmd = NULL;
-		else if ((cmd = getenv(cmd)))
-			cmd = dm_pool_strdup(mem, cmd); /* copy with lock */
-		dmeventd_lvm2_unlock();
+		/* check if ENVVAR wasn't already resolved */
+		dm_list_iterate_items(env_data, &_env_registry)
+			if (!strcmp(cmd, env_data->cmd)) {
+				env = env_data->data;
+				break;
+			}
 
-		if (!cmd) {
-			log_error("Unable to find configured command.");
-			return 0;
+		if (!env) {
+			/* run lvm2 command to find out setting value */
+			dmeventd_lvm2_lock();
+			if (!dmeventd_lvm2_run(cmd) ||
+			    !(env = getenv(cmd))) {
+				dmeventd_lvm2_unlock();
+				log_error("Unable to find configured command.");
+				return 0;
+			}
+			/* output of internal command passed via env var */
+			env = dm_pool_strdup(_mem_pool, env); /* copy with lock */
+			dmeventd_lvm2_unlock();
+			if (!env ||
+			    !(env_data = dm_pool_zalloc(_mem_pool, sizeof(*env_data))) ||
+			    !(env_data->cmd = dm_pool_strdup(_mem_pool, cmd))) {
+				log_error("Unable to allocate env memory.");
+				return 0;
+			}
+			env_data->data = env;
+			/* add to ENVVAR registry */
+			dm_list_add(&_env_registry, &env_data->list);
 		}
+		cmd = env;
 	}
 
 	r = dm_snprintf(buffer, size, "%s %s/%s", cmd, vg, lv);

daemons/dmeventd/plugins/mirror/Makefile.in

@@ -16,8 +16,8 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-INCLUDES += -I$(top_srcdir)/daemons/dmeventd/plugins/lvm2
 CLDFLAGS += -L$(top_builddir)/daemons/dmeventd/plugins/lvm2
+LIBS += -ldevmapper-event-lvm2
 
 SOURCES = dmeventd_mirror.c
 
@@ -30,8 +30,6 @@ CFLOW_LIST_TARGET = $(LIB_NAME).cflow
 
 include $(top_builddir)/make.tmpl
 
-LIBS += -ldevmapper-event-lvm2 $(INTERNAL_LIBS)
-
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -13,8 +13,8 @@
  */
 
 #include "lib/misc/lib.h"
+#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
 #include "daemons/dmeventd/libdevmapper-event.h"
-#include "dmeventd_lvm.h"
 #include "lib/activate/activate.h"
 
 /* FIXME Reformat to 80 char lines. */

daemons/dmeventd/plugins/raid/Makefile.in

@@ -15,8 +15,8 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-INCLUDES += -I$(top_srcdir)/daemons/dmeventd/plugins/lvm2
 CLDFLAGS += -L$(top_builddir)/daemons/dmeventd/plugins/lvm2
+LIBS += -ldevmapper-event-lvm2
 
 SOURCES = dmeventd_raid.c
 
@@ -29,8 +29,6 @@ CFLOW_LIST_TARGET = $(LIB_NAME).cflow
 
 include $(top_builddir)/make.tmpl
 
-LIBS += -ldevmapper-event-lvm2 $(INTERNAL_LIBS)
-
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/raid/dmeventd_raid.c

@@ -13,9 +13,9 @@
  */
 
 #include "lib/misc/lib.h"
-#include "lib/config/defaults.h"
-#include "dmeventd_lvm.h"
+#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
 #include "daemons/dmeventd/libdevmapper-event.h"
+#include "lib/config/defaults.h"
 
 /* Hold enough elements for the mximum number of RAID images */
 #define	RAID_DEVS_ELEMS	((DEFAULT_RAID_MAX_IMAGES + 63) / 64)
@@ -76,14 +76,17 @@ static int _process_raid_event(struct dso_state *state, char *params, const char
 	}
 
 	if (dead) {
-		if (status->insync_regions < status->total_regions) {
-			if (!state->warned) {
-				state->warned = 1;
-				log_warn("WARNING: waiting for resynchronization to finish "
-					 "before initiating repair on RAID device %s.", device);
-			}
-
-			goto out; /* Not yet done syncing with accessible devices */
+		/*
+		 * Use the first event to run a repair ignoring any additonal ones.
+		 *
+		 * We presume lvconvert to do pre-repair
+		 * checks to avoid bloat in this plugin.
+		 */
+		if (!state->warned && status->insync_regions < status->total_regions) {
+			state->warned = 1;
+			log_warn("WARNING: waiting for resynchronization to finish "
+				 "before initiating repair on RAID device %s.", device);
+			/* Fall through to allow lvconvert to run. */
 		}
 
 		if (state->failed)

daemons/dmeventd/plugins/snapshot/Makefile.in

@@ -16,8 +16,8 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-INCLUDES += -I$(top_srcdir)/daemons/dmeventd/plugins/lvm2
 CLDFLAGS += -L$(top_builddir)/daemons/dmeventd/plugins/lvm2
+LIBS += -ldevmapper-event-lvm2
 
 SOURCES = dmeventd_snapshot.c
 
@@ -26,8 +26,6 @@ LIB_VERSION = $(LIB_VERSION_LVM)
 
 include $(top_builddir)/make.tmpl
 
-LIBS += -ldevmapper-event-lvm2 $(INTERNAL_LIBS)
-
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/snapshot/dmeventd_snapshot.c

@@ -13,7 +13,7 @@
  */
 
 #include "lib/misc/lib.h"
-#include "dmeventd_lvm.h"
+#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
 #include "daemons/dmeventd/libdevmapper-event.h"
 
 #include <sys/sysmacros.h>
@@ -175,6 +175,7 @@ void process_event(struct dm_task *dmt,
 	const char *device = dm_task_get_name(dmt);
 	int percent;
 	struct dm_info info;
+	int ret;
 
 	/* No longer monitoring, waiting for remove */
 	if (!state->percent_check)
@@ -205,7 +206,8 @@ void process_event(struct dm_task *dmt,
 		/* Maybe configurable ? */
 		_remove(dm_task_get_uuid(dmt));
 #endif
-		pthread_kill(pthread_self(), SIGALRM);
+		if ((ret = pthread_kill(pthread_self(), SIGALRM)) && (ret != ESRCH))
+			log_sys_error("pthread_kill", "self");
 		goto out;
 	}
 
@@ -213,7 +215,8 @@ void process_event(struct dm_task *dmt,
 		/* TODO eventually recognize earlier when room is enough */
 		log_info("Dropping monitoring of fully provisioned snapshot %s.",
 			 device);
-		pthread_kill(pthread_self(), SIGALRM);
+		if ((ret = pthread_kill(pthread_self(), SIGALRM)) && (ret != ESRCH))
+			log_sys_error("pthread_kill", "self");
 		goto out;
 	}
 

daemons/dmeventd/plugins/thin/Makefile.in

@@ -15,8 +15,8 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-INCLUDES += -I$(top_srcdir)/daemons/dmeventd/plugins/lvm2
 CLDFLAGS += -L$(top_builddir)/daemons/dmeventd/plugins/lvm2
+LIBS += -ldevmapper-event-lvm2
 
 SOURCES = dmeventd_thin.c
 
@@ -29,8 +29,6 @@ CFLOW_LIST_TARGET = $(LIB_NAME).cflow
 
 include $(top_builddir)/make.tmpl
 
-LIBS += -ldevmapper-event-lvm2 $(INTERNAL_LIBS)
-
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/thin/dmeventd_thin.c

@@ -13,7 +13,7 @@
  */
 
 #include "lib/misc/lib.h"
-#include "dmeventd_lvm.h"
+#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
 #include "daemons/dmeventd/libdevmapper-event.h"
 
 #include <sys/wait.h>
@@ -286,7 +286,7 @@ void process_event(struct dm_task *dmt,
 		if (state->fails++ <= state->max_fails) {
 			log_debug("Postponing frequently failing policy (%u <= %u).",
 				  state->fails - 1, state->max_fails);
-			return;
+			goto out;
 		}
 		if (state->max_fails < MAX_FAILS)
 			state->max_fails <<= 1;

daemons/dmeventd/plugins/vdo/Makefile.in

@@ -15,8 +15,8 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-INCLUDES += -I$(top_srcdir)/daemons/dmeventd/plugins/lvm2
 CLDFLAGS += -L$(top_builddir)/daemons/dmeventd/plugins/lvm2
+LIBS += -ldevmapper-event-lvm2
 
 SOURCES = dmeventd_vdo.c
 
@@ -29,8 +29,6 @@ CFLOW_LIST_TARGET = $(LIB_NAME).cflow
 
 include $(top_builddir)/make.tmpl
 
-LIBS += -ldevmapper-event-lvm2 $(INTERNAL_LIBS)
-
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/vdo/dmeventd_vdo.c

@@ -13,9 +13,16 @@
  */
 
 #include "lib/misc/lib.h"
-#include "dmeventd_lvm.h"
+#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
 #include "daemons/dmeventd/libdevmapper-event.h"
-#include "device_mapper/vdo/target.h"
+
+/*
+ * Use parser from new device_mapper library.
+ * Although during compilation we can see dm_vdo_status_parse()
+ * in runtime we are linked agains systems libdm 'older' library
+ * which does not provide this symbol and plugin fails to load
+ */
+#include "device_mapper/vdo/status.c"
 
 #include <sys/wait.h>
 #include <stdarg.h>
@@ -245,7 +252,7 @@ void process_event(struct dm_task *dmt,
 		if (state->fails++ <= state->max_fails) {
 			log_debug("Postponing frequently failing policy (%u <= %u).",
 				  state->fails - 1, state->max_fails);
-			return;
+			goto out;
 		}
 		if (state->max_fails < MAX_FAILS)
 			state->max_fails <<= 1;
@@ -253,8 +260,7 @@ void process_event(struct dm_task *dmt,
 	} else
 		state->max_fails = 1; /* Reset on success */
 
-	/* FIXME: ATM nothing can be done, drop 0, once it becomes useful */
-	if (0 && needs_policy)
+	if (needs_policy)
 		_use_policy(dmt, state);
 out:
 	if (vdop.status)

daemons/lvmdbusd/Makefile.in

@@ -23,11 +23,10 @@ LVMDBUS_SRCDIR_FILES = \
 	cfg.py \
 	cmdhandler.py \
 	fetch.py \
-	__init__.py \
 	job.py \
 	loader.py \
-	main.py \
 	lv.py \
+	main.py \
 	manager.py \
 	objectmanager.py \
 	pv.py \
@@ -35,7 +34,8 @@ LVMDBUS_SRCDIR_FILES = \
 	state.py \
 	udevwatch.py \
 	utils.py \
-	vg.py
+	vg.py \
+	__init__.py
 
 LVMDBUS_BUILDDIR_FILES = \
 	lvmdb.py \
@@ -51,17 +51,18 @@ include $(top_builddir)/make.tmpl
 .PHONY: install_lvmdbusd
 
 all:
-	test -x $(LVMDBUSD) || chmod 755 $(LVMDBUSD)
+	$(Q) test -x $(LVMDBUSD) || chmod 755 $(LVMDBUSD)
 
 install_lvmdbusd:
-	$(INSTALL_DIR) $(sbindir)
-	$(INSTALL_SCRIPT) $(LVMDBUSD) $(sbindir)
-	$(INSTALL_DIR) $(DESTDIR)$(lvmdbusdir)
-	(cd $(srcdir); $(INSTALL_DATA) $(LVMDBUS_SRCDIR_FILES) $(DESTDIR)$(lvmdbusdir))
-	$(INSTALL_DATA) $(LVMDBUS_BUILDDIR_FILES) $(DESTDIR)$(lvmdbusdir)
-	PYTHON=$(PYTHON3) $(PYCOMPILE) --destdir "$(DESTDIR)" --basedir "$(lvmdbusdir)" $(LVMDBUS_SRCDIR_FILES) $(LVMDBUS_BUILDDIR_FILES)
-	$(CHMOD) 755 $(DESTDIR)$(lvmdbusdir)/__pycache__
-	$(CHMOD) 444 $(DESTDIR)$(lvmdbusdir)/__pycache__/*.py[co]
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_DIR) $(sbindir)
+	$(Q) $(INSTALL_SCRIPT) $(LVMDBUSD) $(sbindir)
+	$(Q) $(INSTALL_DIR) $(DESTDIR)$(lvmdbusdir)
+	$(Q) (cd $(srcdir); $(INSTALL_DATA) $(LVMDBUS_SRCDIR_FILES) $(DESTDIR)$(lvmdbusdir))
+	$(Q) $(INSTALL_DATA) $(LVMDBUS_BUILDDIR_FILES) $(DESTDIR)$(lvmdbusdir)
+	$(Q) PYTHON=$(PYTHON3) $(PYCOMPILE) --destdir "$(DESTDIR)" --basedir "$(lvmdbusdir)" $(LVMDBUS_SRCDIR_FILES) $(LVMDBUS_BUILDDIR_FILES)
+	$(Q) $(CHMOD) 755 $(DESTDIR)$(lvmdbusdir)/__pycache__
+	$(Q) $(CHMOD) 444 $(DESTDIR)$(lvmdbusdir)/__pycache__/*.py[co]
 
 install_lvm2: install_lvmdbusd
 

daemons/lvmdbusd/automatedproperties.py

@@ -155,7 +155,7 @@ class AutomatedProperties(dbus.service.Object):
 		# through all dbus objects as some don't have a search method, like
 		# 'Manager' object.
 		if not self._ap_search_method:
-			return
+			return 0
 
 		search = self.lvm_id
 		if search_key:

daemons/lvmdbusd/cfg.py

@@ -47,9 +47,11 @@ BUS_NAME = os.getenv('LVM_DBUS_NAME', 'com.redhat.lvmdbus1')
 BASE_INTERFACE = 'com.redhat.lvmdbus1'
 PV_INTERFACE = BASE_INTERFACE + '.Pv'
 VG_INTERFACE = BASE_INTERFACE + '.Vg'
+VG_VDO_INTERFACE = BASE_INTERFACE + '.VgVdo'
 LV_INTERFACE = BASE_INTERFACE + '.Lv'
 LV_COMMON_INTERFACE = BASE_INTERFACE + '.LvCommon'
 THIN_POOL_INTERFACE = BASE_INTERFACE + '.ThinPool'
+VDO_POOL_INTERFACE = BASE_INTERFACE + '.VdoPool'
 CACHE_POOL_INTERFACE = BASE_INTERFACE + '.CachePool'
 LV_CACHED = BASE_INTERFACE + '.CachedLv'
 SNAPSHOT_INTERFACE = BASE_INTERFACE + '.Snapshot'
@@ -61,6 +63,7 @@ PV_OBJ_PATH = BASE_OBJ_PATH + '/Pv'
 VG_OBJ_PATH = BASE_OBJ_PATH + '/Vg'
 LV_OBJ_PATH = BASE_OBJ_PATH + '/Lv'
 THIN_POOL_PATH = BASE_OBJ_PATH + "/ThinPool"
+VDO_POOL_PATH = BASE_OBJ_PATH + "/VdoPool"
 CACHE_POOL_PATH = BASE_OBJ_PATH + "/CachePool"
 HIDDEN_LV_PATH = BASE_OBJ_PATH + "/HiddenLv"
 MANAGER_OBJ_PATH = BASE_OBJ_PATH + '/Manager'
@@ -71,6 +74,7 @@ pv_id = itertools.count()
 vg_id = itertools.count()
 lv_id = itertools.count()
 thin_id = itertools.count()
+vdo_id = itertools.count()
 cache_pool_id = itertools.count()
 job_id = itertools.count()
 hidden_lv = itertools.count()
@@ -79,6 +83,9 @@ hidden_lv = itertools.count()
 load = None
 event = None
 
+# Boolean to denote if lvm supports VDO integration
+vdo_support = False
+
 # Global cached state
 db = None
 
@@ -87,3 +94,13 @@ blackbox = None
 
 # RequestEntry ctor
 create_request_entry = None
+
+
+def exit_daemon():
+    """
+    Exit the daemon cleanly
+    :return:
+    """
+    if run and loop:
+        run.value = 0
+        loop.quit()

daemons/lvmdbusd/cmdhandler.py

@@ -67,7 +67,7 @@ class LvmFlightRecorder(object):
 		with cmd_lock:
 			if len(self.queue):
 				log_error("LVM dbus flight recorder START")
-				for c in self.queue:
+				for c in reversed(self.queue):
 					log_error(str(c))
 				log_error("LVM dbus flight recorder END")
 
@@ -217,7 +217,10 @@ def options_to_cli_args(options):
 		else:
 			rc.append("--%s" % k)
 		if v != "":
-			rc.append(str(v))
+			if isinstance(v, int):
+				rc.append(str(int(v)))
+			else:
+				rc.append(str(v))
 	return rc
 
 
@@ -263,10 +266,10 @@ def lv_tag(lv_name, add, rm, tag_options):
 	return _tag('lvchange', lv_name, add, rm, tag_options)
 
 
-def vg_rename(vg, new_name, rename_options):
+def vg_rename(vg_uuid, new_name, rename_options):
 	cmd = ['vgrename']
 	cmd.extend(options_to_cli_args(rename_options))
-	cmd.extend([vg, new_name])
+	cmd.extend([vg_uuid, new_name])
 	return call(cmd)
 
 
@@ -280,7 +283,7 @@ def vg_remove(vg_name, remove_options):
 def vg_lv_create(vg_name, create_options, name, size_bytes, pv_dests):
 	cmd = ['lvcreate']
 	cmd.extend(options_to_cli_args(create_options))
-	cmd.extend(['--size', str(size_bytes) + 'B'])
+	cmd.extend(['--size', '%dB' % size_bytes])
 	cmd.extend(['--name', name, vg_name, '--yes'])
 	pv_dest_ranges(cmd, pv_dests)
 	return call(cmd)
@@ -292,7 +295,7 @@ def vg_lv_snapshot(vg_name, snapshot_options, name, size_bytes):
 	cmd.extend(["-s"])
 
 	if size_bytes != 0:
-		cmd.extend(['--size', str(size_bytes) + 'B'])
+		cmd.extend(['--size', '%dB' % size_bytes])
 
 	cmd.extend(['--name', name, vg_name])
 	return call(cmd)
@@ -303,9 +306,9 @@ def _vg_lv_create_common_cmd(create_options, size_bytes, thin_pool):
 	cmd.extend(options_to_cli_args(create_options))
 
 	if not thin_pool:
-		cmd.extend(['--size', str(size_bytes) + 'B'])
+		cmd.extend(['--size', '%dB' % size_bytes])
 	else:
-		cmd.extend(['--thin', '--size', str(size_bytes) + 'B'])
+		cmd.extend(['--thin', '--size', '%dB' % size_bytes])
 
 	cmd.extend(['--yes'])
 	return cmd
@@ -320,10 +323,10 @@ def vg_lv_create_linear(vg_name, create_options, name, size_bytes, thin_pool):
 def vg_lv_create_striped(vg_name, create_options, name, size_bytes,
 							num_stripes, stripe_size_kb, thin_pool):
 	cmd = _vg_lv_create_common_cmd(create_options, size_bytes, thin_pool)
-	cmd.extend(['--stripes', str(num_stripes)])
+	cmd.extend(['--stripes', str(int(num_stripes))])
 
 	if stripe_size_kb != 0:
-		cmd.extend(['--stripesize', str(stripe_size_kb)])
+		cmd.extend(['--stripesize', str(int(stripe_size_kb))])
 
 	cmd.extend(['--name', name, vg_name])
 	return call(cmd)
@@ -336,13 +339,13 @@ def _vg_lv_create_raid(vg_name, create_options, name, raid_type, size_bytes,
 	cmd.extend(options_to_cli_args(create_options))
 
 	cmd.extend(['--type', raid_type])
-	cmd.extend(['--size', str(size_bytes) + 'B'])
+	cmd.extend(['--size', '%dB' % size_bytes])
 
 	if num_stripes != 0:
-		cmd.extend(['--stripes', str(num_stripes)])
+		cmd.extend(['--stripes', str(int(num_stripes))])
 
 	if stripe_size_kb != 0:
-		cmd.extend(['--stripesize', str(stripe_size_kb)])
+		cmd.extend(['--stripesize', str(int(stripe_size_kb))])
 
 	cmd.extend(['--name', name, vg_name, '--yes'])
 	return call(cmd)
@@ -363,8 +366,8 @@ def vg_lv_create_mirror(
 	cmd.extend(options_to_cli_args(create_options))
 
 	cmd.extend(['--type', 'mirror'])
-	cmd.extend(['--mirrors', str(num_copies)])
-	cmd.extend(['--size', str(size_bytes) + 'B'])
+	cmd.extend(['--mirrors', str(int(num_copies))])
+	cmd.extend(['--size', '%dB' % size_bytes])
 	cmd.extend(['--name', name, vg_name, '--yes'])
 	return call(cmd)
 
@@ -385,6 +388,16 @@ def vg_create_thin_pool(md_full_name, data_full_name, create_options):
 	return call(cmd)
 
 
+def vg_create_vdo_pool_lv_and_lv(vg_name, pool_name, lv_name, data_size,
+									virtual_size, create_options):
+	cmd = ['lvcreate']
+	cmd.extend(options_to_cli_args(create_options))
+	cmd.extend(['-y', '--type', 'vdo', '-n', lv_name,
+				'-L', '%dB' % data_size, '-V', '%dB' % virtual_size,
+				"%s/%s" % (vg_name, pool_name)])
+	return call(cmd)
+
+
 def lv_remove(lv_path, remove_options):
 	cmd = ['lvremove']
 	cmd.extend(options_to_cli_args(remove_options))
@@ -418,7 +431,7 @@ def lv_resize(lv_full_name, size_change, pv_dests,
 def lv_lv_create(lv_full_name, create_options, name, size_bytes):
 	cmd = ['lvcreate']
 	cmd.extend(options_to_cli_args(create_options))
-	cmd.extend(['--virtualsize', str(size_bytes) + 'B', '-T'])
+	cmd.extend(['--virtualsize', '%dB' % size_bytes, '-T'])
 	cmd.extend(['--name', name, lv_full_name, '--yes'])
 	return call(cmd)
 
@@ -459,6 +472,16 @@ def supports_json():
 	return False
 
 
+def supports_vdo():
+	cmd = ['segtypes']
+	rc, out, err = call(cmd)
+	if rc == 0:
+		if "vdo" in out:
+			log_debug("We have VDO support")
+			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',
@@ -486,6 +509,22 @@ def lvm_full_report_json():
 
 	lv_seg_columns = ['seg_pe_ranges', 'segtype', 'lv_uuid']
 
+	if cfg.vdo_support:
+		lv_columns.extend(
+			['vdo_operating_mode', 'vdo_compression_state', 'vdo_index_state',
+				'vdo_used_size', 'vdo_saving_percent']
+		)
+
+		lv_seg_columns.extend(
+			['vdo_compression', 'vdo_deduplication',
+				'vdo_use_metadata_hints', 'vdo_minimum_io_size',
+				'vdo_block_map_cache_size', 'vdo_block_map_era_length',
+				'vdo_use_sparse_index', 'vdo_index_memory_size',
+				'vdo_slab_size', 'vdo_ack_threads', 'vdo_bio_threads',
+				'vdo_bio_rotation', 'vdo_cpu_threads', 'vdo_hash_zone_threads',
+				'vdo_logical_threads', 'vdo_physical_threads',
+				'vdo_max_discard', 'vdo_write_policy', 'vdo_header_size'])
+
 	cmd = _dc('fullreport', [
 		'-a',		# Need hidden too
 		'--configreport', 'pv', '-o', ','.join(pv_columns),
@@ -497,7 +536,8 @@ def lvm_full_report_json():
 	])
 
 	rc, out, err = call(cmd)
-	if rc == 0:
+	# When we have an exported vg the exit code of lvs or fullreport will be 5
+	if rc == 0 or rc == 5:
 		# 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
@@ -555,7 +595,7 @@ def pv_resize(device, size_bytes, create_options):
 	cmd.extend(options_to_cli_args(create_options))
 
 	if size_bytes != 0:
-		cmd.extend(['--yes', '--setphysicalvolumesize', str(size_bytes) + 'B'])
+		cmd.extend(['--yes', '--setphysicalvolumesize', '%dB' % size_bytes])
 
 	cmd.extend([device])
 	return call(cmd)
@@ -651,12 +691,12 @@ def vg_allocation_policy(vg_name, policy, policy_options):
 
 
 def vg_max_pv(vg_name, number, max_options):
-	return _vg_value_set(vg_name, ['--maxphysicalvolumes', str(number)],
+	return _vg_value_set(vg_name, ['--maxphysicalvolumes', str(int(number))],
 							max_options)
 
 
 def vg_max_lv(vg_name, number, max_options):
-	return _vg_value_set(vg_name, ['-l', str(number)], max_options)
+	return _vg_value_set(vg_name, ['-l', str(int(number))], max_options)
 
 
 def vg_uuid_gen(vg_name, ignore, options):
@@ -698,6 +738,7 @@ def activate_deactivate(op, name, activate, control_flags, options):
 		op += 'n'
 
 	cmd.append(op)
+	cmd.append("-y")
 	cmd.append(name)
 	return call(cmd)
 

daemons/lvmdbusd/fetch.py

@@ -14,6 +14,7 @@ from . import cfg
 from .utils import MThreadRunner, log_debug, log_error
 import threading
 import queue
+import time
 import traceback
 
 
@@ -28,11 +29,26 @@ def _main_thread_load(refresh=True, emit_signal=True):
 		refresh=refresh,
 		emit_signal=emit_signal,
 		cache_refresh=False)[1]
-	num_total_changes += load_lvs(
+
+	lv_changes = load_lvs(
 		refresh=refresh,
 		emit_signal=emit_signal,
 		cache_refresh=False)[1]
 
+	num_total_changes += lv_changes
+
+	# When the LVs change it can cause another change in the VGs which is
+	# missed if we don't scan through the VGs again.  We could achieve this
+	# the other way and re-scan the LVs, but in general there are more LVs than
+	# VGs, thus this should be more efficient.  This happens when a LV interface
+	# changes causing the dbus object representing it to be removed and
+	# recreated.
+	if refresh and lv_changes > 0:
+		num_total_changes += load_vgs(
+			refresh=refresh,
+			emit_signal=emit_signal,
+			cache_refresh=False)[1]
+
 	return num_total_changes
 
 
@@ -82,6 +98,8 @@ class StateUpdate(object):
 
 	@staticmethod
 	def update_thread(obj):
+		exception_count = 0
+
 		queued_requests = []
 		while cfg.run.value != 0:
 			# noinspection PyBroadException
@@ -136,12 +154,26 @@ class StateUpdate(object):
 				# wake up if we get an exception
 				queued_requests = []
 
+				# We retrieved OK, clear exception count
+				exception_count = 0
+
 			except queue.Empty:
 				pass
-			except Exception:
+			except Exception as e:
 				st = traceback.format_exc()
 				log_error("update_thread exception: \n%s" % st)
 				cfg.blackbox.dump()
+				exception_count += 1
+				if exception_count >= 5:
+					for i in queued_requests:
+						i.set_result(e)
+
+					log_error("Too many errors in update_thread, exiting daemon")
+					cfg.exit_daemon()
+
+				else:
+					# Slow things down when encountering errors
+					time.sleep(1)
 
 	def __init__(self):
 		self.lock = threading.RLock()

daemons/lvmdbusd/lv.py

@@ -10,20 +10,22 @@
 from .automatedproperties import AutomatedProperties
 
 from . import utils
-from .utils import vg_obj_path_generate
+from .utils import vg_obj_path_generate, log_error, _handle_execute
 import dbus
 from . import cmdhandler
 from . import cfg
 from .cfg import LV_INTERFACE, THIN_POOL_INTERFACE, SNAPSHOT_INTERFACE, \
-	LV_COMMON_INTERFACE, CACHE_POOL_INTERFACE, LV_CACHED
+	LV_COMMON_INTERFACE, CACHE_POOL_INTERFACE, LV_CACHED, VDO_POOL_INTERFACE
 from .request import RequestEntry
-from .utils import n, n32
+from .utils import n, n32, d
 from .loader import common
 from .state import State
 from . import background
 from .utils import round_size, mt_remove_dbus_objects
 from .job import JobState
 
+import traceback
+
 
 # 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
@@ -72,23 +74,66 @@ def lvs_state_retrieve(selection, cache_refresh=True):
 	lvs = sorted(cfg.db.fetch_lvs(selection), key=get_key)
 
 	for l in lvs:
-		rc.append(LvState(
-			l['lv_uuid'], l['lv_name'],
-			l['lv_path'], n(l['lv_size']),
-			l['vg_name'],
-			l['vg_uuid'], l['pool_lv_uuid'],
-			l['pool_lv'], l['origin_uuid'], l['origin'],
-			n32(l['data_percent']), l['lv_attr'],
-			l['lv_tags'], l['lv_active'], l['data_lv'],
-			l['metadata_lv'], l['segtype'], l['lv_role'],
-			l['lv_layout'],
-			n32(l['snap_percent']),
-			n32(l['metadata_percent']),
-			n32(l['copy_percent']),
-			n32(l['sync_percent']),
-			n(l['lv_metadata_size']),
-			l['move_pv'],
-			l['move_pv_uuid']))
+		if cfg.vdo_support:
+			rc.append(LvStateVdo(
+				l['lv_uuid'], l['lv_name'],
+				l['lv_path'], n(l['lv_size']),
+				l['vg_name'],
+				l['vg_uuid'], l['pool_lv_uuid'],
+				l['pool_lv'], l['origin_uuid'], l['origin'],
+				n32(l['data_percent']), l['lv_attr'],
+				l['lv_tags'], l['lv_active'], l['data_lv'],
+				l['metadata_lv'], l['segtype'], l['lv_role'],
+				l['lv_layout'],
+				n32(l['snap_percent']),
+				n32(l['metadata_percent']),
+				n32(l['copy_percent']),
+				n32(l['sync_percent']),
+				n(l['lv_metadata_size']),
+				l['move_pv'],
+				l['move_pv_uuid'],
+				l['vdo_operating_mode'],
+				l['vdo_compression_state'],
+				l['vdo_index_state'],
+				n(l['vdo_used_size']),
+				d(l['vdo_saving_percent']),
+				l['vdo_compression'],
+				l['vdo_deduplication'],
+				l['vdo_use_metadata_hints'],
+				n32(l['vdo_minimum_io_size']),
+				n(l['vdo_block_map_cache_size']),
+				n32(l['vdo_block_map_era_length']),
+				l['vdo_use_sparse_index'],
+				n(l['vdo_index_memory_size']),
+				n(l['vdo_slab_size']),
+				n32(l['vdo_ack_threads']),
+				n32(l['vdo_bio_threads']),
+				n32(l['vdo_bio_rotation']),
+				n32(l['vdo_cpu_threads']),
+				n32(l['vdo_hash_zone_threads']),
+				n32(l['vdo_logical_threads']),
+				n32(l['vdo_physical_threads']),
+				n32(l['vdo_max_discard']),
+				l['vdo_write_policy'],
+				n32(l['vdo_header_size'])))
+		else:
+			rc.append(LvState(
+				l['lv_uuid'], l['lv_name'],
+				l['lv_path'], n(l['lv_size']),
+				l['vg_name'],
+				l['vg_uuid'], l['pool_lv_uuid'],
+				l['pool_lv'], l['origin_uuid'], l['origin'],
+				n32(l['data_percent']), l['lv_attr'],
+				l['lv_tags'], l['lv_active'], l['data_lv'],
+				l['metadata_lv'], l['segtype'], l['lv_role'],
+				l['lv_layout'],
+				n32(l['snap_percent']),
+				n32(l['metadata_percent']),
+				n32(l['copy_percent']),
+				n32(l['sync_percent']),
+				n(l['lv_metadata_size']),
+				l['move_pv'],
+				l['move_pv_uuid']))
 	return rc
 
 
@@ -192,6 +237,8 @@ class LvState(State):
 	def _object_type_create(self):
 		if self.Attr[0] == 't':
 			return LvThinPool
+		elif self.Attr[0] == 'd':
+			return LvVdoPool
 		elif self.Attr[0] == 'C':
 			if 'pool' in self.layout:
 				return LvCachePool
@@ -218,6 +265,34 @@ class LvState(State):
 		return (klass, path_method)
 
 
+class LvStateVdo(LvState):
+
+	def __init__(self, Uuid, Name, Path, SizeBytes,
+					vg_name, vg_uuid, pool_lv_uuid, PoolLv,
+					origin_uuid, OriginLv, DataPercent, Attr, Tags, active,
+					data_lv, metadata_lv, segtypes, role, layout, SnapPercent,
+					MetaDataPercent, CopyPercent, SyncPercent,
+					MetaDataSizeBytes, move_pv, move_pv_uuid,
+					vdo_operating_mode, vdo_compression_state, vdo_index_state,
+					vdo_used_size,vdo_saving_percent,vdo_compression,
+					vdo_deduplication,vdo_use_metadata_hints,
+					vdo_minimum_io_size,vdo_block_map_cache_size,
+					vdo_block_map_era_length,vdo_use_sparse_index,
+					vdo_index_memory_size,vdo_slab_size,vdo_ack_threads,
+					vdo_bio_threads,vdo_bio_rotation,vdo_cpu_threads,
+					vdo_hash_zone_threads,vdo_logical_threads,
+					vdo_physical_threads,vdo_max_discard,
+					vdo_write_policy,vdo_header_size):
+		super(LvStateVdo, self).__init__(Uuid, Name, Path, SizeBytes,
+					vg_name, vg_uuid, pool_lv_uuid, PoolLv,
+					origin_uuid, OriginLv, DataPercent, Attr, Tags, active,
+					data_lv, metadata_lv, segtypes, role, layout, SnapPercent,
+					MetaDataPercent, CopyPercent, SyncPercent,
+					MetaDataSizeBytes, move_pv, move_pv_uuid)
+
+		utils.init_class_from_arguments(self, "vdo_", snake_to_pascal=True)
+
+
 # noinspection PyPep8Naming
 @utils.dbus_property(LV_COMMON_INTERFACE, 'Uuid', 's')
 @utils.dbus_property(LV_COMMON_INTERFACE, 'Name', 's')
@@ -273,13 +348,7 @@ class LvCommon(AutomatedProperties):
 
 	@staticmethod
 	def handle_execute(rc, out, err):
-		if rc == 0:
-			cfg.load()
-		else:
-			# Need to work on error handling, need consistent
-			raise dbus.exceptions.DBusException(
-				LV_INTERFACE,
-				'Exit code %s, stderr = %s' % (str(rc), err))
+		_handle_execute(rc, out, err, LV_INTERFACE)
 
 	@staticmethod
 	def validate_dbus_object(lv_uuid, lv_name):
@@ -291,6 +360,22 @@ class LvCommon(AutomatedProperties):
 				(lv_uuid, lv_name))
 		return dbo
 
+	def attr_struct(self, index, type_map, default='undisclosed'):
+		try:
+			if self.state.Attr[index] not in type_map:
+				log_error("LV %s %s with lv_attr %s, lv_attr[%d] = "
+					"'%s' is not known" %
+					(self.Uuid, self.Name, self.Attr, index,
+					self.state.Attr[index]))
+
+			return dbus.Struct((self.state.Attr[index],
+				type_map.get(self.state.Attr[index], default)),
+								signature="(ss)")
+		except BaseException:
+			st = traceback.format_exc()
+			log_error("attr_struct: \n%s" % st)
+			return dbus.Struct(('?', 'Unavailable'), signature="(ss)")
+
 	@property
 	def VolumeType(self):
 		type_map = {'C': 'Cache', 'm': 'mirrored',
@@ -303,17 +388,16 @@ class LvCommon(AutomatedProperties):
 					'l': 'mirror log device', 'c': 'under conversion',
 					'V': 'thin Volume', 't': 'thin pool', 'T': 'Thin pool data',
 					'e': 'raid or pool metadata or pool metadata spare',
+					'd': 'vdo pool', 'D': 'vdo pool data',
 					'-': 'Unspecified'}
-		return dbus.Struct((self.state.Attr[0], type_map[self.state.Attr[0]]),
-						signature="as")
+		return self.attr_struct(0, type_map)
 
 	@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.attr_struct(1, type_map)
 
 	@property
 	def AllocationPolicy(self):
@@ -322,8 +406,7 @@ 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.attr_struct(2, type_map)
 
 	@property
 	def FixedMinor(self):
@@ -331,15 +414,20 @@ class LvCommon(AutomatedProperties):
 
 	@property
 	def State(self):
-		type_map = {'a': 'active', 's': 'suspended', 'I': 'Invalid snapshot',
+		type_map = {'a': 'active',
+					's': 'suspended',
+					'I': 'Invalid snapshot',
 					'S': 'invalid Suspended snapshot',
 					'm': 'snapshot merge failed',
 					'M': 'suspended snapshot (M)erge failed',
 					'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)")
+					'h': 'historical',
+					'c': 'check needed suspended thin-pool',
+					'C': 'check needed',
+					'X': 'unknown',
+					'-': 'Unspecified'}
+		return self.attr_struct(4, type_map)
 
 	@property
 	def TargetType(self):
@@ -355,11 +443,18 @@ class LvCommon(AutomatedProperties):
 
 	@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)")
+		type_map = {'p': 'partial',
+					'r': 'refresh needed',
+					'm': 'mismatches',
+					'w': 'writemostly',
+					'X': 'unknown',
+					'-': 'unspecified',
+					's': 'reshaping',
+					'F': 'failed',
+					'D': 'Data space',
+					'R': 'Remove',
+					'M': 'Metadata'}
+		return self.attr_struct(8, type_map)
 
 	@property
 	def SkipActivation(self):
@@ -429,8 +524,7 @@ class Lv(LvCommon):
 		# Make sure we have a dbus object representing it
 		LvCommon.validate_dbus_object(lv_uuid, lv_name)
 		# Remove the LV, if successful then remove from the model
-		rc, out, err = cmdhandler.lv_remove(lv_name, remove_options)
-		LvCommon.handle_execute(rc, out, err)
+		LvCommon.handle_execute(*cmdhandler.lv_remove(lv_name, remove_options))
 		return '/'
 
 	@dbus.service.method(
@@ -450,9 +544,8 @@ class Lv(LvCommon):
 		# Make sure we have a dbus object representing it
 		LvCommon.validate_dbus_object(lv_uuid, lv_name)
 		# Rename the logical volume
-		rc, out, err = cmdhandler.lv_rename(lv_name, new_name,
-											rename_options)
-		LvCommon.handle_execute(rc, out, err)
+		LvCommon.handle_execute(*cmdhandler.lv_rename(lv_name, new_name,
+												rename_options))
 		return '/'
 
 	@dbus.service.method(
@@ -501,13 +594,11 @@ class Lv(LvCommon):
 				remainder = space % 512
 				optional_size = space + 512 - remainder
 
-		rc, out, err = cmdhandler.vg_lv_snapshot(
-			lv_name, snapshot_options, name, optional_size)
-		LvCommon.handle_execute(rc, out, err)
+		LvCommon.handle_execute(*cmdhandler.vg_lv_snapshot(
+			lv_name, snapshot_options,name, optional_size))
 		full_name = "%s/%s" % (dbo.vg_name_lookup(), name)
 		return cfg.om.get_object_path_by_lvm_id(full_name)
 
-
 	@dbus.service.method(
 		dbus_interface=LV_INTERFACE,
 		in_signature='stia{sv}',
@@ -543,9 +634,8 @@ class Lv(LvCommon):
 				pv_dests.append((pv_dbus_obj.lvm_id, pr[1], pr[2]))
 
 		size_change = new_size_bytes - dbo.SizeBytes
-		rc, out, err = cmdhandler.lv_resize(dbo.lvm_id, size_change,
-											pv_dests, resize_options)
-		LvCommon.handle_execute(rc, out, err)
+		LvCommon.handle_execute(*cmdhandler.lv_resize(
+			dbo.lvm_id, size_change,pv_dests, resize_options))
 		return "/"
 
 	@dbus.service.method(
@@ -580,9 +670,8 @@ class Lv(LvCommon):
 								options):
 		# Make sure we have a dbus object representing it
 		LvCommon.validate_dbus_object(uuid, lv_name)
-		rc, out, err = cmdhandler.activate_deactivate(
-			'lvchange', lv_name, activate, control_flags, options)
-		LvCommon.handle_execute(rc, out, err)
+		LvCommon.handle_execute(*cmdhandler.activate_deactivate(
+			'lvchange', lv_name, activate, control_flags, options))
 		return '/'
 
 	@dbus.service.method(
@@ -616,9 +705,8 @@ class Lv(LvCommon):
 	def _add_rm_tags(uuid, lv_name, tags_add, tags_del, tag_options):
 		# Make sure we have a dbus object representing it
 		LvCommon.validate_dbus_object(uuid, lv_name)
-		rc, out, err = cmdhandler.lv_tag(
-			lv_name, tags_add, tags_del, tag_options)
-		LvCommon.handle_execute(rc, out, err)
+		LvCommon.handle_execute(*cmdhandler.lv_tag(
+			lv_name, tags_add, tags_del, tag_options))
 		return '/'
 
 	@dbus.service.method(
@@ -655,6 +743,43 @@ class Lv(LvCommon):
 			cb, cbe, return_tuple=False)
 		cfg.worker_q.put(r)
 
+# noinspection PyPep8Naming
+@utils.dbus_property(VDO_POOL_INTERFACE, 'OperatingMode', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'CompressionState', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'IndexState', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'UsedSize', 't')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'SavingPercent', 'd')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'Compression', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'Deduplication', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'UseMetadataHints', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'MinimumIoSize', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'BlockMapCacheSize', "t")
+@utils.dbus_property(VDO_POOL_INTERFACE, 'BlockMapEraLength', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'UseSparseIndex', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'IndexMemorySize', 't')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'SlabSize', 't')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'AckThreads', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'BioThreads', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'BioRotation', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'CpuThreads', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'HashZoneThreads', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'LogicalThreads', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'PhysicalThreads', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'MaxDiscard', 'u')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'WritePolicy', 's')
+@utils.dbus_property(VDO_POOL_INTERFACE, 'HeaderSize', 'u')
+class LvVdoPool(Lv):
+	_DataLv_meta = ("o", VDO_POOL_INTERFACE)
+
+	def __init__(self, object_path, object_state):
+		super(LvVdoPool, self).__init__(object_path, object_state)
+		self.set_interface(VDO_POOL_INTERFACE)
+		self._data_lv, _ = self._get_data_meta()
+
+	@property
+	def DataLv(self):
+		return dbus.ObjectPath(self._data_lv)
+
 
 # noinspection PyPep8Naming
 class LvThinPool(Lv):
@@ -678,10 +803,8 @@ class LvThinPool(Lv):
 	def _lv_create(lv_uuid, lv_name, name, size_bytes, create_options):
 		# Make sure we have a dbus object representing it
 		dbo = LvCommon.validate_dbus_object(lv_uuid, lv_name)
-
-		rc, out, err = cmdhandler.lv_lv_create(
-			lv_name, create_options, name, size_bytes)
-		LvCommon.handle_execute(rc, out, err)
+		LvCommon.handle_execute(*cmdhandler.lv_lv_create(
+			lv_name, create_options, name, size_bytes))
 		full_name = "%s/%s" % (dbo.vg_name_lookup(), name)
 		return cfg.om.get_object_path_by_lvm_id(full_name)
 

daemons/lvmdbusd/lvm_shell_proxy.py.in

@@ -220,7 +220,10 @@ class LVMShellProxy(object):
 
 		# Parse the report to see what happened
 		if 'log' in report_json:
-			if report_json['log'][-1:][0]['log_ret_code'] == '1':
+			ret_code = int(report_json['log'][-1:][0]['log_ret_code'])
+			# If we have an exported vg we get a log_ret_code == 5 when
+			# we do a 'fullreport'
+			if (ret_code == 1) or (ret_code == 5 and argv[0] == 'fullreport'):
 				rc = 0
 			else:
 				error_msg = self.get_error_msg()

daemons/lvmdbusd/lvmdb.py.in

@@ -20,7 +20,7 @@ from lvmdbusd.utils import log_debug, log_error
 
 
 class DataStore(object):
-	def __init__(self, usejson=True):
+	def __init__(self, usejson=True, vdo_support=False):
 		self.pvs = {}
 		self.vgs = {}
 		self.lvs = {}
@@ -43,6 +43,8 @@ class DataStore(object):
 		else:
 			self.json = usejson
 
+		self.vdo_support = vdo_support
+
 	@staticmethod
 	def _insert_record(table, key, record, allowed_multiple):
 		if key in table:
@@ -141,13 +143,22 @@ class DataStore(object):
 
 	@staticmethod
 	def _parse_vgs(_vgs):
-		vgs = sorted(_vgs, key=lambda vk: vk['vg_name'])
+		vgs = sorted(_vgs, key=lambda vk: vk['vg_uuid'])
 
 		c_vgs = OrderedDict()
 		c_lookup = {}
 
 		for i in vgs:
-			c_lookup[i['vg_name']] = i['vg_uuid']
+			vg_name = i['vg_name']
+
+			# Lvm allows duplicate vg names.  When this occurs, each subsequent
+			# matching VG name will be called vg_name:vg_uuid.  Note: ':' is an
+			# invalid character for lvm VG names
+			if vg_name in c_lookup:
+				vg_name = "%s:%s" % (vg_name, i['vg_uuid'])
+				i['vg_name'] = vg_name
+
+			c_lookup[vg_name] = i['vg_uuid']
 			DataStore._insert_record(c_vgs, i['vg_uuid'], i, [])
 
 		return c_vgs, c_lookup
@@ -162,13 +173,22 @@ class DataStore(object):
 				tmp_vg.extend(r['vg'])
 
 		# Sort for consistent output, however this is optional
-		vgs = sorted(tmp_vg, key=lambda vk: vk['vg_name'])
+		vgs = sorted(tmp_vg, key=lambda vk: vk['vg_uuid'])
 
 		c_vgs = OrderedDict()
 		c_lookup = {}
 
 		for i in vgs:
-			c_lookup[i['vg_name']] = i['vg_uuid']
+			vg_name = i['vg_name']
+
+			# Lvm allows duplicate vg names.  When this occurs, each subsequent
+			# matching VG name will be called vg_name:vg_uuid.  Note: ':' is an
+			# invalid character for lvm VG names
+			if vg_name in c_lookup:
+				vg_name = "%s:%s" % (vg_name, i['vg_uuid'])
+				i['vg_name'] = vg_name
+
+			c_lookup[vg_name] = i['vg_uuid']
 			c_vgs[i['vg_uuid']] = i
 
 		return c_vgs, c_lookup
@@ -223,8 +243,7 @@ class DataStore(object):
 
 		return DataStore._parse_lvs_common(c_lvs, c_lv_full_lookup)
 
-	@staticmethod
-	def _parse_lvs_json(_all):
+	def _parse_lvs_json(self, _all):
 
 		c_lvs = OrderedDict()
 		c_lv_full_lookup = {}
@@ -244,8 +263,13 @@ class DataStore(object):
 				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('seg_pe_ranges', []).\
+							append(s['seg_pe_ranges'])
 						r.setdefault('segtype', []).append(s['segtype'])
+						if self.vdo_support:
+							for seg_key, seg_val in s.items():
+								if seg_key.startswith("vdo_"):
+									r[seg_key] = seg_val
 
 		return DataStore._parse_lvs_common(c_lvs, c_lv_full_lookup)
 
@@ -521,6 +545,10 @@ if __name__ == "__main__":
 	for v in ds.vgs.values():
 		pp.pprint(v)
 
+	print("VG name to UUID")
+	for k, v in ds.vg_name_to_uuid.items():
+		print("%s: %s" % (k, v))
+
 	print("LVS")
 	for v in ds.lvs.values():
 		pp.pprint(v)

daemons/lvmdbusd/main.py

@@ -29,7 +29,7 @@ from .utils import log_debug, log_error
 import argparse
 import os
 import sys
-from .cmdhandler import LvmFlightRecorder
+from .cmdhandler import LvmFlightRecorder, supports_vdo
 from .request import RequestEntry
 
 
@@ -44,10 +44,10 @@ def process_request():
 		try:
 			req = cfg.worker_q.get(True, 5)
 			log_debug(
-				"Running method: %s with args %s" %
-				(str(req.method), str(req.arguments)))
+				"Method start: %s with args %s (callback = %s)" %
+				(str(req.method), str(req.arguments), str(req.cb)))
 			req.run_cmd()
-			log_debug("Method complete ")
+			log_debug("Method complete: %s" % str(req.method))
 		except queue.Empty:
 			pass
 		except Exception:
@@ -127,6 +127,14 @@ def main():
 		log_error("You cannot specify --lvmshell and --nojson")
 		sys.exit(1)
 
+	# We will dynamically add interfaces which support vdo if it
+	# exists.
+	cfg.vdo_support = supports_vdo()
+
+	if cfg.vdo_support and not cfg.args.use_json:
+		log_error("You cannot specify --nojson when lvm has VDO support")
+		sys.exit(1)
+
 	# List of threads that we start up
 	thread_list = []
 
@@ -147,12 +155,12 @@ def main():
 	cfg.om = Lvm(BASE_OBJ_PATH)
 	cfg.om.register_object(Manager(MANAGER_OBJ_PATH))
 
-	cfg.db = lvmdb.DataStore(cfg.args.use_json)
+	cfg.db = lvmdb.DataStore(cfg.args.use_json, cfg.vdo_support)
 
 	# Using a thread to process requests, we cannot hang the dbus library
 	# thread that is handling the dbus interface
-	thread_list.append(threading.Thread(target=process_request,
-										name='process_request'))
+	thread_list.append(
+		threading.Thread(target=process_request, name='process_request'))
 
 	# Have a single thread handling updating lvm and the dbus model so we
 	# don't have multiple threads doing this as the same time

daemons/lvmdbusd/manager.py

@@ -107,10 +107,10 @@ class Manager(AutomatedProperties):
 		rc = cfg.load(log=False)
 
 		if rc != 0:
-			utils.log_debug('Manager.Refresh - exit %d' % (rc),
+			utils.log_debug('Manager.Refresh - exit %d %d' % (rc, lc),
 							'bg_black', 'fg_light_red')
 		else:
-			utils.log_debug('Manager.Refresh - exit %d' % (rc))
+			utils.log_debug('Manager.Refresh - exit %d %d' % (rc, lc))
 		return rc + lc
 
 	@dbus.service.method(
@@ -164,6 +164,8 @@ class Manager(AutomatedProperties):
 		return the object path in O(1) time.
 
 		:param key: The lookup value
+		:param cb:	dbus python call back parameter, not client visible
+		:param cbe:	dbus python error call back parameter, not client visible
 		:return: Return the object path.  If object not found you will get '/'
 		"""
 		r = RequestEntry(-1, Manager._lookup_by_lvm_id, (key,), cb, cbe, False)

daemons/lvmdbusd/objectmanager.py

@@ -189,8 +189,8 @@ class ObjectManager(AutomatedProperties):
 			path = dbus_object.dbus_object_path()
 			interfaces = dbus_object.interface()
 
-			# print 'UN-Registering object path %s for %s' % \
-			#      (path, dbus_object.lvm_id)
+			# print('UN-Registering object path %s for %s' %
+			#		(path, dbus_object.lvm_id))
 
 			self._lookup_remove(path)
 
@@ -240,39 +240,19 @@ class ObjectManager(AutomatedProperties):
 				return lookup_rc
 			return '/'
 
-	def _uuid_verify(self, path, uuid, lvm_id):
+	def _id_verify(self, path, uuid, lvm_id):
 		"""
-		Ensure uuid is present for a successful lvm_id lookup
+		Ensure our lookups are correct
 		NOTE: Internal call, assumes under object manager lock
 		:param path: 		Path to object we looked up
-		:param uuid: 		lvm uuid to verify
-		:param lvm_id:		lvm_id used to find object
+		:param uuid: 		uuid lookup
+		:param lvm_id:		lvm_id lookup
 		:return: None
 		"""
-		# This gets called when we found an object based on lvm_id, ensure
-		# uuid is correct too, as they can change. There is no durable
-		# non-changeable name in lvm
+		# There is no durable non-changeable name in lvm
 		if lvm_id != uuid:
-			if uuid and uuid not in self._id_to_object_path:
-				obj = self.get_object_by_path(path)
-				self._lookup_add(obj, path, lvm_id, uuid)
-
-	def _lvm_id_verify(self, path, uuid, lvm_id):
-		"""
-		Ensure lvm_id is present for a successful uuid lookup
-		NOTE: Internal call, assumes under object manager lock
-		:param path: 		Path to object we looked up
-		:param uuid: 		uuid used to find object
-		:param lvm_id:		lvm_id to verify
-		:return: None
-		"""
-		# This gets called when we found an object based on uuid, ensure
-		# lvm_id is correct too, as they can change.  There is no durable
-		# non-changeable name in lvm
-		if lvm_id != uuid:
-			if lvm_id and lvm_id not in self._id_to_object_path:
-				obj = self.get_object_by_path(path)
-				self._lookup_add(obj, path, lvm_id, uuid)
+			obj = self.get_object_by_path(path)
+			self._lookup_add(obj, path, lvm_id, uuid)
 
 	def _id_lookup(self, the_id):
 		path = None
@@ -339,22 +319,22 @@ class ObjectManager(AutomatedProperties):
 				# Lets check for the uuid first
 				path = self._id_lookup(uuid)
 				if path:
-					# Verify the lvm_id is sane
-					self._lvm_id_verify(path, uuid, lvm_id)
+					# Ensure table lookups are correct
+					self._id_verify(path, uuid, lvm_id)
 				else:
 					# Unable to find by UUID, lets lookup by lvm_id
 					path = self._id_lookup(lvm_id)
 					if path:
-						# Verify the uuid is sane
-						self._uuid_verify(path, uuid, lvm_id)
+						# Ensure table lookups are correct
+						self._id_verify(path, uuid, lvm_id)
 					else:
 						# We have exhausted all lookups, let's create if we can
 						if path_create:
 							path = path_create()
 							self._lookup_add(None, path, lvm_id, uuid)
 
-			# print('get_object_path_by_lvm_id(%s, %s, %s, %s: return %s' %
-			# 	   (uuid, lvm_id, str(path_create), str(gen_new), path))
+			# print('get_object_path_by_lvm_id(%s, %s, %s): return %s' %
+			#	(uuid, lvm_id, str(path_create), path))
 
 			return path
 

daemons/lvmdbusd/pv.py

@@ -14,7 +14,7 @@ import dbus
 from .cfg import PV_INTERFACE
 from . import cmdhandler
 from .utils import vg_obj_path_generate, n, pv_obj_path_generate, \
-	lv_object_path_method
+	lv_object_path_method, _handle_execute
 from .loader import common
 from .request import RequestEntry
 from .state import State
@@ -138,19 +138,12 @@ class Pv(AutomatedProperties):
 		# Remove the PV, if successful then remove from the model
 		# Make sure we have a dbus object representing it
 		Pv.validate_dbus_object(pv_uuid, pv_name)
-		rc, out, err = cmdhandler.pv_remove(pv_name, remove_options)
-		Pv.handle_execute(rc, out, err)
+		Pv.handle_execute(*cmdhandler.pv_remove(pv_name, remove_options))
 		return '/'
 
 	@staticmethod
 	def handle_execute(rc, out, err):
-		if rc == 0:
-			cfg.load()
-		else:
-			# Need to work on error handling, need consistent
-			raise dbus.exceptions.DBusException(
-				PV_INTERFACE,
-				'Exit code %s, stderr = %s' % (str(rc), err))
+		return _handle_execute(rc, out, err, PV_INTERFACE)
 
 	@staticmethod
 	def validate_dbus_object(pv_uuid, pv_name):
@@ -178,10 +171,8 @@ class Pv(AutomatedProperties):
 	def _resize(pv_uuid, pv_name, new_size_bytes, resize_options):
 		# Make sure we have a dbus object representing it
 		Pv.validate_dbus_object(pv_uuid, pv_name)
-
-		rc, out, err = cmdhandler.pv_resize(pv_name, new_size_bytes,
-												resize_options)
-		Pv.handle_execute(rc, out, err)
+		Pv.handle_execute(*cmdhandler.pv_resize(pv_name, new_size_bytes,
+												resize_options))
 		return '/'
 
 	@dbus.service.method(
@@ -200,9 +191,8 @@ class Pv(AutomatedProperties):
 	def _allocation_enabled(pv_uuid, pv_name, yes_no, allocation_options):
 		# Make sure we have a dbus object representing it
 		Pv.validate_dbus_object(pv_uuid, pv_name)
-		rc, out, err = cmdhandler.pv_allocatable(
-			pv_name, yes_no, allocation_options)
-		Pv.handle_execute(rc, out, err)
+		Pv.handle_execute(*cmdhandler.pv_allocatable(pv_name, yes_no,
+														allocation_options))
 		return '/'
 
 	@dbus.service.method(

daemons/lvmdbusd/utils.py

@@ -26,6 +26,15 @@ import signal
 STDOUT_TTY = os.isatty(sys.stdout.fileno())
 
 
+def _handle_execute(rc, out, err, interface):
+	if rc == 0:
+		cfg.load()
+	else:
+		# Need to work on error handling, need consistent
+		raise dbus.exceptions.DBusException(
+			interface, 'Exit code %s, stderr = %s' % (str(rc), err))
+
+
 def rtype(dbus_type):
 	"""
 	Decorator making sure that the decorated function returns a value of
@@ -57,8 +66,20 @@ def n32(v):
 	return int(float(v))
 
 
+@rtype(dbus.Double)
+def d(v):
+	if not v:
+		return 0.0
+	return float(v)
+
+
+def _snake_to_pascal(s):
+	return ''.join(x.title() for x in s.split('_'))
+
+
 # noinspection PyProtectedMember
-def init_class_from_arguments(obj_instance):
+def init_class_from_arguments(
+		obj_instance, begin_suffix=None, snake_to_pascal=False):
 	for k, v in list(sys._getframe(1).f_locals.items()):
 		if k != 'self':
 			nt = k
@@ -69,8 +90,17 @@ def init_class_from_arguments(obj_instance):
 			cur = getattr(obj_instance, nt, v)
 
 			# print 'Init class %s = %s' % (nt, str(v))
-			if not (cur and len(str(cur)) and (v is None or len(str(v))) == 0):
-				setattr(obj_instance, nt, v)
+			if not (cur and len(str(cur)) and (v is None or len(str(v))) == 0)\
+					and (begin_suffix is None or nt.startswith(begin_suffix)):
+
+				if begin_suffix and nt.startswith(begin_suffix):
+					name = nt[len(begin_suffix):]
+					if snake_to_pascal:
+						name = _snake_to_pascal(name)
+
+					setattr(obj_instance, name, v)
+				else:
+					setattr(obj_instance, nt, v)
 
 
 def get_properties(f):
@@ -338,6 +368,8 @@ def lv_object_path_method(name, meta):
 		return _hidden_lv_obj_path_generate
 	elif meta[0][0] == 't':
 		return _thin_pool_obj_path_generate
+	elif meta[0][0] == 'd':
+		return _vdo_pool_object_path_generate
 	elif meta[0][0] == 'C' and 'pool' in meta[1]:
 		return _cache_pool_obj_path_generate
 
@@ -355,6 +387,10 @@ def _thin_pool_obj_path_generate():
 	return cfg.THIN_POOL_PATH + "/%d" % next(cfg.thin_id)
 
 
+def _vdo_pool_object_path_generate():
+	return cfg.VDO_POOL_PATH + "/%d" % next(cfg.vdo_id)
+
+
 def _cache_pool_obj_path_generate():
 	return cfg.CACHE_POOL_PATH + "/%d" % next(cfg.cache_pool_id)
 
@@ -446,7 +482,7 @@ _ALLOWABLE_CH_SET = set(_ALLOWABLE_CH)
 _ALLOWABLE_VG_LV_CH = string.ascii_letters + string.digits + '.-_+'
 _ALLOWABLE_VG_LV_CH_SET = set(_ALLOWABLE_VG_LV_CH)
 _LV_NAME_RESERVED = ("_cdata", "_cmeta", "_corig", "_mimage", "_mlog",
-	"_pmspare", "_rimage", "_rmeta", "_tdata", "_tmeta", "_vorigin")
+	"_pmspare", "_rimage", "_rmeta", "_tdata", "_tmeta", "_vorigin", "_vdata")
 
 # Tags can have the characters, based on the code
 # a-zA-Z0-9._-+/=!:&#

daemons/lvmdbusd/vg.py

@@ -10,10 +10,11 @@
 from .automatedproperties import AutomatedProperties
 
 from . import utils
-from .utils import pv_obj_path_generate, vg_obj_path_generate, n
+from .utils import pv_obj_path_generate, vg_obj_path_generate, n, \
+	_handle_execute
 import dbus
 from . import cfg
-from .cfg import VG_INTERFACE
+from .cfg import VG_INTERFACE, VG_VDO_INTERFACE
 from . import cmdhandler
 from .request import RequestEntry
 from .loader import common
@@ -46,24 +47,29 @@ def vgs_state_retrieve(selection, cache_refresh=True):
 
 def load_vgs(vg_specific=None, object_path=None, refresh=False,
 		emit_signal=False, cache_refresh=True):
-	return common(vgs_state_retrieve, (Vg,), vg_specific, object_path, refresh,
+	return common(vgs_state_retrieve, (Vg, VgVdo, ), vg_specific, object_path, refresh,
 					emit_signal, cache_refresh)
 
 
 # noinspection PyPep8Naming,PyUnresolvedReferences,PyUnusedLocal
 class VgState(State):
+
 	@property
-	def lvm_id(self):
+	def internal_name(self):
 		return self.Name
 
+	@property
+	def lvm_id(self):
+		return self.internal_name
+
 	def identifiers(self):
-		return (self.Uuid, self.Name)
+		return (self.Uuid, self.internal_name)
 
 	def _lv_paths_build(self):
 		rc = []
 		for lv in cfg.db.lvs_in_vg(self.Uuid):
 			(lv_name, meta, lv_uuid) = lv
-			full_name = "%s/%s" % (self.Name, lv_name)
+			full_name = "%s/%s" % (self.internal_name, lv_name)
 
 			gen = utils.lv_object_path_method(lv_name, meta)
 
@@ -92,8 +98,12 @@ class VgState(State):
 	def create_dbus_object(self, path):
 		if not path:
 			path = cfg.om.get_object_path_by_uuid_lvm_id(
-				self.Uuid, self.Name, vg_obj_path_generate)
-		return Vg(path, self)
+				self.Uuid, self.internal_name, vg_obj_path_generate)
+
+		if cfg.vdo_support:
+			return VgVdo(path, self)
+		else:
+			return Vg(path, self)
 
 	# noinspection PyMethodMayBeStatic
 	def creation_signature(self):
@@ -102,7 +112,6 @@ class VgState(State):
 
 # noinspection PyPep8Naming
 @utils.dbus_property(VG_INTERFACE, 'Uuid', 's')
-@utils.dbus_property(VG_INTERFACE, 'Name', 's')
 @utils.dbus_property(VG_INTERFACE, 'Fmt', 's')
 @utils.dbus_property(VG_INTERFACE, 'SizeBytes', 't', 0)
 @utils.dbus_property(VG_INTERFACE, 'FreeBytes', 't', 0)
@@ -135,6 +144,7 @@ class Vg(AutomatedProperties):
 	_AllocNormal_meta = ('b', VG_INTERFACE)
 	_AllocAnywhere_meta = ('b', VG_INTERFACE)
 	_Clustered_meta = ('b', VG_INTERFACE)
+	_Name_meta = ('s', VG_INTERFACE)
 
 	# noinspection PyUnusedLocal,PyPep8Naming
 	def __init__(self, object_path, object_state):
@@ -149,13 +159,7 @@ class Vg(AutomatedProperties):
 
 	@staticmethod
 	def handle_execute(rc, out, err):
-		if rc == 0:
-			cfg.load()
-		else:
-			# Need to work on error handling, need consistent
-			raise dbus.exceptions.DBusException(
-				VG_INTERFACE,
-				'Exit code %s, stderr = %s' % (str(rc), err))
+		return _handle_execute(rc, out, err, VG_INTERFACE)
 
 	@staticmethod
 	def validate_dbus_object(vg_uuid, vg_name):
@@ -171,9 +175,8 @@ class Vg(AutomatedProperties):
 	def _rename(uuid, vg_name, new_name, rename_options):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
-		rc, out, err = cmdhandler.vg_rename(
-			vg_name, new_name, rename_options)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_rename(
+			uuid, new_name, rename_options))
 		return '/'
 
 	@dbus.service.method(
@@ -192,8 +195,7 @@ class Vg(AutomatedProperties):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
 		# Remove the VG, if successful then remove from the model
-		rc, out, err = cmdhandler.vg_remove(vg_name, remove_options)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_remove(vg_name, remove_options))
 		return '/'
 
 	@dbus.service.method(
@@ -209,14 +211,13 @@ class Vg(AutomatedProperties):
 	@staticmethod
 	def _change(uuid, vg_name, change_options):
 		Vg.validate_dbus_object(uuid, vg_name)
-		rc, out, err = cmdhandler.vg_change(change_options, vg_name)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_change(change_options, vg_name))
 		return '/'
 
 	# TODO: This should be broken into a number of different methods
 	# instead of having one method that takes a hash for parameters.  Some of
 	# the changes that vgchange does works on entire system, not just a
-	# specfic vg, thus that should be in the Manager interface.
+	# specific vg, thus that should be in the Manager interface.
 	@dbus.service.method(
 		dbus_interface=VG_INTERFACE,
 		in_signature='ia{sv}',
@@ -246,9 +247,8 @@ class Vg(AutomatedProperties):
 						VG_INTERFACE,
 						'PV Object path not found = %s!' % pv_op)
 
-		rc, out, err = cmdhandler.vg_reduce(vg_name, missing, pv_devices,
-											reduce_options)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_reduce(
+			vg_name, missing, pv_devices, reduce_options))
 		return '/'
 
 	@dbus.service.method(
@@ -278,9 +278,8 @@ class Vg(AutomatedProperties):
 					VG_INTERFACE, 'PV Object path not found = %s!' % i)
 
 		if len(extend_devices):
-			rc, out, err = cmdhandler.vg_extend(vg_name, extend_devices,
-												extend_options)
-			Vg.handle_execute(rc, out, err)
+			Vg.handle_execute(*cmdhandler.vg_extend(
+				vg_name, extend_devices, extend_options))
 		else:
 			raise dbus.exceptions.DBusException(
 				VG_INTERFACE, 'No pv_object_paths provided!')
@@ -334,10 +333,8 @@ class Vg(AutomatedProperties):
 
 				pv_dests.append((pv_dbus_obj.lvm_id, pr[1], pr[2]))
 
-		rc, out, err = cmdhandler.vg_lv_create(
-			vg_name, create_options, name, size_bytes, pv_dests)
-
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_lv_create(
+			vg_name, create_options, name, size_bytes, pv_dests))
 		return Vg.fetch_new_lv(vg_name, name)
 
 	@dbus.service.method(
@@ -375,11 +372,8 @@ class Vg(AutomatedProperties):
 			thin_pool, create_options):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
-
-		rc, out, err = cmdhandler.vg_lv_create_linear(
-			vg_name, create_options, name, size_bytes, thin_pool)
-
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_lv_create_linear(
+			vg_name, create_options, name, size_bytes, thin_pool))
 		return Vg.fetch_new_lv(vg_name, name)
 
 	@dbus.service.method(
@@ -401,10 +395,9 @@ class Vg(AutomatedProperties):
 			stripe_size_kb, thin_pool, create_options):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
-		rc, out, err = cmdhandler.vg_lv_create_striped(
+		Vg.handle_execute(*cmdhandler.vg_lv_create_striped(
 			vg_name, create_options, name, size_bytes,
-			num_stripes, stripe_size_kb, thin_pool)
-		Vg.handle_execute(rc, out, err)
+			num_stripes, stripe_size_kb, thin_pool))
 		return Vg.fetch_new_lv(vg_name, name)
 
 	@dbus.service.method(
@@ -429,9 +422,8 @@ class Vg(AutomatedProperties):
 			num_copies, create_options):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
-		rc, out, err = cmdhandler.vg_lv_create_mirror(
-			vg_name, create_options, name, size_bytes, num_copies)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_lv_create_mirror(
+			vg_name, create_options, name, size_bytes, num_copies))
 		return Vg.fetch_new_lv(vg_name, name)
 
 	@dbus.service.method(
@@ -454,10 +446,9 @@ class Vg(AutomatedProperties):
 						num_stripes, stripe_size_kb, create_options):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
-		rc, out, err = cmdhandler.vg_lv_create_raid(
+		Vg.handle_execute(*cmdhandler.vg_lv_create_raid(
 			vg_name, create_options, name, raid_type, size_bytes,
-			num_stripes, stripe_size_kb)
-		Vg.handle_execute(rc, out, err)
+			num_stripes, stripe_size_kb))
 		return Vg.fetch_new_lv(vg_name, name)
 
 	@dbus.service.method(
@@ -555,9 +546,8 @@ class Vg(AutomatedProperties):
 				raise dbus.exceptions.DBusException(
 					VG_INTERFACE, 'PV object path = %s not found' % p)
 
-		rc, out, err = cmdhandler.pv_tag(
-			pv_devices, tags_add, tags_del, tag_options)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.pv_tag(
+			pv_devices, tags_add, tags_del, tag_options))
 		return '/'
 
 	@dbus.service.method(
@@ -598,9 +588,8 @@ class Vg(AutomatedProperties):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
 
-		rc, out, err = cmdhandler.vg_tag(
-			vg_name, tags_add, tags_del, tag_options)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.vg_tag(
+			vg_name, tags_add, tags_del, tag_options))
 		return '/'
 
 	@dbus.service.method(
@@ -639,8 +628,7 @@ class Vg(AutomatedProperties):
 	def _vg_change_set(uuid, vg_name, method, value, options):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
-		rc, out, err = method(vg_name, value, options)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*method(vg_name, value, options))
 		return '/'
 
 	@dbus.service.method(
@@ -700,9 +688,8 @@ class Vg(AutomatedProperties):
 								options):
 		# Make sure we have a dbus object representing it
 		Vg.validate_dbus_object(uuid, vg_name)
-		rc, out, err = cmdhandler.activate_deactivate(
-			'vgchange', vg_name, activate, control_flags, options)
-		Vg.handle_execute(rc, out, err)
+		Vg.handle_execute(*cmdhandler.activate_deactivate(
+			'vgchange', vg_name, activate, control_flags, options))
 		return '/'
 
 	@dbus.service.method(
@@ -729,6 +716,12 @@ class Vg(AutomatedProperties):
 				cb, cbe, return_tuple=False)
 		cfg.worker_q.put(r)
 
+	@property
+	def Name(self):
+		if ':' in self.state.Name:
+			return self.state.Name.split(':')[0]
+		return self.state.Name
+
 	@property
 	def Tags(self):
 		return utils.parse_tags(self.state.tags)
@@ -784,3 +777,39 @@ class Vg(AutomatedProperties):
 	@property
 	def Clustered(self):
 		return self._attribute(5, 'c')
+
+
+class VgVdo(Vg):
+
+	# noinspection PyUnusedLocal,PyPep8Naming
+	def __init__(self, object_path, object_state):
+		super(VgVdo, self).__init__(object_path, vgs_state_retrieve)
+		self.set_interface(VG_VDO_INTERFACE)
+		self._object_path = object_path
+		self.state = object_state
+
+	@staticmethod
+	def _lv_vdo_pool_create_with_lv(uuid, vg_name, pool_name, lv_name,
+									data_size, virtual_size, create_options):
+		Vg.validate_dbus_object(uuid, vg_name)
+		Vg.handle_execute(*cmdhandler.vg_create_vdo_pool_lv_and_lv(
+			vg_name, pool_name, lv_name, data_size, virtual_size,
+			create_options))
+		return Vg.fetch_new_lv(vg_name, pool_name)
+
+	@dbus.service.method(
+		dbus_interface=VG_VDO_INTERFACE,
+		in_signature='ssttia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def CreateVdoPoolandLv(self, pool_name, lv_name, data_size, virtual_size,
+							tmo, create_options, cb, cbe):
+		utils.validate_lv_name(VG_VDO_INTERFACE, self.Name, pool_name)
+		utils.validate_lv_name(VG_VDO_INTERFACE, self.Name, lv_name)
+
+		r = RequestEntry(tmo, VgVdo._lv_vdo_pool_create_with_lv,
+							(self.state.Uuid, self.state.lvm_id,
+							pool_name, lv_name, round_size(data_size),
+							round_size(virtual_size),
+							create_options), cb, cbe)
+		cfg.worker_q.put(r)

daemons/lvmlockd/Makefile.in

@@ -15,6 +15,8 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
+USE_SD_NOTIFY=yes
+
 SOURCES = lvmlockd-core.c
 
 ifeq ("@BUILD_LOCKDSANLOCK@", "yes")
@@ -25,6 +27,7 @@ endif
 ifeq ("@BUILD_LOCKDDLM@", "yes")
   SOURCES += lvmlockd-dlm.c
   LOCK_LIBS += -ldlm_lt
+  LOCK_LIBS += -ldlmcontrol
 endif
 
 SOURCES2 = lvmlockctl.c
@@ -40,18 +43,28 @@ INCLUDES += -I$(top_srcdir)/libdaemon/server
 LDFLAGS += -L$(top_builddir)/libdaemon/server $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS)
 LIBS += $(RT_LIBS) $(DAEMON_LIBS) $(PTHREAD_LIBS)
 
+
+ifeq ($(USE_SD_NOTIFY),yes)
+	CFLAGS += $(shell pkg-config --cflags libsystemd) -DUSE_SD_NOTIFY
+	LIBS += $(shell pkg-config --libs libsystemd)
+endif
+
 lvmlockd: $(OBJECTS) $(top_builddir)/libdaemon/client/libdaemonclient.a \
 		    $(top_builddir)/libdaemon/server/libdaemonserver.a
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(LOCK_LIBS) -ldaemonserver $(INTERNAL_LIBS) $(LIBS)
+	@echo "    [CC] $@"
+	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(LOCK_LIBS) -ldaemonserver $(INTERNAL_LIBS) $(LIBS)
 
 lvmlockctl: lvmlockctl.o $(top_builddir)/libdaemon/client/libdaemonclient.a
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ lvmlockctl.o $(INTERNAL_LIBS) $(LIBS)
+	@echo "    [CC] $@"
+	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ lvmlockctl.o $(INTERNAL_LIBS) $(LIBS)
 
 install_lvmlockd: lvmlockd
-	$(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
 
 install_lvmlockctl: lvmlockctl
-	$(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
 
 install_lvm2: install_lvmlockd install_lvmlockctl
 

daemons/lvmlockd/lvmlockctl.c

@@ -24,7 +24,7 @@
 static int quit = 0;
 static int info = 0;
 static int dump = 0;
-static int wait_opt = 0;
+static int wait_opt = 1;
 static int force_opt = 0;
 static int kill_vg = 0;
 static int drop_vg = 0;

daemons/lvmlockd/lvmlockd-core.c

@@ -8,10 +8,6 @@
  * of the GNU Lesser General Public License v.2.1.
  */
 
-#define _XOPEN_SOURCE 500  /* pthread */
-#define _ISOC99_SOURCE
-#define _REENTRANT
-
 #include "tools/tool.h"
 
 #include "libdaemon/client/daemon-io.h"
@@ -35,6 +31,10 @@
 #include <sys/utsname.h>
 #include <sys/un.h>
 
+#ifdef USE_SD_NOTIFY
+#include <systemd/sd-daemon.h>
+#endif
+
 #define EXTERN
 #include "lvmlockd-internal.h"
 
@@ -405,12 +405,11 @@ struct lockspace *alloc_lockspace(void)
 {
 	struct lockspace *ls;
 
-	if (!(ls = malloc(sizeof(struct lockspace)))) {
+	if (!(ls = zalloc(sizeof(struct lockspace)))) {
 		log_error("out of memory for lockspace");
 		return NULL;
 	}
 
-	memset(ls, 0, sizeof(struct lockspace));
 	INIT_LIST_HEAD(&ls->actions);
 	INIT_LIST_HEAD(&ls->resources);
 	pthread_mutex_init(&ls->mutex, NULL);
@@ -503,6 +502,10 @@ static struct lock *alloc_lock(void)
 
 static void free_action(struct action *act)
 {
+	if (act->path) {
+		free(act->path);
+		act->path = NULL;
+	}
 	pthread_mutex_lock(&unused_struct_mutex);
 	if (unused_action_count >= MAX_UNUSED_ACTION) {
 		free(act);
@@ -726,6 +729,8 @@ static const char *op_str(int x)
 		return "rename_final";
 	case LD_OP_RUNNING_LM:
 		return "running_lm";
+	case LD_OP_QUERY_LOCK:
+		return "query_lock";
 	case LD_OP_FIND_FREE_LOCK:
 		return "find_free_lock";
 	case LD_OP_KILL_VG:
@@ -738,6 +743,8 @@ static const char *op_str(int x)
 		return "dump_info";
 	case LD_OP_BUSY:
 		return "busy";
+	case LD_OP_REFRESH_LV:
+		return "refresh_lv";
 	default:
 		return "op_unknown";
 	};
@@ -925,12 +932,12 @@ static void lm_rem_resource(struct lockspace *ls, struct resource *r)
 		lm_rem_resource_sanlock(ls, r);
 }
 
-static int lm_find_free_lock(struct lockspace *ls, uint64_t *free_offset)
+static int lm_find_free_lock(struct lockspace *ls, uint64_t *free_offset, int *sector_size, int *align_size)
 {
 	if (ls->lm_type == LD_LM_DLM)
 		return 0;
 	else if (ls->lm_type == LD_LM_SANLOCK)
-		return lm_find_free_lock_sanlock(ls, free_offset);
+		return lm_find_free_lock_sanlock(ls, free_offset, sector_size, align_size);
 	return -1;
 }
 
@@ -1815,9 +1822,9 @@ static void res_process(struct lockspace *ls, struct resource *r,
 			add_client_result(act);
 		} else {
 			/* persistent lock is sh, transient request is ex */
-			/* FIXME: can we remove this case? do a convert here? */
 			log_debug("res_process %s existing persistent lock new transient", r->name);
 			r->last_client_id = act->client_id;
+			act->flags |= LD_AF_SH_EXISTS;
 			act->result = -EEXIST;
 			list_del(&act->list);
 			add_client_result(act);
@@ -2197,6 +2204,7 @@ static int process_op_during_kill(struct action *act)
 	case LD_OP_UPDATE:
 	case LD_OP_RENAME_BEFORE:
 	case LD_OP_RENAME_FINAL:
+	case LD_OP_QUERY_LOCK:
 	case LD_OP_FIND_FREE_LOCK:
 		return 0;
 	};
@@ -2222,7 +2230,7 @@ static void *lockspace_thread_main(void *arg_in)
 	struct action *act_op_free = NULL;
 	struct list_head tmp_act;
 	struct list_head act_close;
-	char tmp_name[MAX_NAME+1];
+	char tmp_name[MAX_NAME+5];
 	int free_vg = 0;
 	int drop_vg = 0;
 	int error = 0;
@@ -2421,13 +2429,31 @@ static void *lockspace_thread_main(void *arg_in)
 				break;
 			}
 
+			if (act->op == LD_OP_QUERY_LOCK) {
+				r = find_resource_act(ls, act, 0);
+				if (!r)
+					act->result = -ENOENT;
+				else {
+					act->result = 0;
+					act->mode = r->mode;
+				}
+				list_del(&act->list);
+				add_client_result(act);
+				continue;
+			}
+
 			if (act->op == LD_OP_FIND_FREE_LOCK && act->rt == LD_RT_VG) {
 				uint64_t free_offset = 0;
+				int sector_size = 0;
+				int align_size = 0;
+
 				log_debug("S %s find free lock", ls->name);
-				rv = lm_find_free_lock(ls, &free_offset);
-				log_debug("S %s find free lock %d offset %llu",
-					  ls->name, rv, (unsigned long long)free_offset);
+				rv = lm_find_free_lock(ls, &free_offset, &sector_size, &align_size);
+				log_debug("S %s find free lock %d offset %llu sector_size %d align_size %d",
+					  ls->name, rv, (unsigned long long)free_offset, sector_size, align_size);
 				ls->free_lock_offset = free_offset;
+				ls->free_lock_sector_size = sector_size;
+				ls->free_lock_align_size = align_size;
 				list_del(&act->list);
 				act->result = rv;
 				add_client_result(act);
@@ -2598,8 +2624,10 @@ out_act:
 	 * blank or fill it with garbage, but instead set it to REM:<name>
 	 * to make it easier to follow progress of freeing is via log_debug.
 	 */
-	dm_strncpy(tmp_name, ls->name, sizeof(tmp_name));
-	snprintf(ls->name, sizeof(ls->name), "REM:%s", tmp_name);
+	memset(tmp_name, 0, sizeof(tmp_name));
+	memcpy(tmp_name, "REM:", 4);
+	strncpy(tmp_name+4, ls->name, sizeof(tmp_name)-4);
+	memcpy(ls->name, tmp_name, sizeof(ls->name));
 	pthread_mutex_unlock(&lockspaces_mutex);
 
 	/* worker_thread will join this thread, and free the ls */
@@ -2739,6 +2767,9 @@ static int add_lockspace_thread(const char *ls_name,
 		if (ls2->thread_stop) {
 			log_debug("add_lockspace_thread %s exists and stopping", ls->name);
 			rv = -EAGAIN;
+		} else if (!ls2->create_fail && !ls2->create_done) {
+			log_debug("add_lockspace_thread %s exists and starting", ls->name);
+			rv = -ESTARTING;
 		} else {
 			log_debug("add_lockspace_thread %s exists", ls->name);
 			rv = -EEXIST;
@@ -2980,7 +3011,7 @@ static int count_lockspace_starting(uint32_t client_id)
 
 	pthread_mutex_lock(&lockspaces_mutex);
 	list_for_each_entry(ls, &lockspaces, list) {
-		if (ls->start_client_id != client_id)
+		if (client_id && (ls->start_client_id != client_id))
 			continue;
 
 		if (!ls->create_done && !ls->create_fail) {
@@ -3233,6 +3264,8 @@ static int work_init_lv(struct action *act)
 	char vg_args[MAX_ARGS+1];
 	char lv_args[MAX_ARGS+1];
 	uint64_t free_offset = 0;
+	int sector_size = 0;
+	int align_size = 0;
 	int lm_type = 0;
 	int rv = 0;
 
@@ -3248,6 +3281,8 @@ static int work_init_lv(struct action *act)
 		lm_type = ls->lm_type;
 		memcpy(vg_args, ls->vg_args, MAX_ARGS);
 		free_offset = ls->free_lock_offset;
+		sector_size = ls->free_lock_sector_size;
+		align_size = ls->free_lock_align_size;
 	}
 	pthread_mutex_unlock(&lockspaces_mutex);
 
@@ -3264,7 +3299,7 @@ static int work_init_lv(struct action *act)
 
 	if (lm_type == LD_LM_SANLOCK) {
 		rv = lm_init_lv_sanlock(ls_name, act->vg_name, act->lv_uuid,
-					vg_args, lv_args, free_offset);
+					vg_args, lv_args, sector_size, align_size, free_offset);
 
 		memcpy(act->lv_args, lv_args, MAX_ARGS);
 		return rv;
@@ -3381,7 +3416,7 @@ static void *worker_thread_main(void *arg_in)
 			add_client_result(act);
 
 		} else if (act->op == LD_OP_START_WAIT) {
-			act->result = count_lockspace_starting(act->client_id);
+			act->result = count_lockspace_starting(0);
 			if (!act->result)
 				add_client_result(act);
 			else
@@ -3394,6 +3429,15 @@ static void *worker_thread_main(void *arg_in)
 			else
 				list_add(&act->list, &delayed_list);
 
+		} else if (act->op == LD_OP_REFRESH_LV) {
+			log_debug("work refresh_lv %s %s", act->lv_uuid, act->path);
+			rv = lm_refresh_lv_start_dlm(act);
+			if (rv < 0) {
+				act->result = rv;
+				add_client_result(act);
+			} else
+				list_add(&act->list, &delayed_list);
+
 		} else {
 			log_error("work unknown op %d", act->op);
 			act->result = -EINVAL;
@@ -3415,7 +3459,7 @@ static void *worker_thread_main(void *arg_in)
 		list_for_each_entry_safe(act, safe, &delayed_list, list) {
 			if (act->op == LD_OP_START_WAIT) {
 				log_debug("work delayed start_wait for client %u", act->client_id);
-				act->result = count_lockspace_starting(act->client_id);
+				act->result = count_lockspace_starting(0);
 				if (!act->result) {
 					list_del(&act->list);
 					add_client_result(act);
@@ -3429,6 +3473,19 @@ static void *worker_thread_main(void *arg_in)
 					act->result = 0;
 					add_client_result(act);
 				}
+
+			} else if (act->op == LD_OP_REFRESH_LV) {
+				log_debug("work delayed refresh_lv");
+				rv = lm_refresh_lv_check_dlm(act);
+				if (!rv) {
+					list_del(&act->list);
+					act->result = 0;
+					add_client_result(act);
+				} else if ((rv < 0) && (rv != -EAGAIN)) {
+					list_del(&act->list);
+					act->result = rv;
+					add_client_result(act);
+				}
 			}
 		}
 
@@ -3634,6 +3691,9 @@ static int client_send_result(struct client *cl, struct action *act)
 	if ((act->flags & LD_AF_WARN_GL_REMOVED) || gl_vg_removed)
 		strcat(result_flags, "WARN_GL_REMOVED,");
 	
+	if (act->flags & LD_AF_SH_EXISTS)
+		strcat(result_flags, "SH_EXISTS,");
+
 	if (act->op == LD_OP_INIT) {
 		/*
 		 * init is a special case where lock args need
@@ -3662,6 +3722,20 @@ static int client_send_result(struct client *cl, struct action *act)
 					  "result_flags = %s", result_flags[0] ? result_flags : "none",
 					  NULL);
 
+	} else if (act->op == LD_OP_QUERY_LOCK) {
+
+		log_debug("send %s[%d] cl %u %s %s rv %d mode %d",
+			  cl->name[0] ? cl->name : "client", cl->pid, cl->id,
+			  op_str(act->op), rt_str(act->rt),
+			  act->result, act->mode);
+
+		res = daemon_reply_simple("OK",
+					  "op = " FMTd64, (int64_t)act->op,
+					  "op_result = " FMTd64, (int64_t) act->result,
+					  "lock_type = %s", lm_str(act->lm_type),
+					  "mode = %s", mode_str(act->mode),
+					  NULL);
+
 	} else if (act->op == LD_OP_DUMP_LOG || act->op == LD_OP_DUMP_INFO) {
 		/*
 		 * lvmlockctl creates the unix socket then asks us to write to it.
@@ -3992,6 +4066,16 @@ static int str_to_op_rt(const char *req_name, int *op, int *rt)
 		*rt = 0;
 		return 0;
 	}
+	if (!strcmp(req_name, "query_lock_vg")) {
+		*op = LD_OP_QUERY_LOCK;
+		*rt = LD_RT_VG;
+		return 0;
+	}
+	if (!strcmp(req_name, "query_lock_lv")) {
+		*op = LD_OP_QUERY_LOCK;
+		*rt = LD_RT_LV;
+		return 0;
+	}
 	if (!strcmp(req_name, "find_free_lock")) {
 		*op = LD_OP_FIND_FREE_LOCK;
 		*rt = LD_RT_VG;
@@ -4007,6 +4091,11 @@ static int str_to_op_rt(const char *req_name, int *op, int *rt)
 		*rt = LD_RT_VG;
 		return 0;
 	}
+	if (!strcmp(req_name, "refresh_lv")) {
+		*op = LD_OP_REFRESH_LV;
+		*rt = 0;
+		return 0;
+	}
 out:
 	return -1;
 }
@@ -4368,6 +4457,7 @@ static void client_recv_action(struct client *cl)
 	const char *vg_name;
 	const char *vg_uuid;
 	const char *vg_sysid;
+	const char *path;
 	const char *str;
 	int64_t val;
 	uint32_t opts = 0;
@@ -4454,6 +4544,7 @@ static void client_recv_action(struct client *cl)
 	opts = str_to_opts(str);
 	str = daemon_request_str(req, "vg_lock_type", NULL);
 	lm = str_to_lm(str);
+	path = daemon_request_str(req, "path", NULL);
 
 	if (cl_pid && cl_pid != cl->pid)
 		log_error("client recv bad message pid %d client %d", cl_pid, cl->pid);
@@ -4486,6 +4577,9 @@ static void client_recv_action(struct client *cl)
 	act->flags = opts;
 	act->lm_type = lm;
 
+	if (path)
+		act->path = strdup(path);
+
 	if (vg_name && strcmp(vg_name, "none"))
 		strncpy(act->vg_name, vg_name, MAX_NAME);
 
@@ -4562,6 +4656,7 @@ static void client_recv_action(struct client *cl)
 	case LD_OP_STOP_ALL:
 	case LD_OP_RENAME_FINAL:
 	case LD_OP_RUNNING_LM:
+	case LD_OP_REFRESH_LV:
 		add_work_action(act);
 		rv = 0;
 		break;
@@ -4571,6 +4666,7 @@ static void client_recv_action(struct client *cl)
 	case LD_OP_DISABLE:
 	case LD_OP_FREE:
 	case LD_OP_RENAME_BEFORE:
+	case LD_OP_QUERY_LOCK:
 	case LD_OP_FIND_FREE_LOCK:
 	case LD_OP_KILL_VG:
 	case LD_OP_DROP_VG:
@@ -5786,6 +5882,10 @@ static int main_loop(daemon_state *ds_arg)
 	setup_worker_thread();
 	setup_restart();
 
+#ifdef USE_SD_NOTIFY
+	sd_notify(0, "READY=1");
+#endif
+
 	/*
 	 * Attempt to rejoin lockspaces and adopt locks from a previous
 	 * instance of lvmlockd that left behind lockspaces/locks.

daemons/lvmlockd/lvmlockd-dlm.c

@@ -24,6 +24,7 @@
  * link with non-threaded version of library, libdlm_lt.
  */
 #include "libdlm.h"
+#include "libdlmcontrol.h"
 
 #include <stddef.h>
 #include <poll.h>
@@ -127,16 +128,18 @@ static int read_cluster_name(char *clustername)
 	return 0;
 }
 
+#define MAX_VERSION 16
+
 int lm_init_vg_dlm(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
 {
 	char clustername[MAX_ARGS+1];
-	char lock_args_version[MAX_ARGS+1];
+	char lock_args_version[MAX_VERSION+1];
 	int rv;
 
 	memset(clustername, 0, sizeof(clustername));
 	memset(lock_args_version, 0, sizeof(lock_args_version));
 
-	snprintf(lock_args_version, MAX_ARGS, "%u.%u.%u",
+	snprintf(lock_args_version, MAX_VERSION, "%u.%u.%u",
 		 VG_LOCK_ARGS_MAJOR, VG_LOCK_ARGS_MINOR, VG_LOCK_ARGS_PATCH);
 
 	rv = read_cluster_name(clustername);
@@ -148,7 +151,9 @@ int lm_init_vg_dlm(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
 		return -EARGS;
 	}
 
-	snprintf(vg_args, MAX_ARGS, "%s:%s", lock_args_version, clustername);
+	rv = snprintf(vg_args, MAX_ARGS, "%s:%s", lock_args_version, clustername);
+	if (rv >= MAX_ARGS)
+		log_debug("init_vg_dlm vg_args may be too long %d %s", rv, vg_args);
 	rv = 0;
 
 	log_debug("init_vg_dlm done %s vg_args %s", ls_name, vg_args);
@@ -272,10 +277,9 @@ static int lm_add_resource_dlm(struct lockspace *ls, struct resource *r, int wit
 	int rv;
 
 	if (r->type == LD_RT_GL || r->type == LD_RT_VG) {
-		buf = malloc(sizeof(struct val_blk) + DLM_LVB_LEN);
+		buf = zalloc(sizeof(struct val_blk) + DLM_LVB_LEN);
 		if (!buf)
 			return -ENOMEM;
-		memset(buf, 0, sizeof(struct val_blk) + DLM_LVB_LEN);
 
 		rdd->vb = (struct val_blk *)buf;
 		rdd->lksb.sb_lvbptr = buf + sizeof(struct val_blk);
@@ -777,3 +781,107 @@ int lm_is_running_dlm(void)
 	return 1;
 }
 
+#ifdef LOCKDDLM_CONTROL_SUPPORT
+
+int lm_refresh_lv_start_dlm(struct action *act)
+{
+	char path[PATH_MAX];
+	char command[DLMC_RUN_COMMAND_LEN];
+	char run_uuid[DLMC_RUN_UUID_LEN];
+	char *p, *vgname, *lvname;
+	int rv;
+
+	/* split /dev/vgname/lvname into vgname and lvname strings */
+	strncpy(path, act->path, strlen(act->path));
+
+	/* skip past dev */
+	p = strchr(path + 1, '/');
+
+	/* skip past slashes */
+	while (*p == '/')
+		p++;
+
+	/* start of vgname */
+	vgname = p;
+
+	/* skip past vgname */
+	while (*p != '/')
+		p++;
+
+	/* terminate vgname */
+	*p = '\0';
+	p++;
+
+	/* skip past slashes */
+	while (*p == '/')
+		p++;
+
+	lvname = p;
+
+	memset(command, 0, sizeof(command));
+	memset(run_uuid, 0, sizeof(run_uuid));
+
+	/* todo: add --readonly */
+
+	snprintf(command, DLMC_RUN_COMMAND_LEN,
+		 "lvm lvchange --refresh --partial --nolocking %s/%s",
+		 vgname, lvname);
+
+	rv = dlmc_run_start(command, strlen(command), 0,
+			    DLMC_FLAG_RUN_START_NODE_NONE,
+			    run_uuid);
+	if (rv < 0) {
+		log_debug("refresh_lv run_start error %d", rv);
+		return rv;
+	}
+
+	log_debug("refresh_lv run_start %s", run_uuid);
+
+	/* Bit of a hack here, we don't need path once started,
+	   but we do need to save the run_uuid somewhere, so just
+	   replace the path with the uuid. */
+
+	free(act->path);
+	act->path = strdup(run_uuid);
+	return 0;
+}
+
+int lm_refresh_lv_check_dlm(struct action *act)
+{
+	uint32_t check_status = 0;
+	int rv;
+
+	/* NB act->path was replaced with run_uuid */
+
+	rv = dlmc_run_check(act->path, strlen(act->path), 0,
+			    DLMC_FLAG_RUN_CHECK_CLEAR,
+			    &check_status);
+	if (rv < 0) {
+		log_debug("refresh_lv check error %d", rv);
+		return rv;
+	}
+
+	log_debug("refresh_lv check %s status %x", act->path, check_status);
+
+	if (!(check_status & DLMC_RUN_STATUS_DONE))
+		return -EAGAIN;
+
+	if (check_status & DLMC_RUN_STATUS_FAILED)
+		return -1;
+
+	return 0;
+}
+
+#else /* LOCKDDLM_CONTROL_SUPPORT */
+
+int lm_refresh_lv_start_dlm(struct action *act)
+{
+	return 0;
+}
+
+int lm_refresh_lv_check_dlm(struct action *act)
+{
+	return 0;
+}
+
+#endif /* LOCKDDLM_CONTROL_SUPPORT */

daemons/lvmlockd/lvmlockd-internal.h

@@ -53,6 +53,8 @@ enum {
 	LD_OP_KILL_VG,
 	LD_OP_DROP_VG,
 	LD_OP_BUSY,
+	LD_OP_QUERY_LOCK,
+	LD_OP_REFRESH_LV,
 };
 
 /* resource types */
@@ -105,6 +107,7 @@ struct client {
 #define LD_AF_WARN_GL_REMOVED	   0x00020000
 #define LD_AF_LV_LOCK              0x00040000
 #define LD_AF_LV_UNLOCK            0x00080000
+#define LD_AF_SH_EXISTS            0x00100000
 
 /*
  * Number of times to repeat a lock request after
@@ -127,6 +130,7 @@ struct action {
 	int max_retries;
 	int result;
 	int lm_rv;			/* return value from lm_ function */
+	char *path;
 	char vg_uuid[64];
 	char vg_name[MAX_NAME+1];
 	char lv_name[MAX_NAME+1];
@@ -174,7 +178,9 @@ struct lockspace {
 	int8_t lm_type;			/* lock manager: LM_DLM, LM_SANLOCK */
 	void *lm_data;
 	uint64_t host_id;
-	uint64_t free_lock_offset;	/* start search for free lock here */
+	uint64_t free_lock_offset;	/* for sanlock, start search for free lock here */
+	int free_lock_sector_size;	/* for sanlock */
+	int free_lock_align_size;	/* for sanlock */
 
 	uint32_t start_client_id;	/* client_id that started the lockspace */
 	pthread_t thread;		/* makes synchronous lock requests */
@@ -387,6 +393,8 @@ int lm_get_lockspaces_dlm(struct list_head *ls_rejoin);
 int lm_data_size_dlm(void);
 int lm_is_running_dlm(void);
 int lm_hosts_dlm(struct lockspace *ls, int notify);
+int lm_refresh_lv_start_dlm(struct action *act);
+int lm_refresh_lv_check_dlm(struct action *act);
 
 static inline int lm_support_dlm(void)
 {
@@ -463,12 +471,22 @@ static inline int lm_hosts_dlm(struct lockspace *ls, int notify)
 	return 0;
 }
 
+static inline int lm_refresh_lv_start_dlm(struct action *act)
+{
+	return 0;
+}
+
+static inline int lm_refresh_lv_check_dlm(struct action *act)
+{
+	return 0;
+}
+
 #endif /* dlm support */
 
 #ifdef LOCKDSANLOCK_SUPPORT
 
 int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
-int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, uint64_t free_offset);
+int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, int sector_size, int align_size, uint64_t free_offset);
 int lm_free_lv_sanlock(struct lockspace *ls, struct resource *r);
 int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
 int lm_prepare_lockspace_sanlock(struct lockspace *ls);
@@ -488,7 +506,7 @@ int lm_gl_is_enabled(struct lockspace *ls);
 int lm_get_lockspaces_sanlock(struct list_head *ls_rejoin);
 int lm_data_size_sanlock(void);
 int lm_is_running_sanlock(void);
-int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset);
+int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset, int *sector_size, int *align_size);
 
 static inline int lm_support_sanlock(void)
 {
@@ -502,7 +520,7 @@ static inline int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flag
 	return -1;
 }
 
-static inline int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, uint64_t free_offset)
+static inline int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, int sector_size, int align_size, uint64_t free_offset)
 {
 	return -1;
 }
@@ -590,7 +608,7 @@ static inline int lm_is_running_sanlock(void)
 	return 0;
 }
 
-static inline int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
+static inline int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset, int *sector_size, int *align_size)
 {
 	return -1;
 }

daemons/lvmlockd/lvmlockd-sanlock.c

@@ -24,10 +24,29 @@
 #include "sanlock_admin.h"
 #include "sanlock_resource.h"
 
+/* FIXME: these are copied from sanlock.h only until
+   an updated version of sanlock is available with them. */
+#define SANLK_RES_ALIGN1M       0x00000010
+#define SANLK_RES_ALIGN2M       0x00000020
+#define SANLK_RES_ALIGN4M       0x00000040
+#define SANLK_RES_ALIGN8M       0x00000080
+#define SANLK_RES_SECTOR512     0x00000100
+#define SANLK_RES_SECTOR4K      0x00000200
+#define SANLK_LSF_ALIGN1M       0x00000010
+#define SANLK_LSF_ALIGN2M       0x00000020
+#define SANLK_LSF_ALIGN4M       0x00000040
+#define SANLK_LSF_ALIGN8M       0x00000080
+#define SANLK_LSF_SECTOR512     0x00000100
+#define SANLK_LSF_SECTOR4K      0x00000200
+
 #include <stddef.h>
 #include <poll.h>
 #include <errno.h>
 #include <syslog.h>
+#include <blkid/blkid.h>
+#include <sys/sysmacros.h>
+
+#define ONE_MB 1048576
 
 /*
 -------------------------------------------------------------------------------
@@ -139,6 +158,7 @@ release all the leases for the VG.
 
 struct lm_sanlock {
 	struct sanlk_lockspace ss;
+	int sector_size;
 	int align_size;
 	int sock; /* sanlock daemon connection */
 };
@@ -201,7 +221,6 @@ int lm_data_size_sanlock(void)
  * ...
  */
 
-#define LS_BEGIN 0
 #define GL_LOCK_BEGIN UINT64_C(65)
 #define VG_LOCK_BEGIN UINT64_C(66)
 #define LV_LOCK_BEGIN UINT64_C(67)
@@ -288,7 +307,8 @@ static int read_host_id_file(void)
 		}
 	}
 	if (fclose(file))
-		log_error("failed to close host id file %s", daemon_host_id_file);
+		log_debug("Failed to fclose host id file %s (%s).",
+			  daemon_host_id_file, strerror(errno));
 out:
 	log_debug("host_id %d from %s", host_id, daemon_host_id_file);
 	return host_id;
@@ -324,6 +344,154 @@ fail:
 	return rv;
 }
 
+static void _read_sysfs_size(dev_t devno, const char *name, unsigned int *val)
+{
+	char path[PATH_MAX];
+	char buf[32];
+	FILE *fp;
+	size_t len;
+
+	snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/queue/%s",
+		 (int)major(devno), (int)minor(devno), name);
+
+	if (!(fp = fopen(path, "r")))
+		return;
+
+	if (!fgets(buf, sizeof(buf), fp))
+		goto out;
+
+	if ((len = strlen(buf)) && buf[len - 1] == '\n')
+		buf[--len] = '\0';
+
+	if (strlen(buf))
+		*val = atoi(buf);
+out:
+	if (fclose(fp))
+		log_debug("Failed to fclose host id file %s (%s).", path, strerror(errno));
+
+}
+
+/* Select sector/align size for a new VG based on what the device reports for
+   sector size of the lvmlock LV. */
+
+static int get_sizes_device(char *path, int *sector_size, int *align_size)
+{
+	unsigned int physical_block_size = 0;
+	unsigned int logical_block_size = 0;
+	struct stat st;
+	int rv;
+
+	rv = stat(path, &st);
+	if (rv < 0) {
+		log_error("Failed to stat device to get block size %s %d", path, errno);
+		return -1;
+	}
+
+	_read_sysfs_size(st.st_rdev, "physical_block_size", &physical_block_size);
+	_read_sysfs_size(st.st_rdev, "logical_block_size", &logical_block_size);
+
+	if ((physical_block_size == 512) && (logical_block_size == 512)) {
+		*sector_size = 512;
+		*align_size = ONE_MB;
+		return 0;
+	}
+
+	if ((physical_block_size == 4096) && (logical_block_size == 4096)) {
+		*sector_size = 4096;
+		*align_size = 8 * ONE_MB;
+		return 0;
+	}
+
+	if (physical_block_size && (physical_block_size != 512) && (physical_block_size != 4096)) {
+		log_warn("WARNING: invalid block sizes physical %u logical %u for %s",
+			 physical_block_size, logical_block_size, path);
+		physical_block_size = 0;
+	}
+
+	if (logical_block_size && (logical_block_size != 512) && (logical_block_size != 4096)) {
+		log_warn("WARNING: invalid block sizes physical %u logical %u for %s",
+			 physical_block_size, logical_block_size, path);
+		logical_block_size = 0;
+	}
+
+	if (!physical_block_size && !logical_block_size) {
+		log_error("Failed to get a block size for %s", path);
+		return -1;
+	}
+
+	if (!physical_block_size || !logical_block_size) {
+		log_warn("WARNING: incomplete block size information physical %u logical %u for %s",
+			 physical_block_size, logical_block_size, path);
+		if (!physical_block_size)
+			physical_block_size = logical_block_size;
+		if (!logical_block_size)
+			logical_block_size = physical_block_size;
+	}
+
+	if ((logical_block_size == 4096) && (physical_block_size == 512)) {
+		log_warn("WARNING: mixed block sizes physical %u logical %u (using 4096) for %s",
+			 physical_block_size, logical_block_size, path);
+		*sector_size = 4096;
+		*align_size = 8 * ONE_MB;
+		return 0;
+	}
+
+	if ((physical_block_size == 4096) && (logical_block_size == 512)) {
+		log_warn("WARNING: mixed block sizes physical %u logical %u (using 4096) for %s",
+			 physical_block_size, logical_block_size, path);
+		*sector_size = 4096;
+		*align_size = 8 * ONE_MB;
+		return 0;
+	}
+
+	if (physical_block_size == 512) {
+		*sector_size = 512;
+		*align_size = ONE_MB;
+		return 0;
+	}
+
+	if (physical_block_size == 4096) {
+		*sector_size = 4096;
+		*align_size = 8 * ONE_MB;
+		return 0;
+	}
+
+	log_error("Failed to get a block size for %s", path);
+	return -1;
+}
+
+
+/* Get the sector/align sizes that were used to create an existing VG.
+   sanlock encoded this in the lockspace/resource structs on disk. */
+
+static int get_sizes_lockspace(char *path, int *sector_size, int *align_size)
+{
+	struct sanlk_lockspace ss;
+	uint32_t io_timeout = 0;
+	int rv;
+
+	memset(&ss, 0, sizeof(ss));
+	memcpy(ss.host_id_disk.path, path, SANLK_PATH_LEN);
+	ss.host_id_disk.offset = 0;
+
+	rv = sanlock_read_lockspace(&ss, 0, &io_timeout);
+	if (rv < 0) {
+		log_error("get_sizes_lockspace %s error %d", path, rv);
+		return rv;
+	}
+
+	if ((ss.flags & SANLK_LSF_SECTOR4K) && (ss.flags & SANLK_LSF_ALIGN8M)) {
+		*sector_size = 4096;
+		*align_size = 8 * ONE_MB;
+	} else if ((ss.flags & SANLK_LSF_SECTOR512) && (ss.flags & SANLK_LSF_ALIGN1M)) {
+		*sector_size = 512;
+		*align_size = ONE_MB;
+	}
+
+	log_debug("get_sizes_lockspace found %d %d", *sector_size, *align_size);
+	return 0;
+}
+
 /*
  * vgcreate
  *
@@ -332,18 +500,21 @@ fail:
  * version and lv name, and returns the real lock_args in vg_args.
  */
 
+#define MAX_VERSION 16
+
 int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
 {
 	struct sanlk_lockspace ss;
 	struct sanlk_resourced rd;
 	struct sanlk_disk disk;
 	char lock_lv_name[MAX_ARGS+1];
-	char lock_args_version[MAX_ARGS+1];
+	char lock_args_version[MAX_VERSION+1];
 	const char *gl_name = NULL;
 	uint32_t daemon_version;
 	uint32_t daemon_proto;
 	uint64_t offset;
-	int align_size;
+	int sector_size = 0;
+	int align_size = 0;
 	int i, rv;
 
 	memset(&ss, 0, sizeof(ss));
@@ -357,7 +528,7 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 		return -EARGS;
 	}
 
-	snprintf(lock_args_version, MAX_ARGS, "%u.%u.%u",
+	snprintf(lock_args_version, MAX_VERSION, "%u.%u.%u",
 		 VG_LOCK_ARGS_MAJOR, VG_LOCK_ARGS_MINOR, VG_LOCK_ARGS_PATCH);
 
 	/* see comment above about input vg_args being only lock_lv_name */
@@ -374,7 +545,9 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	if (daemon_test) {
 		if (!gl_lsname_sanlock[0])
 			strncpy(gl_lsname_sanlock, ls_name, MAX_NAME);
-		snprintf(vg_args, MAX_ARGS, "%s:%s", lock_args_version, lock_lv_name);
+		rv = snprintf(vg_args, MAX_ARGS, "%s:%s", lock_args_version, lock_lv_name);
+		if (rv >= MAX_ARGS)
+			log_debug("init_vg_san vg_args may be too long %d %s", rv, vg_args);
 		return 0;
 	}
 
@@ -387,23 +560,25 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	log_debug("sanlock daemon version %08x proto %08x",
 		  daemon_version, daemon_proto);
 
-	rv = sanlock_align(&disk);
-	if (rv <= 0) {
+	/* Nothing formatted on disk yet, use what the device reports. */
+	rv = get_sizes_device(disk.path, &sector_size, &align_size);
+	if (rv < 0) {
 		if (rv == -EACCES) {
 			log_error("S %s init_vg_san sanlock error -EACCES: no permission to access %s",
 				  ls_name, disk.path);
 			return -EDEVOPEN;
 		} else {
-			log_error("S %s init_vg_san sanlock error %d trying to get align size of %s",
+			log_error("S %s init_vg_san sanlock error %d trying to get sector/align size of %s",
 				  ls_name, rv, disk.path);
 			return -EARGS;
 		}
-	} else
-		align_size = rv;
+	}
 
 	strncpy(ss.name, ls_name, SANLK_NAME_LEN);
 	memcpy(ss.host_id_disk.path, disk.path, SANLK_PATH_LEN);
-	ss.host_id_disk.offset = LS_BEGIN * align_size;
+	ss.host_id_disk.offset = 0;
+	ss.flags = (sector_size == 4096) ? (SANLK_LSF_SECTOR4K | SANLK_LSF_ALIGN8M) :
+					   (SANLK_LSF_SECTOR512 | SANLK_LSF_ALIGN1M);
 
 	rv = sanlock_write_lockspace(&ss, 0, 0, sanlock_io_timeout);
 	if (rv < 0) {
@@ -436,6 +611,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	memcpy(rd.rs.disks[0].path, disk.path, SANLK_PATH_LEN);
 	rd.rs.disks[0].offset = align_size * GL_LOCK_BEGIN;
 	rd.rs.num_disks = 1;
+	rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+					      (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 
 	rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 	if (rv < 0) {
@@ -449,6 +626,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	memcpy(rd.rs.disks[0].path, disk.path, SANLK_PATH_LEN);
 	rd.rs.disks[0].offset = align_size * VG_LOCK_BEGIN;
 	rd.rs.num_disks = 1;
+	rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+					      (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 
 	rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 	if (rv < 0) {
@@ -460,7 +639,9 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	if (!strcmp(gl_name, R_NAME_GL))
 		strncpy(gl_lsname_sanlock, ls_name, MAX_NAME);
  
-	snprintf(vg_args, MAX_ARGS, "%s:%s", lock_args_version, lock_lv_name);
+	rv = snprintf(vg_args, MAX_ARGS, "%s:%s", lock_args_version, lock_lv_name);
+	if (rv >= MAX_ARGS)
+		log_debug("init_vg_san vg_args may be too long %d %s", rv, vg_args);
 
 	log_debug("S %s init_vg_san done vg_args %s", ls_name, vg_args);
 
@@ -472,6 +653,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 
 	memset(&rd, 0, sizeof(rd));
 	rd.rs.num_disks = 1;
+	rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+					      (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 	memcpy(rd.rs.disks[0].path, disk.path, SANLK_PATH_LEN);
 	strncpy(rd.rs.lockspace_name, ls_name, SANLK_NAME_LEN);
 	strcpy(rd.rs.name, "#unused");
@@ -510,13 +693,13 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
  */
 
 int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
-		       char *vg_args, char *lv_args, uint64_t free_offset)
+		       char *vg_args, char *lv_args,
+		       int sector_size, int align_size, uint64_t free_offset)
 {
 	struct sanlk_resourced rd;
 	char lock_lv_name[MAX_ARGS+1];
-	char lock_args_version[MAX_ARGS+1];
+	char lock_args_version[MAX_VERSION+1];
 	uint64_t offset;
-	int align_size;
 	int rv;
 
 	memset(&rd, 0, sizeof(rd));
@@ -530,11 +713,11 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 		return rv;
 	}
 
-	snprintf(lock_args_version, MAX_ARGS, "%u.%u.%u",
+	snprintf(lock_args_version, MAX_VERSION, "%u.%u.%u",
 		 LV_LOCK_ARGS_MAJOR, LV_LOCK_ARGS_MINOR, LV_LOCK_ARGS_PATCH);
 
 	if (daemon_test) {
-		align_size = 1048576;
+		align_size = ONE_MB;
 		snprintf(lv_args, MAX_ARGS, "%s:%llu",
 			 lock_args_version,
 			 (unsigned long long)((align_size * LV_LOCK_BEGIN) + (align_size * daemon_test_lv_count)));
@@ -547,12 +730,35 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 	if ((rv = build_dm_path(rd.rs.disks[0].path, SANLK_PATH_LEN, vg_name, lock_lv_name)))
 		return rv;
 
-	align_size = sanlock_align(&rd.rs.disks[0]);
-	if (align_size <= 0) {
-		log_error("S %s init_lv_san align error %d", ls_name, align_size);
-		return -EINVAL;
+	/*
+	 * These should not usually be zero, maybe only the first time this function is called?
+	 * We need to use the same sector/align sizes that are already being used.
+	 */
+	if (!sector_size || !align_size) {
+		rv = get_sizes_lockspace(rd.rs.disks[0].path, &sector_size, &align_size);
+		if (rv < 0) {
+			log_error("S %s init_lv_san read_lockspace error %d %s",
+				  ls_name, rv, rd.rs.disks[0].path);
+			return rv;
+		}
+
+		if (sector_size)
+			log_debug("S %s init_lv_san found ls sector_size %d align_size %d", ls_name, sector_size, align_size);
+		else {
+			/* use the old method */
+			align_size = sanlock_align(&rd.rs.disks[0]);
+			if (align_size <= 0) {
+				log_error("S %s init_lv_san align error %d", ls_name, align_size);
+				return -EINVAL;
+			}
+			sector_size = (align_size == ONE_MB) ? 512 : 4096;
+			log_debug("S %s init_lv_san found old sector_size %d align_size %d", ls_name, sector_size, align_size);
+		}
 	}
 
+	rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+					      (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
+
 	if (free_offset)
 		offset = free_offset;
 	else
@@ -595,6 +801,8 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 				  ls_name, lv_name, (unsigned long long)offset);
 
 			strncpy(rd.rs.name, lv_name, SANLK_NAME_LEN);
+			rd.rs.flags = (sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+							      (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 
 			rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 			if (!rv) {
@@ -626,7 +834,8 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 	char lock_lv_name[MAX_ARGS+1];
 	uint64_t offset;
 	uint32_t io_timeout;
-	int align_size;
+	int sector_size = 0;
+	int align_size = 0;
 	int i, rv;
 
 	memset(&disk, 0, sizeof(disk));
@@ -655,20 +864,13 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 	/* FIXME: device is not always ready for us here */
 	sleep(1);
 
-	align_size = sanlock_align(&disk);
-	if (align_size <= 0) {
-		log_error("S %s rename_vg_san bad align size %d %s",
-			  ls_name, align_size, disk.path);
-		return -EINVAL;
-	}
-
 	/*
 	 * Lockspace
 	 */
 
 	memset(&ss, 0, sizeof(ss));
 	memcpy(ss.host_id_disk.path, disk.path, SANLK_PATH_LEN);
-	ss.host_id_disk.offset = LS_BEGIN * align_size;
+	ss.host_id_disk.offset = 0;
 
 	rv = sanlock_read_lockspace(&ss, 0, &io_timeout);
 	if (rv < 0) {
@@ -677,6 +879,26 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 		return rv;
 	}
 
+	if ((ss.flags & SANLK_LSF_SECTOR4K) && (ss.flags & SANLK_LSF_ALIGN8M)) {
+		sector_size = 4096;
+		align_size = 8 * ONE_MB;
+	} else if ((ss.flags & SANLK_LSF_SECTOR512) && (ss.flags & SANLK_LSF_ALIGN1M)) {
+		sector_size = 512;
+		align_size = ONE_MB;
+	} else {
+		/* use the old method */
+		align_size = sanlock_align(&ss.host_id_disk);
+		if (align_size <= 0) {
+			log_error("S %s rename_vg_san unknown sector/align size for %s",
+				 ls_name, ss.host_id_disk.path);
+			return -1;
+		}
+		sector_size = (align_size == ONE_MB) ? 512 : 4096;
+	}
+
+	if (!sector_size || !align_size)
+		return -1;
+
 	strncpy(ss.name, ls_name, SANLK_NAME_LEN);
 
 	rv = sanlock_write_lockspace(&ss, 0, 0, sanlock_io_timeout);
@@ -830,6 +1052,11 @@ int lm_ex_disable_gl_sanlock(struct lockspace *ls)
 	rd1.rs.num_disks = 1;
 	strncpy(rd1.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
 	rd1.rs.disks[0].offset = lms->align_size * GL_LOCK_BEGIN;
+	
+	rd1.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+						    (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
+	rd2.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+						    (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 
 	rv = sanlock_acquire(lms->sock, -1, 0, 1, &rs1, NULL);
 	if (rv < 0) {
@@ -891,6 +1118,8 @@ int lm_able_gl_sanlock(struct lockspace *ls, int enable)
 	rd.rs.num_disks = 1;
 	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
 	rd.rs.disks[0].offset = lms->align_size * GL_LOCK_BEGIN;
+	rd.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+						   (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 
 	rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
 	if (rv < 0) {
@@ -936,7 +1165,8 @@ static int gl_is_enabled(struct lockspace *ls, struct lm_sanlock *lms)
 
 	rv = sanlock_read_resource(&rd.rs, 0);
 	if (rv < 0) {
-		log_error("gl_is_enabled read_resource error %d", rv);
+		log_error("gl_is_enabled read_resource align_size %d offset %llu error %d",
+			  lms->align_size, (unsigned long long)offset, rv);
 		return rv;
 	}
 
@@ -973,7 +1203,7 @@ int lm_gl_is_enabled(struct lockspace *ls)
  * been disabled.)
  */
 
-int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
+int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset, int *sector_size, int *align_size)
 {
 	struct lm_sanlock *lms = (struct lm_sanlock *)ls->lm_data;
 	struct sanlk_resourced rd;
@@ -983,15 +1213,22 @@ int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
 	int round = 0;
 
 	if (daemon_test) {
-		*free_offset = (1048576 * LV_LOCK_BEGIN) + (1048576 * (daemon_test_lv_count + 1));
+		*free_offset = (ONE_MB * LV_LOCK_BEGIN) + (ONE_MB * (daemon_test_lv_count + 1));
+		*sector_size = 512;
+		*align_size = ONE_MB;
 		return 0;
 	}
 
+	*sector_size = lms->sector_size;
+	*align_size = lms->align_size;
+
 	memset(&rd, 0, sizeof(rd));
 
 	strncpy(rd.rs.lockspace_name, ls->name, SANLK_NAME_LEN);
 	rd.rs.num_disks = 1;
 	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
+	rd.rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) :
+						   (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 
 	if (ls->free_lock_offset)
 		offset = ls->free_lock_offset;
@@ -1091,6 +1328,8 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 	char disk_path[SANLK_PATH_LEN];
 	char killpath[SANLK_PATH_LEN];
 	char killargs[SANLK_PATH_LEN];
+	int sector_size = 0;
+	int align_size = 0;
 	int gl_found;
 	int ret, rv;
 
@@ -1160,7 +1399,7 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 		goto fail;
 	}
 
-	lms = malloc(sizeof(struct lm_sanlock));
+	lms = zalloc(sizeof(struct lm_sanlock));
 	if (!lms) {
 		ret = -ENOMEM;
 		goto fail;
@@ -1169,7 +1408,6 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 	memset(lsname, 0, sizeof(lsname));
 	strncpy(lsname, ls->name, SANLK_NAME_LEN);
 
-	memset(lms, 0, sizeof(struct lm_sanlock));
 	memcpy(lms->ss.name, lsname, SANLK_NAME_LEN);
 	lms->ss.host_id_disk.offset = 0;
 	lms->ss.host_id = ls->host_id;
@@ -1207,13 +1445,34 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 		goto fail;
 	}
 
-	lms->align_size = sanlock_align(&lms->ss.host_id_disk);
-	if (lms->align_size <= 0) {
-		log_error("S %s prepare_lockspace_san align error %d", lsname, lms->align_size);
+	rv = get_sizes_lockspace(disk_path, &sector_size, &align_size);
+	if (rv < 0) {
+		log_error("S %s prepare_lockspace_san cannot get sector/align sizes %d", lsname, rv);
 		ret = -EMANAGER;
 		goto fail;
 	}
 
+	if (!sector_size) {
+		log_debug("S %s prepare_lockspace_san using old size method", lsname);
+		/* use the old method */
+		align_size = sanlock_align(&lms->ss.host_id_disk);
+		if (align_size <= 0) {
+			log_error("S %s prepare_lockspace_san align error %d", lsname, align_size);
+			ret = -EINVAL;
+			goto fail;
+		}
+		sector_size = (align_size == ONE_MB) ? 512 : 4096;
+		log_debug("S %s prepare_lockspace_san found old sector_size %d align_size %d", lsname, sector_size, align_size);
+	}
+
+	log_debug("S %s prepare_lockspace_san sizes %d %d", lsname, sector_size, align_size);
+
+	lms->align_size = align_size;
+	lms->sector_size = sector_size;
+
+	lms->ss.flags = (sector_size == 4096) ? (SANLK_LSF_SECTOR4K | SANLK_LSF_ALIGN8M) :
+						(SANLK_LSF_SECTOR512 | SANLK_LSF_ALIGN1M);
+
 	gl_found = gl_is_enabled(ls, lms);
 	if (gl_found < 0) {
 		log_error("S %s prepare_lockspace_san gl_enabled error %d", lsname, gl_found);
@@ -1351,6 +1610,7 @@ static int lm_add_resource_sanlock(struct lockspace *ls, struct resource *r)
 	strncpy(rds->rs.name, r->name, SANLK_NAME_LEN);
 	rds->rs.num_disks = 1;
 	memcpy(rds->rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN);
+	rds->rs.flags = (lms->sector_size == 4096) ? (SANLK_RES_SECTOR4K | SANLK_RES_ALIGN8M) : (SANLK_RES_SECTOR512 | SANLK_RES_ALIGN1M);
 
 	if (r->type == LD_RT_GL)
 		rds->rs.disks[0].offset = GL_LOCK_BEGIN * lms->align_size;
@@ -1360,10 +1620,9 @@ static int lm_add_resource_sanlock(struct lockspace *ls, struct resource *r)
 	/* LD_RT_LV offset is set in each lm_lock call from lv_args. */
 
 	if (r->type == LD_RT_GL || r->type == LD_RT_VG) {
-		rds->vb = malloc(sizeof(struct val_blk));
+		rds->vb = zalloc(sizeof(struct val_blk));
 		if (!rds->vb)
 			return -ENOMEM;
-		memset(rds->vb, 0, sizeof(struct val_blk));
 	}
 
 	return 0;
@@ -1860,12 +2119,20 @@ int lm_unlock_sanlock(struct lockspace *ls, struct resource *r,
 	if (rv < 0)
 		log_error("S %s R %s unlock_san release error %d", ls->name, r->name, rv);
 
-	if (rv == -EIO)
-		rv = -ELOCKIO;
-	else if (rv < 0)
-		rv = -ELMERR;
+	/*
+	 * sanlock may return an error here if it fails to release the lease on
+	 * disk because of an io timeout.  But, sanlock will continue trying to
+	 * release the lease after this call returns.  We shouldn't return an
+	 * error here which would result in lvmlockd-core keeping the lock
+	 * around.  By releasing the lock in lvmlockd-core at this point,
+	 * lvmlockd may send another acquire request to lvmlockd.  If sanlock
+	 * has not been able to release the previous instance of the lock yet,
+	 * then it will return an error for the new request.  But, acquiring a
+	 * new lock is able o fail gracefully, until sanlock is finally able to
+	 * release the old lock.
+	 */
 
-	return rv;
+	return 0;
 }
 
 int lm_hosts_sanlock(struct lockspace *ls, int notify)

daemons/lvmpolld/Makefile.in

@@ -29,15 +29,16 @@ include $(top_builddir)/make.tmpl
 
 CFLAGS += $(EXTRA_EXEC_CFLAGS)
 INCLUDES += -I$(top_srcdir)/libdaemon/server
-LDFLAGS += -L$(top_builddir)/libdaemon/server $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS)
-LIBS += $(DAEMON_LIBS) -ldaemonserver $(PTHREAD_LIBS)
+LDFLAGS += $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS)
+LIBS += $(DAEMON_LIBS) $(PTHREAD_LIBS)
 
-lvmpolld: $(OBJECTS) $(top_builddir)/libdaemon/client/libdaemonclient.a \
-		    $(top_builddir)/libdaemon/server/libdaemonserver.a
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(INTERNAL_LIBS) $(LIBS)
+lvmpolld: $(OBJECTS) $(top_builddir)/libdaemon/server/libdaemonserver.a $(INTERNAL_LIBS)
+	@echo "    [CC] $@"
+	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $+ $(LIBS)
 
 install_lvmpolld: lvmpolld
-	$(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
+	@echo "    [INSTALL] $<"
+	$(Q) $(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
 
 install_lvm2: install_lvmpolld
 

daemons/lvmpolld/lvmpolld-common.h

@@ -18,8 +18,6 @@
 #ifndef _LVM_LVMPOLLD_COMMON_H
 #define _LVM_LVMPOLLD_COMMON_H
 
-#define _REENTRANT
-
 #include "tools/tool.h"
 
 #include "lvmpolld-cmd-utils.h"

daemons/lvmpolld/lvmpolld-core.c

@@ -915,7 +915,7 @@ int main(int argc, char *argv[])
 	int option_index = 0;
 	int client = 0, server = 0;
 	unsigned action = ACTION_MAX;
-	struct timeval timeout;
+	struct timespec timeout;
 	daemon_idle di = { .ptimeout = &timeout };
 	struct lvmpolld_state ls = { .log_config = "" };
 	daemon_state s = {

device_mapper/Makefile

@@ -10,8 +10,12 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
+# NOTE: this Makefile only works as 'include' for toplevel Makefile
+#       which defined all top_* variables
+
 DEVICE_MAPPER_SOURCE=\
 	device_mapper/datastruct/bitset.c \
+	device_mapper/ioctl/libdm-iface.c \
 	device_mapper/libdm-common.c \
 	device_mapper/libdm-config.c \
 	device_mapper/libdm-deptree.c \
@@ -24,29 +28,25 @@ DEVICE_MAPPER_SOURCE=\
 	device_mapper/regex/matcher.c \
 	device_mapper/regex/parse_rx.c \
 	device_mapper/regex/ttree.c \
-	device_mapper/ioctl/libdm-iface.c \
-	device_mapper/vdo/vdo_target.c \
-	device_mapper/vdo/status.c
+	device_mapper/vdo/status.c \
+	device_mapper/vdo/vdo_target.c
 
-DEVICE_MAPPER_DEPENDS=$(addprefix $(top_builddir)/,$(subst .c,.d,$(DEVICE_MAPPER_SOURCE)))
-DEVICE_MAPPER_OBJECTS=$(addprefix $(top_builddir)/,$(subst .c,.o,$(DEVICE_MAPPER_SOURCE)))
-CLEAN_TARGETS+=$(DEVICE_MAPPER_DEPENDS) $(DEVICE_MAPPER_OBJECTS)
+DEVICE_MAPPER_TARGET = device_mapper/libdevice-mapper.a
+DEVICE_MAPPER_DEPENDS = $(DEVICE_MAPPER_SOURCE:%.c=%.d)
+DEVICE_MAPPER_OBJECTS = $(DEVICE_MAPPER_SOURCE:%.c=%.o)
+CLEAN_TARGETS += $(DEVICE_MAPPER_DEPENDS) $(DEVICE_MAPPER_OBJECTS) \
+	$(DEVICE_MAPPER_SOURCE:%.c=%.gcda) \
+	$(DEVICE_MAPPER_SOURCE:%.c=%.gcno) \
+	$(DEVICE_MAPPER_TARGET)
 
 #$(DEVICE_MAPPER_DEPENDS): INCLUDES+=$(VDO_INCLUDES)
 #$(DEVICE_MAPPER_OBJECTS): INCLUDES+=$(VDO_INCLUDES)
 
-ifeq ("$(USE_TRACKING)","yes")
-ifeq (,$(findstring $(MAKECMDGOALS),cscope.out cflow clean distclean lcov \
- help check check_local check_cluster check_lvmetad check_lvmpolld))
-	-include $(DEVICE_MAPPER_DEPENDS)
-endif
-endif
-
-$(DEVICE_MAPPER_OBJECTS): INCLUDES+=-I$(top_srcdir)/device_mapper/
-
-$(top_builddir)/device_mapper/libdevice-mapper.a: $(DEVICE_MAPPER_OBJECTS)
+$(DEVICE_MAPPER_TARGET): $(DEVICE_MAPPER_OBJECTS)
 	@echo "    [AR] $@"
 	$(Q) $(RM) $@
 	$(Q) $(AR) rsv $@ $(DEVICE_MAPPER_OBJECTS) > /dev/null
 
-CLEAN_TARGETS+=$(top_builddir)/device_mapper/libdevice-mapper.a
+ifeq ("$(DEPENDS)","yes")
+-include $(DEVICE_MAPPER_DEPENDS)
+endif

device_mapper/all.h

@@ -116,10 +116,14 @@ enum {
 	DM_DEVICE_MKNODES,
 
 	DM_DEVICE_LIST_VERSIONS,
-	
+
 	DM_DEVICE_TARGET_MSG,
 
-	DM_DEVICE_SET_GEOMETRY
+	DM_DEVICE_SET_GEOMETRY,
+
+	DM_DEVICE_ARM_POLL,
+
+	DM_DEVICE_GET_TARGET_VERSION
 };
 
 /*
@@ -388,6 +392,15 @@ struct dm_status_writecache {
 int dm_get_status_writecache(struct dm_pool *mem, const char *params,
                              struct dm_status_writecache **status);
 
+struct dm_status_integrity {
+	uint64_t number_of_mismatches;
+	uint64_t provided_data_sectors;
+	uint64_t recalc_sector;
+};
+
+int dm_get_status_integrity(struct dm_pool *mem, const char *params,
+                            struct dm_status_integrity **status);
+
 /*
  * Parse params from STATUS call for snapshot target
  *
@@ -901,6 +914,7 @@ int dm_tree_node_add_raid_target_with_params_v2(struct dm_tree_node *node,
 #define DM_CACHE_FEATURE_WRITETHROUGH 0x00000002
 #define DM_CACHE_FEATURE_PASSTHROUGH  0x00000004
 #define DM_CACHE_FEATURE_METADATA2    0x00000008 /* cache v1.10 */
+#define DM_CACHE_FEATURE_NO_DISCARD_PASSDOWN 0x00000010
 
 struct dm_config_node;
 /*
@@ -922,14 +936,78 @@ int dm_tree_node_add_cache_target(struct dm_tree_node *node,
 				  const char *origin_uuid,
 				  const char *policy_name,
 				  const struct dm_config_node *policy_settings,
+				  uint64_t metadata_start,
+				  uint64_t metadata_len,
+				  uint64_t data_start,
+				  uint64_t data_len,
 				  uint32_t data_block_size);
 
+struct writecache_settings {
+	uint64_t high_watermark;
+	uint64_t low_watermark;
+	uint64_t writeback_jobs;
+	uint64_t autocommit_blocks;
+	uint64_t autocommit_time; /* in milliseconds */
+	uint32_t fua;
+	uint32_t nofua;
+
+	/*
+	 * Allow an unrecognized key and its val to be passed to the kernel for
+	 * cases where a new kernel setting is added but lvm doesn't know about
+	 * it yet.
+	 */
+	char *new_key;
+	char *new_val;
+
+	/*
+	 * Flag is 1 if a value has been set.
+	 */
+	unsigned high_watermark_set:1;
+	unsigned low_watermark_set:1;
+	unsigned writeback_jobs_set:1;
+	unsigned autocommit_blocks_set:1;
+	unsigned autocommit_time_set:1;
+	unsigned fua_set:1;
+	unsigned nofua_set:1;
+};
+
 int dm_tree_node_add_writecache_target(struct dm_tree_node *node,
 				uint64_t size,
 				const char *origin_uuid,
 				const char *cache_uuid,
-				int pmem);
+				int pmem,
+				uint32_t writecache_block_size,
+				struct writecache_settings *settings);
 
+struct integrity_settings {
+	char mode[8];
+	uint32_t tag_size;
+	const char *internal_hash;
+
+	uint32_t journal_sectors;
+	uint32_t interleave_sectors;
+	uint32_t buffer_sectors;
+	uint32_t journal_watermark;
+	uint32_t commit_time;
+	uint32_t block_size;
+	uint32_t bitmap_flush_interval;
+	uint64_t sectors_per_bit;
+
+	unsigned journal_sectors_set:1;
+	unsigned interleave_sectors_set:1;
+	unsigned buffer_sectors_set:1;
+	unsigned journal_watermark_set:1;
+	unsigned commit_time_set:1;
+	unsigned block_size_set:1;
+	unsigned bitmap_flush_interval_set:1;
+	unsigned sectors_per_bit_set:1;
+};
+
+int dm_tree_node_add_integrity_target(struct dm_tree_node *node,
+				uint64_t size,
+				const char *origin_uuid,
+				const char *meta_uuid,
+				struct integrity_settings *settings);
 
 /*
  * VDO target
@@ -937,6 +1015,7 @@ int dm_tree_node_add_writecache_target(struct dm_tree_node *node,
 int dm_tree_node_add_vdo_target(struct dm_tree_node *node,
 				uint64_t size,
 				const char *data_uuid,
+				uint64_t data_size,
 				const struct dm_vdo_target_params *param);
 
 /*

device_mapper/ioctl/libdm-iface.c

@@ -15,6 +15,7 @@
 
 #include "base/memory/zalloc.h"
 #include "device_mapper/misc/dmlib.h"
+#include "device_mapper/misc/dm-ioctl.h"
 #include "device_mapper/ioctl/libdm-targets.h"
 #include "device_mapper/libdm-common.h"
 
@@ -32,11 +33,9 @@
 #else
 #  define MAJOR(x) major((x))
 #  define MINOR(x) minor((x))
-#  define MKDEV(x,y) makedev((x),(y))
+#  define MKDEV(x,y) makedev(((dev_t)x),((dev_t)y))
 #endif
 
-#include "device_mapper/misc/dm-ioctl.h"
-
 /*
  * Ensure build compatibility.  
  * The hard-coded versions here are the highest present 
@@ -117,6 +116,12 @@ static struct cmd_data _cmd_data_v4[] = {
 #ifdef DM_DEV_SET_GEOMETRY
 	{"setgeometry",	DM_DEV_SET_GEOMETRY,	{4, 6, 0}},
 #endif
+#ifdef DM_DEV_ARM_POLL
+	{"armpoll",	DM_DEV_ARM_POLL,	{4, 36, 0}},
+#endif
+#ifdef DM_GET_TARGET_VERSION
+	{"target-version", DM_GET_TARGET_VERSION, {4, 41, 0}},
+#endif
 };
 /* *INDENT-ON* */
 
@@ -261,7 +266,7 @@ static int _control_exists(const char *control, uint32_t major, uint32_t minor)
 		return -1;
 	}
 
-	if (major && buf.st_rdev != MKDEV((dev_t)major, (dev_t)minor)) {
+	if (major && buf.st_rdev != MKDEV(major, minor)) {
 		log_verbose("%s: Wrong device number: (%u, %u) instead of "
 			    "(%u, %u)", control,
 			    MAJOR(buf.st_mode), MINOR(buf.st_mode),
@@ -304,7 +309,7 @@ static int _create_control(const char *control, uint32_t major, uint32_t minor)
 	(void) dm_prepare_selinux_context(control, S_IFCHR);
 	old_umask = umask(DM_CONTROL_NODE_UMASK);
 	if (mknod(control, S_IFCHR | S_IRUSR | S_IWUSR,
-		  MKDEV((dev_t)major, (dev_t)minor)) < 0)  {
+		  MKDEV(major, minor)) < 0)  {
 		log_sys_error("mknod", control);
 		ret = 0;
 	}
@@ -468,6 +473,7 @@ static void _dm_zfree_string(char *string)
 {
 	if (string) {
 		memset(string, 0, strlen(string));
+		asm volatile ("" ::: "memory"); /* Compiler barrier. */
 		free(string);
 	}
 }
@@ -476,6 +482,7 @@ static void _dm_zfree_dmi(struct dm_ioctl *dmi)
 {
 	if (dmi) {
 		memset(dmi, 0, dmi->data_size);
+		asm volatile ("" ::: "memory"); /* Compiler barrier. */
 		free(dmi);
 	}
 }
@@ -1082,6 +1089,22 @@ static int _lookup_dev_name(uint64_t dev, char *buf, size_t len)
 	return r;
 }
 
+static int _add_params(int type)
+{
+	switch (type) {
+	case DM_DEVICE_REMOVE_ALL:
+	case DM_DEVICE_CREATE:
+	case DM_DEVICE_REMOVE:
+	case DM_DEVICE_SUSPEND:
+	case DM_DEVICE_STATUS:
+	case DM_DEVICE_CLEAR:
+	case DM_DEVICE_ARM_POLL:
+		return 0; /* IOCTL_FLAGS_NO_PARAMS in drivers/md/dm-ioctl.c */
+	default:
+		return 1;
+	}
+}
+
 static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
 {
 	const size_t min_size = 16 * 1024;
@@ -1094,11 +1117,15 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
 	char *b, *e;
 	int count = 0;
 
-	for (t = dmt->head; t; t = t->next) {
-		len += sizeof(struct dm_target_spec);
-		len += strlen(t->params) + 1 + ALIGNMENT;
-		count++;
-	}
+	if (_add_params(dmt->type))
+		for (t = dmt->head; t; t = t->next) {
+			len += sizeof(struct dm_target_spec);
+			len += strlen(t->params) + 1 + ALIGNMENT;
+			count++;
+		}
+	else if (dmt->head)
+		log_debug_activation(INTERNAL_ERROR "dm '%s' ioctl should not define parameters.",
+				     _cmd_data_v4[dmt->type].name);
 
 	if (count && (dmt->sector || dmt->message)) {
 		log_error("targets and message are incompatible");
@@ -1182,7 +1209,7 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
 		}
 
 		dmi->flags |= DM_PERSISTENT_DEV_FLAG;
-		dmi->dev = MKDEV((dev_t)dmt->major, (dev_t)dmt->minor);
+		dmi->dev = MKDEV(dmt->major, dmt->minor);
 	}
 
 	/* Does driver support device number referencing? */
@@ -1248,9 +1275,10 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
 	b = (char *) (dmi + 1);
 	e = (char *) dmi + len;
 
-	for (t = dmt->head; t; t = t->next)
-		if (!(b = _add_target(t, b, e)))
-			goto_bad;
+	if (_add_params(dmt->type))
+		for (t = dmt->head; t; t = t->next)
+			if (!(b = _add_target(t, b, e)))
+				goto_bad;
 
 	if (dmt->newname)
 		strcpy(b, dmt->newname);
@@ -1454,6 +1482,7 @@ static int _create_and_load_v4(struct dm_task *dmt)
 	dmt->uuid = NULL;
 	free(dmt->mangled_uuid);
 	dmt->mangled_uuid = NULL;
+	_dm_task_free_targets(dmt);
 
 	if (dm_task_run(dmt))
 		return 1;
@@ -1464,6 +1493,7 @@ static int _create_and_load_v4(struct dm_task *dmt)
 	dmt->uuid = NULL;
 	free(dmt->mangled_uuid);
 	dmt->mangled_uuid = NULL;
+	_dm_task_free_targets(dmt);
 
 	/*
 	 * Also udev-synchronize "remove" dm task that is a part of this revert!

device_mapper/libdm-common.c

@@ -1042,7 +1042,7 @@ static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
 {
 	char path[PATH_MAX];
 	struct stat info;
-	dev_t dev = MKDEV((dev_t)major, (dev_t)minor);
+	dev_t dev = MKDEV(major, minor);
 	mode_t old_mask;
 
 	if (!_build_dev_path(path, sizeof(path), dev_name))
@@ -1765,7 +1765,7 @@ static int _mountinfo_parse_line(const char *line, unsigned *maj, unsigned *min,
 			return 0;
 		}
 		devmapper += 12; /* skip fixed prefix */
-		for (i = 0; devmapper[i] && devmapper[i] != ' ' && i < sizeof(root); ++i)
+		for (i = 0; devmapper[i] && devmapper[i] != ' ' && i < sizeof(root)-1; ++i)
 			root[i] = devmapper[i];
 		root[i] = 0;
 		_unmangle_mountinfo_string(root, buf);
@@ -1874,6 +1874,120 @@ bad:
 	return r;
 }
 
+static int _sysfs_get_dev_major_minor(const char *path, uint32_t major, uint32_t minor)
+{
+	FILE *fp;
+	uint32_t ma, mi;
+	int r;
+
+	if (!(fp = fopen(path, "r")))
+		return 0;
+
+	r = (fscanf(fp, "%" PRIu32 ":%" PRIu32 , &ma, &mi) == 2) &&
+		(ma == major) && (mi == minor);
+	// log_debug("Checking %s  %u:%u  -> %d", path, ma, mi, r);
+
+	if (fclose(fp))
+		log_sys_error("fclose", path);
+
+	return r;
+}
+
+static int _sysfs_find_kernel_name(uint32_t major, uint32_t minor, char *buf, size_t buf_size)
+{
+	const char *name, *name_dev;
+	char path[PATH_MAX];
+	struct dirent *dirent, *dirent_dev;
+	DIR *d, *d_dev;
+	struct stat st;
+	int r = 0, sz;
+
+	if (!*_sysfs_dir ||
+	    dm_snprintf(path, sizeof(path), "%s/block/", _sysfs_dir) < 0) {
+		log_error("Failed to build sysfs_path.");
+		return 0;
+	}
+
+	if (!(d = opendir(path))) {
+		log_sys_error("opendir", path);
+		return 0;
+	}
+
+	while (!r && (dirent = readdir(d))) {
+		name = dirent->d_name;
+
+		if (!strcmp(name, ".") || !strcmp(name, ".."))
+			continue;
+
+		if ((sz = dm_snprintf(path, sizeof(path), "%sblock/%s/dev",
+				      _sysfs_dir, name)) == -1) {
+			log_warn("Couldn't create path for %s.", name);
+			continue;
+		}
+
+		if (_sysfs_get_dev_major_minor(path, major, minor)) {
+			r = dm_strncpy(buf, name, buf_size);
+			break; /* found */
+		}
+
+		path[sz - 4] = 0; /* strip /dev from end of path string */
+		if (stat(path, &st))
+			continue;
+
+		if (S_ISDIR(st.st_mode)) {
+
+			/* let's assume there is no tree-complex device in past systems */
+			if (!(d_dev = opendir(path))) {
+				log_sys_debug("opendir", path);
+				continue;
+			}
+
+			while ((dirent_dev = readdir(d_dev))) {
+				name_dev = dirent_dev->d_name;
+
+				/* skip known ignorable paths */
+				if (!strcmp(name_dev, ".") || !strcmp(name_dev, "..") ||
+				    !strcmp(name_dev, "bdi") ||
+				    !strcmp(name_dev, "dev") ||
+				    !strcmp(name_dev, "device") ||
+				    !strcmp(name_dev, "holders") ||
+				    !strcmp(name_dev, "integrity") ||
+				    !strcmp(name_dev, "loop") ||
+				    !strcmp(name_dev, "queueu") ||
+				    !strcmp(name_dev, "md") ||
+				    !strcmp(name_dev, "mq") ||
+				    !strcmp(name_dev, "power") ||
+				    !strcmp(name_dev, "removable") ||
+				    !strcmp(name_dev, "slave") ||
+				    !strcmp(name_dev, "slaves") ||
+				    !strcmp(name_dev, "subsystem") ||
+				    !strcmp(name_dev, "trace") ||
+				    !strcmp(name_dev, "uevent"))
+					continue;
+
+				if (dm_snprintf(path, sizeof(path), "%sblock/%s/%s/dev",
+						_sysfs_dir, name, name_dev) == -1) {
+					log_warn("Couldn't create path for %s/%s.", name, name_dev);
+					continue;
+				}
+
+				if (_sysfs_get_dev_major_minor(path, major, minor)) {
+					r = dm_strncpy(buf, name_dev, buf_size);
+					break; /* found */
+				}
+			}
+
+			if (closedir(d_dev))
+				log_sys_debug("closedir", name);
+		}
+	}
+
+	if (closedir(d))
+		log_sys_debug("closedir", path);
+
+	return r;
+}
+
 static int _sysfs_get_kernel_name(uint32_t major, uint32_t minor, char *buf, size_t buf_size)
 {
 	char *name, *sysfs_path, *temp_buf = NULL;
@@ -1896,8 +2010,11 @@ static int _sysfs_get_kernel_name(uint32_t major, uint32_t minor, char *buf, siz
 	if ((size = readlink(sysfs_path, temp_buf, PATH_MAX - 1)) < 0) {
 		if (errno != ENOENT)
 			log_sys_error("readlink", sysfs_path);
-		else
+		else {
 			log_sys_debug("readlink", sysfs_path);
+			r = _sysfs_find_kernel_name(major, minor, buf, buf_size);
+			goto out;
+		}
 		goto bad;
 	}
 	temp_buf[size] = '\0';
@@ -1917,6 +2034,7 @@ static int _sysfs_get_kernel_name(uint32_t major, uint32_t minor, char *buf, siz
 	strcpy(buf, name);
 	r = 1;
 bad:
+out:
 	free(temp_buf);
 	free(sysfs_path);
 

device_mapper/libdm-config.c

@@ -51,6 +51,8 @@ struct parser {
 
 	struct dm_pool *mem;
 	int no_dup_node_check;	/* whether to disable dup node checking */
+	const char *key;        /* last obtained key */
+	unsigned ignored_creation_time;
 };
 
 struct config_output {
@@ -176,7 +178,7 @@ static int _do_dm_config_parse(struct dm_config_tree *cft, const char *start, co
 	/* TODO? if (start == end) return 1; */
 
 	struct parser *p;
-	if (!(p = dm_pool_alloc(cft->mem, sizeof(*p))))
+	if (!(p = dm_pool_zalloc(cft->mem, sizeof(*p))))
 		return_0;
 
 	p->mem = cft->mem;
@@ -615,6 +617,7 @@ static struct dm_config_node *_section(struct parser *p, struct dm_config_node *
 		match(TOK_SECTION_E);
 	} else {
 		match(TOK_EQ);
+		p->key = root->key;
 		if (!(value = _value(p)))
 			return_NULL;
 		if (root->v)
@@ -682,8 +685,17 @@ static struct dm_config_value *_type(struct parser *p)
 		errno = 0;
 		v->v.i = strtoll(p->tb, NULL, 0);	/* FIXME: check error */
 		if (errno) {
-			log_error("Failed to read int token.");
-			return NULL;
+			if (errno == ERANGE && p->key &&
+			    strcmp("creation_time", p->key) == 0) {
+				/* Due to a bug in some older 32bit builds (<2.02.169),
+				 * lvm was able to produce invalid creation_time string */
+				v->v.i = 1527120000; /* Pick 2018-05-24 day instead */
+				if (!p->ignored_creation_time++)
+					log_warn("WARNING: Invalid creation_time found in metadata (repaired with next metadata update).");
+			} else {
+				log_error("Failed to read int token.");
+				return NULL;
+			}
 		}
 		match(TOK_INT);
 		break;

device_mapper/libdm-deptree.c

@@ -21,7 +21,6 @@
 
 #include <stdarg.h>
 #include <string.h>
-#include <sys/param.h>
 #include <sys/utsname.h>
 
 #define MAX_TARGET_PARAMSIZE 500000
@@ -39,6 +38,7 @@ enum {
 	SEG_STRIPED,
 	SEG_ZERO,
 	SEG_WRITECACHE,
+	SEG_INTEGRITY,
 	SEG_THIN_POOL,
 	SEG_THIN,
 	SEG_VDO,
@@ -79,6 +79,7 @@ static const struct {
 	{ SEG_STRIPED, "striped" },
 	{ SEG_ZERO, "zero"},
 	{ SEG_WRITECACHE, "writecache"},
+	{ SEG_INTEGRITY, "integrity"},
 	{ SEG_THIN_POOL, "thin-pool"},
 	{ SEG_THIN, "thin"},
 	{ SEG_VDO, "vdo" },
@@ -192,6 +193,11 @@ struct load_segment {
 	uint32_t min_recovery_rate;	/* raid kB/sec/disk */
 	uint32_t data_copies;		/* raid10 data_copies */
 
+	uint64_t metadata_start;	/* Cache */
+	uint64_t metadata_len;		/* Cache */
+	uint64_t data_start;		/* Cache */
+	uint64_t data_len;		/* Cache */
+
 	struct dm_tree_node *metadata;	/* Thin_pool + Cache */
 	struct dm_tree_node *pool;	/* Thin_pool, Thin */
 	struct dm_tree_node *external;	/* Thin */
@@ -199,6 +205,7 @@ struct load_segment {
 	uint64_t transaction_id;	/* Thin_pool */
 	uint64_t low_water_mark;	/* Thin_pool */
 	uint32_t data_block_size;       /* Thin_pool + cache */
+	uint32_t migration_threshold;   /* Cache */
 	unsigned skip_block_zeroing;	/* Thin_pool */
 	unsigned ignore_discard;	/* Thin_pool target vsn 1.1 */
 	unsigned no_discard_passdown;	/* Thin_pool target vsn 1.1 */
@@ -210,9 +217,16 @@ struct load_segment {
 	struct dm_tree_node *vdo_data;  /* VDO */
 	struct dm_vdo_target_params vdo_params; /* VDO */
 	const char *vdo_name;           /* VDO - device name is ALSO passed as table arg */
+	uint64_t vdo_data_size;		/* VDO - size of data storage device */
 
-	struct dm_tree_node *cachevol;	/* writecache */
-	int cachevol_pmem;
+	struct dm_tree_node *writecache_node;		/* writecache */
+	int writecache_pmem;				/* writecache, 1 if pmem, 0 if ssd */
+	uint32_t writecache_block_size;			/* writecache, in bytes */
+	struct writecache_settings writecache_settings;	/* writecache */
+
+	uint64_t integrity_data_sectors;		/* integrity (provided_data_sectors) */
+	struct dm_tree_node *integrity_meta_node;	/* integrity */
+	struct integrity_settings integrity_settings;	/* integrity */
 };
 
 /* Per-device properties */
@@ -537,7 +551,7 @@ static struct dm_tree_node *_create_dm_tree_node(struct dm_tree *dtree,
 	dm_list_init(&node->activated);
 	dm_list_init(&node->props.segs);
 
-	dev = MKDEV((dev_t)info->major, (dev_t)info->minor);
+	dev = MKDEV(info->major, info->minor);
 
 	if (!dm_hash_insert_binary(dtree->devs, (const char *) &dev,
 				   sizeof(dev), node)) {
@@ -560,7 +574,7 @@ static struct dm_tree_node *_create_dm_tree_node(struct dm_tree *dtree,
 static struct dm_tree_node *_find_dm_tree_node(struct dm_tree *dtree,
 					       uint32_t major, uint32_t minor)
 {
-	dev_t dev = MKDEV((dev_t)major, (dev_t)minor);
+	dev_t dev = MKDEV(major, minor);
 
 	return dm_hash_lookup_binary(dtree->devs, (const char *) &dev,
 				     sizeof(dev));
@@ -1492,7 +1506,7 @@ static int _node_message(uint32_t major, uint32_t minor,
 			 int expected_errno, const char *message)
 {
 	struct dm_task *dmt;
-	int r;
+	int r = 0;
 
 	if (!(dmt = dm_task_create(DM_DEVICE_TARGET_MSG)))
 		return_0;
@@ -1758,7 +1772,12 @@ static int _dm_tree_deactivate_children(struct dm_tree_node *dnode,
 
 		if (info.open_count) {
 			/* Skip internal non-toplevel opened nodes */
-			if (level)
+			/* On some old udev systems without corrrect udev rules
+			 * this hack avoids 'leaking' active _mimageX legs after
+			 * deactivation of mirror LV. Other suffixes are not added
+			 * since it's expected newer systems with wider range of
+			 * supported targets also use better udev */
+			if (level && !strstr(name, "_mimage"))
 				continue;
 
 			/* When retry is not allowed, error */
@@ -1798,7 +1817,7 @@ static int _dm_tree_deactivate_children(struct dm_tree_node *dnode,
 
 		if (!_deactivate_node(name, info.major, info.minor,
 				      &child->dtree->cookie, child->udev_flags,
-				      (level == 0) ? child->dtree->retry_remove : 0)) {
+				      child->dtree->retry_remove)) {
 			log_error("Unable to deactivate %s (" FMTu32 ":"
 				  FMTu32 ").", name, info.major, info.minor);
 			r = 0;
@@ -2550,7 +2569,7 @@ static int _cache_emit_segment_line(struct dm_task *dmt,
 				    char *params, size_t paramsize)
 {
 	int pos = 0;
-	/* unsigned feature_count; */
+	unsigned feature_count;
 	char data[DM_FORMAT_DEV_BUFSIZE];
 	char metadata[DM_FORMAT_DEV_BUFSIZE];
 	char origin[DM_FORMAT_DEV_BUFSIZE];
@@ -2575,29 +2594,37 @@ static int _cache_emit_segment_line(struct dm_task *dmt,
 	EMIT_PARAMS(pos, " %u", seg->data_block_size);
 
 	/* Features */
-	/* feature_count = hweight32(seg->flags); */
-	/* EMIT_PARAMS(pos, " %u", feature_count); */
+
+	feature_count = 1; /* One of passthrough|writeback|writethrough is always set. */
+
 	if (seg->flags & DM_CACHE_FEATURE_METADATA2)
-		EMIT_PARAMS(pos, " 2 metadata2 ");
-	else
-		EMIT_PARAMS(pos, " 1 ");
+		feature_count++;
+
+	EMIT_PARAMS(pos, " %u", feature_count);
+
+	if (seg->flags & DM_CACHE_FEATURE_METADATA2)
+		EMIT_PARAMS(pos, " metadata2");
 
 	if (seg->flags & DM_CACHE_FEATURE_PASSTHROUGH)
-		EMIT_PARAMS(pos, "passthrough");
+		EMIT_PARAMS(pos, " passthrough");
         else if (seg->flags & DM_CACHE_FEATURE_WRITEBACK)
-		EMIT_PARAMS(pos, "writeback");
+		EMIT_PARAMS(pos, " writeback");
 	else
-		EMIT_PARAMS(pos, "writethrough");
+		EMIT_PARAMS(pos, " writethrough");
 
 	/* Cache Policy */
 	name = seg->policy_name ? : "default";
 
 	EMIT_PARAMS(pos, " %s", name);
 
-	EMIT_PARAMS(pos, " %u", seg->policy_argc * 2);
+	/* Do not pass migration_threshold 2048 which is default */
+	EMIT_PARAMS(pos, " %u", (seg->policy_argc + (seg->migration_threshold != 2048) ? 1 : 0) * 2);
+	if (seg->migration_threshold != 2048)
+		    EMIT_PARAMS(pos, " migration_threshold %u", seg->migration_threshold);
 	if (seg->policy_settings)
 		for (cn = seg->policy_settings->child; cn; cn = cn->sib)
-			EMIT_PARAMS(pos, " %s %" PRIu64, cn->key, cn->v->v.i);
+			if (cn->v) /* Skip deleted entry */
+				EMIT_PARAMS(pos, " %s %" PRIu64, cn->key, cn->v->v.i);
 
 	return 1;
 }
@@ -2607,18 +2634,155 @@ static int _writecache_emit_segment_line(struct dm_task *dmt,
 				    char *params, size_t paramsize)
 {
 	int pos = 0;
+	int count = 0;
+	uint32_t block_size;
 	char origin_dev[DM_FORMAT_DEV_BUFSIZE];
 	char cache_dev[DM_FORMAT_DEV_BUFSIZE];
 
 	if (!_build_dev_string(origin_dev, sizeof(origin_dev), seg->origin))
 		return_0;
 
-	if (!_build_dev_string(cache_dev, sizeof(cache_dev), seg->cachevol))
+	if (!_build_dev_string(cache_dev, sizeof(cache_dev), seg->writecache_node))
 		return_0;
 
-	EMIT_PARAMS(pos, "%s %s %s 4096 0",
-		    seg->cachevol_pmem ? "p" : "s",
-		    origin_dev, cache_dev);
+	if (seg->writecache_settings.high_watermark_set)
+		count += 2;
+	if (seg->writecache_settings.low_watermark_set)
+		count += 2;
+	if (seg->writecache_settings.writeback_jobs_set)
+		count += 2;
+	if (seg->writecache_settings.autocommit_blocks_set)
+		count += 2;
+	if (seg->writecache_settings.autocommit_time_set)
+		count += 2;
+	if (seg->writecache_settings.fua_set)
+		count += 1;
+	if (seg->writecache_settings.nofua_set)
+		count += 1;
+	if (seg->writecache_settings.new_key)
+		count += 2;
+
+	if (!(block_size = seg->writecache_block_size))
+		block_size = 4096;
+
+	EMIT_PARAMS(pos, "%s %s %s %u %d",
+		    seg->writecache_pmem ? "p" : "s",
+		    origin_dev, cache_dev, block_size, count);
+
+	if (seg->writecache_settings.high_watermark_set) {
+		EMIT_PARAMS(pos, " high_watermark %llu",
+			(unsigned long long)seg->writecache_settings.high_watermark);
+	}
+
+	if (seg->writecache_settings.low_watermark_set) {
+		EMIT_PARAMS(pos, " low_watermark %llu",
+			(unsigned long long)seg->writecache_settings.low_watermark);
+	}
+
+	if (seg->writecache_settings.writeback_jobs_set) {
+		EMIT_PARAMS(pos, " writeback_jobs %llu",
+			(unsigned long long)seg->writecache_settings.writeback_jobs);
+	}
+
+	if (seg->writecache_settings.autocommit_blocks_set) {
+		EMIT_PARAMS(pos, " autocommit_blocks %llu",
+			(unsigned long long)seg->writecache_settings.autocommit_blocks);
+	}
+
+	if (seg->writecache_settings.autocommit_time_set) {
+		EMIT_PARAMS(pos, " autocommit_time %llu",
+			(unsigned long long)seg->writecache_settings.autocommit_time);
+	}
+
+	if (seg->writecache_settings.fua_set) {
+		EMIT_PARAMS(pos, " fua");
+	}
+
+	if (seg->writecache_settings.nofua_set) {
+		EMIT_PARAMS(pos, " nofua");
+	}
+
+	if (seg->writecache_settings.new_key) {
+		EMIT_PARAMS(pos, " %s %s",
+			seg->writecache_settings.new_key,
+			seg->writecache_settings.new_val);
+	}
+
+	return 1;
+}
+
+static int _integrity_emit_segment_line(struct dm_task *dmt,
+				    struct load_segment *seg,
+				    char *params, size_t paramsize)
+{
+	struct integrity_settings *set = &seg->integrity_settings;
+	int pos = 0;
+	int count;
+	char origin_dev[DM_FORMAT_DEV_BUFSIZE];
+	char meta_dev[DM_FORMAT_DEV_BUFSIZE];
+
+	if (!_build_dev_string(origin_dev, sizeof(origin_dev), seg->origin))
+		return_0;
+
+	if (seg->integrity_meta_node &&
+	    !_build_dev_string(meta_dev, sizeof(meta_dev), seg->integrity_meta_node))
+		return_0;
+
+	count = 1; /* for internal_hash which we always pass in */
+
+	if (seg->integrity_meta_node)
+		count++;
+
+	if (set->journal_sectors_set)
+		count++;
+	if (set->interleave_sectors_set)
+		count++;
+	if (set->buffer_sectors_set)
+		count++;
+	if (set->journal_watermark_set)
+		count++;
+	if (set->commit_time_set)
+		count++;
+	if (set->block_size_set)
+		count++;
+	if (set->bitmap_flush_interval_set)
+		count++;
+	if (set->sectors_per_bit_set)
+		count++;
+
+	EMIT_PARAMS(pos, "%s 0 %u %s %d internal_hash:%s",
+		    origin_dev,
+		    set->tag_size,
+		    set->mode,
+		    count,
+		    set->internal_hash);
+
+	if (seg->integrity_meta_node)
+		EMIT_PARAMS(pos, " meta_device:%s", meta_dev);
+
+	if (set->journal_sectors_set)
+		EMIT_PARAMS(pos, " journal_sectors:%u", set->journal_sectors);
+
+	if (set->interleave_sectors_set)
+		EMIT_PARAMS(pos, " ineterleave_sectors:%u", set->interleave_sectors);
+
+	if (set->buffer_sectors_set)
+		EMIT_PARAMS(pos, " buffer_sectors:%u", set->buffer_sectors);
+
+	if (set->journal_watermark_set)
+		EMIT_PARAMS(pos, " journal_watermark:%u", set->journal_watermark);
+
+	if (set->commit_time_set)
+		EMIT_PARAMS(pos, " commit_time:%u", set->commit_time);
+
+	if (set->block_size_set)
+		EMIT_PARAMS(pos, " block_size:%u", set->block_size);
+
+	if (set->bitmap_flush_interval_set)
+		EMIT_PARAMS(pos, " bitmap_flush_interval:%u", set->bitmap_flush_interval);
+
+	if (set->sectors_per_bit_set)
+		EMIT_PARAMS(pos, " sectors_per_bit:%llu", (unsigned long long)set->sectors_per_bit);
 
 	return 1;
 }
@@ -2666,20 +2830,21 @@ static int _vdo_emit_segment_line(struct dm_task *dmt,
 	/* Unlike normal targets, current VDO requires device path */
 	if (dm_snprintf(data_dev, sizeof(data_dev), "/dev/dm-%u", seg->vdo_data->info.minor) < 0) {
 		log_error("Can create VDO data volume path for %s.", data);
-		return_0;
+		return 0;
 	}
 
-	EMIT_PARAMS(pos, "%s %u %s " FMTu64 " " FMTu64 " %u on %s %s "
-		    "ack=%u,bio=%u,bioRotationInterval=%u,cpu=%u,hash=%u,logical=%u,physical=%u",
+	EMIT_PARAMS(pos, "V2 %s " FMTu64 " %u " FMTu64 " %u %s %s %s "
+		    "maxDiscard %u ack %u bio %u bioRotationInterval %u cpu %u hash %u logical %u physical %u",
 		    data_dev,
-		    (seg->vdo_params.emulate_512_sectors == 0) ? 4096 : 512,
-		    seg->vdo_params.use_read_cache ? "enabled" : "disabled",
-		    seg->vdo_params.read_cache_size_mb * UINT64_C(256),		// 1MiB -> 4KiB units
+		    seg->vdo_data_size / 8, // this parameter is in 4K units
+		    seg->vdo_params.minimum_io_size * UINT32_C(512), //  sector to byte units
 		    seg->vdo_params.block_map_cache_size_mb * UINT64_C(256),	// 1MiB -> 4KiB units
-		    seg->vdo_params.block_map_period,
+		    seg->vdo_params.block_map_era_length,
+		    seg->vdo_params.use_metadata_hints ? "on" : "off" ,
 		    (seg->vdo_params.write_policy == DM_VDO_WRITE_POLICY_SYNC) ? "sync" :
 			(seg->vdo_params.write_policy == DM_VDO_WRITE_POLICY_ASYNC) ? "async" : "auto", // policy
 		    seg->vdo_name,
+		    seg->vdo_params.max_discard,
 		    seg->vdo_params.ack_threads,
 		    seg->vdo_params.bio_threads,
 		    seg->vdo_params.bio_rotation,
@@ -2806,6 +2971,10 @@ static int _emit_segment_line(struct dm_task *dmt, uint32_t major,
 		if (!_writecache_emit_segment_line(dmt, seg, params, paramsize))
 			return_0;
 		break;
+	case SEG_INTEGRITY:
+		if (!_integrity_emit_segment_line(dmt, seg, params, paramsize))
+			return_0;
+		break;
 	}
 
 	switch(seg->type) {
@@ -2818,6 +2987,7 @@ static int _emit_segment_line(struct dm_task *dmt, uint32_t major,
 	case SEG_THIN:
 	case SEG_CACHE:
 	case SEG_WRITECACHE:
+	case SEG_INTEGRITY:
 		break;
 	case SEG_CRYPT:
 	case SEG_LINEAR:
@@ -3501,6 +3671,10 @@ int dm_tree_node_add_cache_target(struct dm_tree_node *node,
 				  const char *origin_uuid,
 				  const char *policy_name,
 				  const struct dm_config_node *policy_settings,
+				  uint64_t metadata_start,
+				  uint64_t metadata_len,
+				  uint64_t data_start,
+				  uint64_t data_len,
 				  uint32_t data_block_size)
 {
 	struct dm_config_node *cn;
@@ -3576,9 +3750,14 @@ int dm_tree_node_add_cache_target(struct dm_tree_node *node,
 	if (!_link_tree_nodes(node, seg->origin))
 		return_0;
 
+	seg->metadata_start = metadata_start;
+	seg->metadata_len = metadata_len;
+	seg->data_start = data_start;
+	seg->data_len = data_len;
 	seg->data_block_size = data_block_size;
 	seg->flags = feature_flags;
 	seg->policy_name = policy_name;
+	seg->migration_threshold = 2048; /* Default migration threshold 1MiB */
 
 	/* FIXME: better validation missing */
 	if (policy_settings) {
@@ -3591,10 +3770,18 @@ int dm_tree_node_add_cache_target(struct dm_tree_node *node,
 				log_error("Cache policy parameter %s is without integer value.", cn->key);
 				return 0;
 			}
-			seg->policy_argc++;
+			if (strcmp(cn->key, "migration_threshold") == 0) {
+				seg->migration_threshold = cn->v->v.i;
+				cn->v = NULL; /* skip this entry */
+			} else
+				seg->policy_argc++;
 		}
 	}
 
+	/* Always some throughput available for cache to proceed */
+	if (seg->migration_threshold < data_block_size * 8)
+		seg->migration_threshold = data_block_size * 8;
+
 	return 1;
 }
 
@@ -3602,31 +3789,72 @@ int dm_tree_node_add_writecache_target(struct dm_tree_node *node,
 				  uint64_t size,
 				  const char *origin_uuid,
 				  const char *cache_uuid,
-				  int pmem)
+				  int pmem,
+				  uint32_t writecache_block_size,
+				  struct writecache_settings *settings)
 {
 	struct load_segment *seg;
 
 	if (!(seg = _add_segment(node, SEG_WRITECACHE, size)))
 		return_0;
 
-	seg->cachevol_pmem = pmem;
+	seg->writecache_pmem = pmem;
+	seg->writecache_block_size = writecache_block_size;
 
-	if (!(seg->cachevol = dm_tree_find_node_by_uuid(node->dtree,
-							cache_uuid))) {
-		log_error("Missing writecache's cachevol uuid %s.", cache_uuid);
+	if (!(seg->writecache_node = dm_tree_find_node_by_uuid(node->dtree, cache_uuid))) {
+		log_error("Missing writecache's cache uuid %s.", cache_uuid);
 		return 0;
 	}
-	if (!_link_tree_nodes(node, seg->cachevol))
+	if (!_link_tree_nodes(node, seg->writecache_node))
 		return_0;
 
-	if (!(seg->origin = dm_tree_find_node_by_uuid(node->dtree,
-						      origin_uuid))) {
+	if (!(seg->origin = dm_tree_find_node_by_uuid(node->dtree, origin_uuid))) {
 		log_error("Missing writecache's origin uuid %s.", origin_uuid);
 		return 0;
 	}
 	if (!_link_tree_nodes(node, seg->origin))
 		return_0;
 
+	memcpy(&seg->writecache_settings, settings, sizeof(struct writecache_settings));
+
+	if (settings->new_key && settings->new_val) {
+		seg->writecache_settings.new_key = dm_pool_strdup(node->dtree->mem, settings->new_key);
+		seg->writecache_settings.new_val = dm_pool_strdup(node->dtree->mem, settings->new_val);
+	}
+
+	return 1;
+}
+
+int dm_tree_node_add_integrity_target(struct dm_tree_node *node,
+				  uint64_t size,
+				  const char *origin_uuid,
+				  const char *meta_uuid,
+				  struct integrity_settings *settings)
+{
+	struct load_segment *seg;
+
+	if (!(seg = _add_segment(node, SEG_INTEGRITY, size)))
+		return_0;
+
+	if (meta_uuid) {
+		if (!(seg->integrity_meta_node = dm_tree_find_node_by_uuid(node->dtree, meta_uuid))) {
+			log_error("Missing integrity's meta uuid %s.", meta_uuid);
+			return 0;
+		}
+
+		if (!_link_tree_nodes(node, seg->integrity_meta_node))
+			return_0;
+	}
+
+	if (!(seg->origin = dm_tree_find_node_by_uuid(node->dtree, origin_uuid))) {
+		log_error("Missing integrity's origin uuid %s.", origin_uuid);
+		return 0;
+	}
+	if (!_link_tree_nodes(node, seg->origin))
+		return_0;
+
+	memcpy(&seg->integrity_settings, settings, sizeof(struct integrity_settings));
+
 	return 1;
 }
 
@@ -4086,13 +4314,14 @@ int dm_tree_node_add_cache_target_base(struct dm_tree_node *node,
 
 	return dm_tree_node_add_cache_target(node, size, feature_flags & _mask,
 					     metadata_uuid, data_uuid, origin_uuid,
-					     policy_name, policy_settings, data_block_size);
+					     policy_name, policy_settings, 0, 0, 0, 0, data_block_size);
 }
 #endif
 
 int dm_tree_node_add_vdo_target(struct dm_tree_node *node,
 				uint64_t size,
 				const char *data_uuid,
+				uint64_t data_size,
 				const struct dm_vdo_target_params *vtp)
 {
 	struct load_segment *seg;
@@ -4113,6 +4342,7 @@ int dm_tree_node_add_vdo_target(struct dm_tree_node *node,
 
 	seg->vdo_params = *vtp;
 	seg->vdo_name = node->name;
+	seg->vdo_data_size = data_size;
 
 	node->props.send_messages = 2;
 

device_mapper/libdm-file.c

@@ -222,6 +222,8 @@ retry_fcntl:
 		goto fail_close_unlink;
 	}
 
+	/* coverity[leaked_handle] intentional leak of fd handle here  */
+
 	return 1;
 
 fail_close_unlink:

device_mapper/libdm-report.c

@@ -2381,7 +2381,7 @@ static const char *_get_reserved(struct dm_report *rh, unsigned type,
 {
 	const struct dm_report_reserved_value *iter = implicit ? NULL : rh->reserved_values;
 	const struct dm_report_field_reserved_value *frv;
-	const char *tmp_begin, *tmp_end, *tmp_s = s;
+	const char *tmp_begin = NULL, *tmp_end = NULL, *tmp_s = s;
 	const char *name = NULL;
 	char c;
 

device_mapper/libdm-targets.c

@@ -296,6 +296,8 @@ int dm_get_status_cache(struct dm_pool *mem, const char *params,
 			s->feature_flags |= DM_CACHE_FEATURE_PASSTHROUGH;
 		else if (!strncmp(p, "metadata2 ", 10))
 			s->feature_flags |= DM_CACHE_FEATURE_METADATA2;
+		else if (!strncmp(p, "no_discard_passdown ", 20))
+			s->feature_flags |= DM_CACHE_FEATURE_NO_DISCARD_PASSDOWN;
 		else
 			log_error("Unknown feature in status: %s", params);
 
@@ -378,6 +380,35 @@ int dm_get_status_writecache(struct dm_pool *mem, const char *params,
 	return 1;
 }
 
+int dm_get_status_integrity(struct dm_pool *mem, const char *params,
+			     struct dm_status_integrity **status)
+{
+	struct dm_status_integrity *s;
+	char recalc_str[8];
+
+	if (!(s = dm_pool_zalloc(mem, sizeof(struct dm_status_integrity))))
+		return_0;
+
+	memset(recalc_str, 0, sizeof(recalc_str));
+
+	if (sscanf(params, "%llu %llu %s",
+		   (unsigned long long *)&s->number_of_mismatches,
+		   (unsigned long long *)&s->provided_data_sectors,
+		   recalc_str) != 3) {
+		log_error("Failed to parse integrity params: %s.", params);
+		dm_pool_free(mem, s);
+		return 0;
+	}
+
+	if (recalc_str[0] == '-')
+		s->recalc_sector = 0;
+	else
+		s->recalc_sector = strtoull(recalc_str, NULL, 0);
+
+	*status = s;
+	return 1;
+}
+
 int parse_thin_pool_status(const char *params, struct dm_status_thin_pool *s)
 {
 	int pos;

device_mapper/misc/dm-ioctl.h

@@ -244,6 +244,7 @@ enum {
 	DM_TARGET_MSG_CMD,
 	DM_DEV_SET_GEOMETRY_CMD,
 	DM_DEV_ARM_POLL_CMD,
+	DM_GET_TARGET_VERSION_CMD,
 };
 
 #define DM_IOCTL 0xfd
@@ -270,6 +271,8 @@ enum {
 #define DM_TARGET_MSG	 _IOWR(DM_IOCTL, DM_TARGET_MSG_CMD, struct dm_ioctl)
 #define DM_DEV_SET_GEOMETRY	_IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 
+#define DM_GET_TARGET_VERSION	_IOWR(DM_IOCTL, DM_GET_TARGET_VERSION_CMD, struct dm_ioctl)
+
 #define DM_VERSION_MAJOR	4
 #define DM_VERSION_MINOR	36
 #define DM_VERSION_PATCHLEVEL	0

device_mapper/misc/dmlib.h

@@ -21,11 +21,6 @@
 
 // FIXME: get rid of this whole file
  
-#include "configure.h"
-
-#define _REENTRANT
-#define _GNU_SOURCE
-
 #include "device_mapper/all.h"
 #include "lib/misc/util.h"
 #include "dm-logging.h"

device_mapper/misc/kdev_t.h

@@ -17,6 +17,6 @@
 
 #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))
+#define MKDEV(ma,mi)    (((dev_t)mi & 0xff) | ((dev_t)ma << 8) | (((dev_t)mi & ~0xff) << 12))
 
 #endif

device_mapper/mm/pool.c

@@ -59,11 +59,13 @@ char *dm_pool_strdup(struct dm_pool *p, const char *str)
 
 char *dm_pool_strndup(struct dm_pool *p, const char *str, size_t n)
 {
+	size_t slen = strlen(str);
+	size_t len = (slen < n) ? slen : n;
 	char *ret = dm_pool_alloc(p, n + 1);
 
 	if (ret) {
-		strncpy(ret, str, n);
-		ret[n] = '\0';
+		ret[len] = '\0';
+		memcpy(ret, str, len);
 	}
 
 	return ret;

device_mapper/vdo/status.c

@@ -1,8 +1,24 @@
-#include "configure.h"
-#include "target.h"
+/*
+ * Copyright (C) 2018 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * 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
+ */
 
-// For DM_ARRAY_SIZE!
+/* Note: this object is also used by VDO dmeventd plugin for parsing status */
+/* File could be included by VDO plugin and can use original libdm library */
+#ifndef LIB_DMEVENT_H
 #include "device_mapper/all.h"
+#endif
+
+#include "device_mapper/vdo/target.h"
 #include "base/memory/zalloc.h"
 
 #include <ctype.h>
@@ -154,7 +170,7 @@ static void _set_error(struct dm_vdo_status_parse_result *result, const char *fm
 	va_list ap;
 
 	va_start(ap, fmt);
-	vsnprintf(result->error, sizeof(result->error), fmt, ap);
+	(void) vsnprintf(result->error, sizeof(result->error), fmt, ap);
 	va_end(ap);
 }
 
@@ -184,7 +200,7 @@ static bool _parse_field(const char **b, const char *e,
 bool dm_vdo_status_parse(struct dm_pool *mem, const char *input,
 			 struct dm_vdo_status_parse_result *result)
 {
-	const char *b = b = input;
+	const char *b = input;
 	const char *e = input + strlen(input);
 	const char *te;
 	struct dm_vdo_status *s;
@@ -203,11 +219,10 @@ bool dm_vdo_status_parse(struct dm_pool *mem, const char *input,
 		goto bad;
 	}
 
-	if (!(s->device = (!mem) ? malloc((e - b) + 1) : dm_pool_alloc(mem, (e - b) + 1))) {
+	if (!(s->device = (!mem) ? strndup(b, (te - b)) : dm_pool_alloc(mem, (te - b)))) {
 		_set_error(result, "out of memory");
 		goto bad;
 	}
-	dm_strncpy(s->device, b, te - b + 1);
 
 	b = _eat_space(te, e);
 

device_mapper/vdo/target.h

@@ -74,16 +74,16 @@ enum dm_vdo_write_policy {
 
 // FIXME: review whether we should use the createParams from the userlib
 struct dm_vdo_target_params {
+	uint32_t minimum_io_size;       // in sectors
 	uint32_t block_map_cache_size_mb;
-	uint32_t block_map_period;
+	uint32_t block_map_era_length;	// format period
 
 	uint32_t check_point_frequency;
-	uint32_t index_memory_size_mb;
+	uint32_t index_memory_size_mb;  // format
 
-	uint32_t read_cache_size_mb;
-
-	uint32_t slab_size_mb;
+	uint32_t slab_size_mb;          // format
 
+	uint32_t max_discard;
 	// threads
 	uint32_t ack_threads;
 	uint32_t bio_threads;
@@ -95,9 +95,8 @@ struct dm_vdo_target_params {
 
 	bool use_compression;
 	bool use_deduplication;
-	bool emulate_512_sectors;
-	bool use_sparse_index;
-	bool use_read_cache;
+	bool use_metadata_hints;
+	bool use_sparse_index;          // format
 
 	// write policy
 	enum dm_vdo_write_policy write_policy;

device_mapper/vdo/vdo_limits.h

@@ -21,8 +21,8 @@
 #define DM_VDO_BLOCK_MAP_CACHE_SIZE_MAXIMUM_MB	(16 * 1024 * 1024 - 1)	// 16TiB - 1
 #define DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_PER_LOGICAL_THREAD  (4096 * DM_VDO_BLOCK_SIZE_KB)
 
-#define DM_VDO_BLOCK_MAP_PERIOD_MINIMUM		1
-#define DM_VDO_BLOCK_MAP_PERIOD_MAXIMUM		(16380)
+#define DM_VDO_BLOCK_MAP_ERA_LENGTH_MINIMUM	(1)
+#define DM_VDO_BLOCK_MAP_ERA_LENGTH_MAXIMUM	(16380)
 
 #define DM_VDO_INDEX_MEMORY_SIZE_MINIMUM_MB	(256)			// 0.25 GiB
 #define DM_VDO_INDEX_MEMORY_SIZE_MAXIMUM_MB	(1024 * 1024 * 1024)	// 1TiB
@@ -57,4 +57,7 @@
 //#define DM_VDO_PHYSICAL_THREADS_MINIMUM	(0)
 #define DM_VDO_PHYSICAL_THREADS_MAXIMUM		(16)
 
+#define DM_VDO_MAX_DISCARD_MINIMUM		(1)
+#define DM_VDO_MAX_DISCARD_MAXIMUM		(UINT32_MAX / 4096)
+
 #endif // DEVICE_MAPPER_VDO_LIMITS_H

device_mapper/vdo/vdo_target.c

@@ -23,6 +23,14 @@ bool dm_vdo_validate_target_params(const struct dm_vdo_target_params *vtp,
 {
 	bool valid = true;
 
+	/* 512 or 4096 bytes only ATM */
+	if ((vtp->minimum_io_size != 1) &&
+	    (vtp->minimum_io_size != 8)) {
+		log_error("VDO minimum io size %u is unsupported.",
+			  vtp->minimum_io_size);
+		valid = false;
+	}
+
 	if ((vtp->block_map_cache_size_mb < DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_MB) ||
 	    (vtp->block_map_cache_size_mb > DM_VDO_BLOCK_MAP_CACHE_SIZE_MAXIMUM_MB)) {
 		log_error("VDO block map cache size %u out of range.",
@@ -37,12 +45,6 @@ bool dm_vdo_validate_target_params(const struct dm_vdo_target_params *vtp,
 		valid = false;
 	}
 
-	if (vtp->read_cache_size_mb > DM_VDO_READ_CACHE_SIZE_MAXIMUM_MB) {
-		log_error("VDO read cache size %u out of range.",
-			  vtp->read_cache_size_mb);
-		valid = false;
-	}
-
 	if ((vtp->slab_size_mb < DM_VDO_SLAB_SIZE_MINIMUM_MB) ||
 	    (vtp->slab_size_mb > DM_VDO_SLAB_SIZE_MAXIMUM_MB)) {
 		log_error("VDO slab size %u out of range.",
@@ -50,6 +52,13 @@ bool dm_vdo_validate_target_params(const struct dm_vdo_target_params *vtp,
 		valid = false;
 	}
 
+	if ((vtp->max_discard < DM_VDO_MAX_DISCARD_MINIMUM) ||
+	    (vtp->max_discard > DM_VDO_MAX_DISCARD_MAXIMUM)) {
+		log_error("VDO max discard %u out of range.",
+			  vtp->max_discard);
+		valid = false;
+	}
+
 	if (vtp->ack_threads > DM_VDO_ACK_THREADS_MAXIMUM) {
 		log_error("VDO ack threads %u out of range.", vtp->ack_threads);
 		valid = false;

include/Makefile.in

@@ -18,7 +18,7 @@ top_builddir = @top_builddir@
 
 include $(top_builddir)/make.tmpl
 
-DISTCLEAN_TARGETS += .configure.h lvm-version.h
+DISTCLEAN_TARGETS += configure.h lvm-version.h
 CLEAN_TARGETS += \
  .symlinks \
  .symlinks_created \

include/configure.h.in

@@ -45,9 +45,6 @@
 /* Name of default metadata cache subdirectory. */
 #undef DEFAULT_CACHE_SUBDIR
 
-/* Default data alignment. */
-#undef DEFAULT_DATA_ALIGNMENT
-
 /* Define default node creation behavior with dmsetup create */
 #undef DEFAULT_DM_ADD_NODE
 
@@ -90,9 +87,6 @@
 /* Use blkid wiping by default. */
 #undef DEFAULT_USE_BLKID_WIPING
 
-/* Use lvmetad by default. */
-#undef DEFAULT_USE_LVMETAD
-
 /* Use lvmlockd by default. */
 #undef DEFAULT_USE_LVMLOCKD
 
@@ -298,6 +292,12 @@
 /* Define to 1 if you have the <paths.h> header file. */
 #undef HAVE_PATHS_H
 
+/* Define to 1 if you have the `prlimit' function. */
+#undef HAVE_PRLIMIT
+
+/* Define to 1 if you have the `pselect' function. */
+#undef HAVE_PSELECT
+
 /* Define to 1 if the system has the type `ptrdiff_t'. */
 #undef HAVE_PTRDIFF_T
 
@@ -537,6 +537,9 @@
 /* Locale-dependent data */
 #undef LOCALEDIR
 
+/* Define to 1 to include code that uses lvmlockd dlm control option. */
+#undef LOCKDDLM_CONTROL_SUPPORT
+
 /* Define to 1 to include code that uses lvmlockd dlm option. */
 #undef LOCKDDLM_SUPPORT
 
@@ -550,12 +553,6 @@
 /* Path to lvmconfig binary. */
 #undef LVMCONFIG_PATH
 
-/* Path to lvmetad pidfile. */
-#undef LVMETAD_PIDFILE
-
-/* Define to 1 to include code that uses lvmetad. */
-#undef LVMETAD_SUPPORT
-
 /* Path to lvmlockd pidfile. */
 #undef LVMLOCKD_PIDFILE
 
@@ -678,6 +675,15 @@
 /* Define to 1 to include built-in support for vdo. */
 #undef VDO_INTERNAL
 
+/* Define to 1 to include built-in support for writecache. */
+#undef WRITECACHE_INTERNAL
+
+/* Define to get access to GNU/Linux extension */
+#undef _GNU_SOURCE
+
+/* Define to use re-entrant thread safe versions */
+#undef _REENTRANT
+
 /* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
    <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
    #define below would cause a syntax error. */

lib/Makefile.in

@@ -20,6 +20,7 @@ SOURCES =\
 	activate/activate.c \
 	cache/lvmcache.c \
 	writecache/writecache.c \
+	integrity/integrity.c \
 	cache_segtype/cache.c \
 	commands/toolcontext.c \
 	config/config.c \
@@ -61,10 +62,13 @@ SOURCES =\
 	format_text/text_label.c \
 	freeseg/freeseg.c \
 	label/label.c \
+	label/hints.c \
 	locking/file_locking.c \
 	locking/locking.c \
 	log/log.c \
 	metadata/cache_manip.c \
+	metadata/writecache_manip.c \
+	metadata/integrity_manip.c \
 	metadata/lv.c \
 	metadata/lv_manip.c \
 	metadata/merge.c \
@@ -91,6 +95,7 @@ SOURCES =\
 	misc/lvm-string.c \
 	misc/lvm-wrappers.c \
 	misc/lvm-percent.c \
+	misc/sharedlib.c \
 	mm/memlock.c \
 	notify/lvmnotify.c \
 	properties/prop_common.c \
@@ -109,10 +114,6 @@ ifeq ("@DEVMAPPER@", "yes")
 	activate/fs.c
 endif
 
-ifeq ("@HAVE_LIBDL@", "yes")
-  SOURCES += misc/sharedlib.c
-endif
-
 ifeq ("@BUILD_LVMPOLLD@", "yes")
   SOURCES +=\
 	lvmpolld/lvmpolld-client.c
@@ -130,12 +131,6 @@ endif
 LIB_NAME = liblvm-internal
 LIB_STATIC = $(LIB_NAME).a
 
-ifeq ($(MAKECMDGOALS),distclean)
-  SUBDIRS =\
-	notify \
-	locking
-endif
-
 CFLOW_LIST = $(SOURCES)
 CFLOW_LIST_TARGET = $(LIB_NAME).cflow
 

lib/activate/activate.c

@@ -28,7 +28,6 @@
 #include "lib/config/config.h"
 #include "lib/metadata/segtype.h"
 #include "lib/misc/sharedlib.h"
-#include "lib/cache/lvmcache.h"
 #include "lib/metadata/metadata.h"
 
 #include <limits.h>
@@ -540,25 +539,7 @@ int target_version(const char *target_name, uint32_t *maj,
 
 int lvm_dm_prefix_check(int major, int minor, const char *prefix)
 {
-	struct dm_task *dmt;
-	const char *uuid;
-	int r;
-
-	if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
-		return_0;
-
-	if (!dm_task_set_minor(dmt, minor) ||
-	    !dm_task_set_major(dmt, major) ||
-	    !dm_task_run(dmt) ||
-	    !(uuid = dm_task_get_uuid(dmt))) {
-		dm_task_destroy(dmt);
-		return 0;
-	}
-
-	r = strncasecmp(uuid, prefix, strlen(prefix));
-	dm_task_destroy(dmt);
-
-	return r ? 0 : 1;
+	return dev_manager_check_prefix_dm_major_minor(major, minor, prefix);
 }
 
 int module_present(struct cmd_context *cmd, const char *target_name)
@@ -639,7 +620,7 @@ static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv,
 		    int use_layer, struct lvinfo *info,
 		    const struct lv_segment *seg,
 		    struct lv_seg_status *seg_status,
-		    int with_open_count, int with_read_ahead)
+		    int with_open_count, int with_read_ahead, int with_name_check)
 {
 	struct dm_info dminfo;
 
@@ -657,7 +638,7 @@ 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, lv, NULL, 0, 0, 0, &dminfo, NULL, NULL))
 			return_0;
 		if (!dminfo.exists)
 			use_layer = 1;
@@ -670,8 +651,9 @@ static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv,
 
 	if (!dev_manager_info(cmd, lv,
 			      (use_layer) ? lv_layer(lv) : NULL,
-			      with_open_count, with_read_ahead,
-			      &dminfo, (info) ? &info->read_ahead : NULL,
+			      with_open_count, with_read_ahead, with_name_check,
+			      &dminfo,
+			      (info) ? &info->read_ahead : NULL,
 			      seg_status))
 		return_0;
 
@@ -700,7 +682,16 @@ int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, int use_la
 	if (!activation())
 		return 0;
 
-	return _lv_info(cmd, lv, use_layer, info, NULL, NULL, with_open_count, with_read_ahead);
+	return _lv_info(cmd, lv, use_layer, info, NULL, NULL, with_open_count, with_read_ahead, 0);
+}
+
+int lv_info_with_name_check(struct cmd_context *cmd, const struct logical_volume *lv,
+			    int use_layer, struct lvinfo *info)
+{
+	if (!activation())
+		return 0;
+
+	return _lv_info(cmd, lv, use_layer, info, NULL, NULL, 0, 0, 1);
 }
 
 /*
@@ -730,16 +721,16 @@ int lv_info_with_seg_status(struct cmd_context *cmd,
 		 * STATUS is collected from cache LV */
 		if (!(lv_seg = get_only_segment_using_this_lv(lv)))
 			return_0;
-		(void) _lv_info(cmd, lv_seg->lv, 1, NULL, lv_seg, &status->seg_status, 0, 0);
+		(void) _lv_info(cmd, lv_seg->lv, 1, NULL, lv_seg, &status->seg_status, 0, 0, 0);
 		return 1;
 	}
 
 	if (lv_is_thin_pool(lv)) {
 		/* Always collect status for '-tpool' */
-		if (_lv_info(cmd, lv, 1, &status->info, lv_seg, &status->seg_status, 0, 0) &&
+		if (_lv_info(cmd, lv, 1, &status->info, lv_seg, &status->seg_status, 0, 0, 0) &&
 		    (status->seg_status.type == SEG_STATUS_THIN_POOL)) {
 			/* There is -tpool device, but query 'active' state of 'fake' thin-pool */
-			if (!_lv_info(cmd, lv, 0, NULL, NULL, NULL, 0, 0) &&
+			if (!_lv_info(cmd, lv, 0, NULL, NULL, NULL, 0, 0, 0) &&
 			    !status->seg_status.thin_pool->needs_check)
 				status->info.exists = 0; /* So pool LV is not active */
 		}
@@ -748,10 +739,10 @@ int lv_info_with_seg_status(struct cmd_context *cmd,
 
 	if (lv_is_external_origin(lv)) {
 		if (!_lv_info(cmd, lv, 0, &status->info, NULL, NULL,
-			      with_open_count, with_read_ahead))
+			      with_open_count, with_read_ahead, 0))
 			return_0;
 
-		(void) _lv_info(cmd, lv, 1, NULL, lv_seg, &status->seg_status, 0, 0);
+		(void) _lv_info(cmd, lv, 1, NULL, lv_seg, &status->seg_status, 0, 0, 0);
 		return 1;
 	}
 
@@ -764,13 +755,13 @@ int lv_info_with_seg_status(struct cmd_context *cmd,
 		/* Show INFO for actual origin and grab status for merging origin */
 		if (!_lv_info(cmd, lv, 0, &status->info, lv_seg,
 			      lv_is_merging_origin(lv) ? &status->seg_status : NULL,
-			      with_open_count, with_read_ahead))
+			      with_open_count, with_read_ahead, 0))
 			return_0;
 
 		if (status->info.exists &&
 		    (status->seg_status.type != SEG_STATUS_SNAPSHOT)) /* Not merging */
 			/* Grab STATUS from layered -real */
-			(void) _lv_info(cmd, lv, 1, NULL, lv_seg, &status->seg_status, 0, 0);
+			(void) _lv_info(cmd, lv, 1, NULL, lv_seg, &status->seg_status, 0, 0, 0);
 		return 1;
 	}
 
@@ -779,10 +770,11 @@ int lv_info_with_seg_status(struct cmd_context *cmd,
 			olv = origin_from_cow(lv);
 
 			if (!_lv_info(cmd, olv, 0, &status->info, first_seg(olv), &status->seg_status,
-				      with_open_count, with_read_ahead))
+				      with_open_count, with_read_ahead, 0))
 				return_0;
 
-			if (status->seg_status.type == SEG_STATUS_SNAPSHOT) {
+			if (status->seg_status.type == SEG_STATUS_SNAPSHOT ||
+			    (lv_is_thin_volume(olv) && (status->seg_status.type == SEG_STATUS_THIN))) {
 				log_debug_activation("Snapshot merge is in progress, querying status of %s instead.",
 						     display_lvname(lv));
 				/*
@@ -800,21 +792,33 @@ int lv_info_with_seg_status(struct cmd_context *cmd,
 
 	if (lv_is_vdo(lv)) {
 		if (!_lv_info(cmd, lv, 0, &status->info, NULL, NULL,
-			      with_open_count, with_read_ahead))
+			      with_open_count, with_read_ahead, 0))
 			return_0;
 		if (status->info.exists) {
 			/* Status for VDO pool */
 			(void) _lv_info(cmd, seg_lv(lv_seg, 0), 1, NULL,
 					first_seg(seg_lv(lv_seg, 0)),
-					&status->seg_status, 0, 0);
+					&status->seg_status, 0, 0, 0);
 			/* Use VDO pool segtype result for VDO segtype */
 			status->seg_status.seg = lv_seg;
 		}
 		return 1;
 	}
 
+	if (lv_is_vdo_pool(lv)) {
+		/* Always collect status for '-vpool' */
+		if (_lv_info(cmd, lv, 1, &status->info, lv_seg, &status->seg_status, 0, 0, 0) &&
+		    (status->seg_status.type == SEG_STATUS_VDO_POOL)) {
+			/* There is -tpool device, but query 'active' state of 'fake' vdo-pool */
+			if (!_lv_info(cmd, lv, 0, NULL, NULL, NULL, 0, 0, 0))
+				status->info.exists = 0; /* So VDO pool LV is not active */
+		}
+
+		return 1;
+	}
+
 	return _lv_info(cmd, lv, 0, &status->info, lv_seg, &status->seg_status,
-			with_open_count, with_read_ahead);
+			with_open_count, with_read_ahead, 0);
 }
 
 #define OPEN_COUNT_CHECK_RETRIES 25
@@ -1174,6 +1178,26 @@ out:
 	return r;
 }
 
+int lv_writecache_message(const struct logical_volume *lv, const char *msg)
+{
+	int r = 0;
+	struct dev_manager *dm;
+
+	if (!lv_info(lv->vg->cmd, lv, 0, NULL, 0, 0)) {
+		log_error("Unable to send message to an inactive logical volume.");
+		return 0;
+	}
+
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name, 1)))
+		return_0;
+
+	r = dev_manager_writecache_message(dm, lv, msg);
+
+	dev_manager_destroy(dm);
+
+	return r;
+}
+
 /*
  * Return dm_status_cache for cache volume, accept also cache pool
  *
@@ -1340,10 +1364,8 @@ int lv_vdo_pool_status(const struct logical_volume *lv, int flush,
 {
 	int r = 0;
 	struct dev_manager *dm;
-	struct lv_status_vdo *status;
-	char *params;
 
-	if (!lv_info(lv->vg->cmd, lv, 0, NULL, 0, 0))
+	if (!lv_info(lv->vg->cmd, lv, 1, NULL, 0, 0))
 		return 0;
 
 	log_debug_activation("Checking VDO pool status for LV %s.",
@@ -1352,14 +1374,10 @@ int lv_vdo_pool_status(const struct logical_volume *lv, int flush,
 	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name, !lv_is_pvmove(lv))))
 		return_0;
 
-	if (!dev_manager_vdo_pool_status(dm, lv, flush, &params, &status))
+	if (!dev_manager_vdo_pool_status(dm, lv, vdo_status, flush))
 		goto_out;
 
-	if (!parse_vdo_pool_status(status->mem, lv, params, status))
-		goto_out;
-
-	/* User is responsible to dm_pool_destroy memory pool! */
-	*vdo_status = status;
+	/* User has to call dm_pool_destroy(vdo_status->mem) */
 	r = 1;
 out:
 	if (!r)
@@ -1368,6 +1386,19 @@ out:
 	return r;
 }
 
+int lv_vdo_pool_percent(const struct logical_volume *lv, dm_percent_t *percent)
+{
+	struct lv_status_vdo *vdo_status;
+
+	if (!lv_vdo_pool_status(lv, 0, &vdo_status))
+		return_0;
+
+	*percent = vdo_status->usage;
+	dm_pool_destroy(vdo_status->mem);
+
+	return 1;
+}
+
 static int _lv_active(struct cmd_context *cmd, const struct logical_volume *lv)
 {
 	struct lvinfo info;
@@ -1584,6 +1615,8 @@ static char *_build_target_uuid(struct cmd_context *cmd, const struct logical_vo
 
 	if (lv_is_thin_pool(lv))
 		layer = "tpool"; /* Monitor "tpool" for the "thin pool". */
+	else if (lv_is_vdo_pool(lv))
+		layer = "vpool"; /* Monitor "vpool" for the "VDO pool". */
 	else if (lv_is_origin(lv) || lv_is_external_origin(lv))
 		layer = "real"; /* Monitor "real" for "snapshot-origin". */
 	else
@@ -1740,6 +1773,8 @@ int monitor_dev_for_events(struct cmd_context *cmd, const struct logical_volume
 
 	if (!laopts)
 		laopts = &zlaopts;
+	else
+		mirr_laopts.read_only = laopts->read_only;
 
 	/* skip dmeventd code altogether */
 	if (dmeventd_monitor_mode() == DMEVENTD_MONITOR_IGNORE)
@@ -1999,6 +2034,11 @@ static int _preload_detached_lv(struct logical_volume *lv, void *data)
 		    !lv_is_raid_metadata(lv_pre) && lv_is_active(lv) &&
 		    !_lv_preload(lv_pre, detached->laopts, detached->flush_required))
 			return_0;
+	} else if (lv_is_mirror_image(lv)) {
+		if ((lv_pre = find_lv_in_vg_by_lvid(detached->lv_pre->vg, &lv->lvid)) &&
+		    !lv_is_mirror_image(lv_pre) && lv_is_active(lv) &&
+		    !_lv_preload(lv_pre, detached->laopts, detached->flush_required))
+			return_0;
 	}
 
 	if (!lv_is_visible(lv) && (lv_pre = find_lv(detached->lv_pre->vg, lv->name)) &&
@@ -2025,8 +2065,6 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 	               const struct logical_volume *lv, const struct logical_volume *lv_pre)
 {
 	const struct logical_volume *pvmove_lv = NULL;
-	const struct logical_volume *lv_to_free = NULL;
-	const struct logical_volume *lv_pre_to_free = NULL;
 	struct logical_volume *lv_pre_tmp, *lv_tmp;
 	struct seg_list *sl;
 	struct lv_segment *snap_seg;
@@ -2217,10 +2255,6 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 out:
 	if (mem)
 		dm_pool_destroy(mem);
-	if (lv_pre_to_free)
-		release_vg(lv_pre_to_free->vg);
-	if (lv_to_free)
-		release_vg(lv_to_free->vg);
 
 	return r;
 }
@@ -2381,7 +2415,6 @@ static int _lv_has_open_snapshots(const struct logical_volume *lv)
 
 int lv_deactivate(struct cmd_context *cmd, const char *lvid_s, const struct logical_volume *lv)
 {
-	const struct logical_volume *lv_to_free = NULL;
 	struct lvinfo info;
 	static const struct lv_activate_opts laopts = { .skip_in_use = 1 };
 	struct dm_list *snh;
@@ -2414,6 +2447,17 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s, const struct logi
 			}
 		}
 
+		if (lv_is_vdo_pool(lv)) {
+			/* If someone has remove 'linear' mapping over VDO device
+			 * we may still be able to deactivate the rest of the tree
+			 * i.e. in test-suite we simulate this via 'dmsetup remove' */
+			if (!lv_info(cmd, lv, 1, &info, 1, 0))
+				goto_out;
+
+			if (info.exists && !info.open_count)
+				r = 0; /* Unused VDO device left in table? */
+		}
+
 		if (r)
 			goto out;
 	}
@@ -2451,27 +2495,25 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s, const struct logi
 		r = 0;
 	}
 out:
-	if (lv_to_free)
-		release_vg(lv_to_free->vg);
 
 	return r;
 }
 
 /* Test if LV passes filter */
 int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
-			 int *activate_lv, const struct logical_volume *lv)
+			 int *activate, const struct logical_volume *lv)
 {
 	if (!activation()) {
-		*activate_lv = 1;
+		*activate = 1;
 		return 1;
 	}
 
 	if (!_passes_activation_filter(cmd, lv)) {
 		log_verbose("Not activating %s since it does not pass "
 			    "activation filter.", display_lvname(lv));
-		*activate_lv = 0;
+		*activate = 0;
 	} else
-		*activate_lv = 1;
+		*activate = 1;
 
 	return 1;
 }
@@ -2515,6 +2557,12 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
 		goto out;
 	}
 
+	if (lv_raid_has_visible_sublvs(lv)) {
+		log_error("Refusing activation of RAID LV %s with "
+			  "visible SubLVs.", display_lvname(lv));
+		goto out;
+	}
+
 	if (test_mode()) {
 		_skip("Activating %s.", display_lvname(lv));
 		r = 1;
@@ -2535,7 +2583,7 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
 			     laopts->noscan ? " noscan" : "",
 			     laopts->temporary ? " temporary" : "");
 
-	if (!lv_info(cmd, lv, 0, &info, 0, 0))
+	if (!lv_info_with_name_check(cmd, lv, 0, &info))
 		goto_out;
 
 	/*
@@ -2822,6 +2870,7 @@ int deactivate_lv_with_sub_lv(const struct logical_volume *lv)
 int activate_lv(struct cmd_context *cmd, const struct logical_volume *lv)
 {
 	const struct logical_volume *active_lv;
+	const struct logical_volume *lv_use;
 	int ret;
 
 	/*
@@ -2840,19 +2889,30 @@ int activate_lv(struct cmd_context *cmd, const struct logical_volume *lv)
 		goto out;
 	}
 
+	if (lv->status & LV_UNCOMMITTED)
+		lv_use = lv;
+	else
+		lv_use = lv_committed(lv);
+
 	ret = lv_activate_with_filter(cmd, NULL, 0,
 				      (lv->status & LV_NOSCAN) ? 1 : 0,
 				      (lv->status & LV_TEMPORARY) ? 1 : 0,
-				      lv_committed(lv));
+				      lv_use);
 out:
 	return ret;
 }
 
 int deactivate_lv(struct cmd_context *cmd, const struct logical_volume *lv)
 {
+	const struct logical_volume *lv_use;
 	int ret;
 
-	ret = lv_deactivate(cmd, NULL, lv_committed(lv));
+	if (lv->status & LV_UNCOMMITTED)
+		lv_use = lv;
+	else
+		lv_use = lv_committed(lv);
+
+	ret = lv_deactivate(cmd, NULL, lv_use);
 
 	return ret;
 }

lib/activate/activate.h

@@ -39,6 +39,7 @@ typedef enum {
 	SEG_STATUS_THIN_POOL,
 	SEG_STATUS_VDO_POOL,
 	SEG_STATUS_WRITECACHE,
+	SEG_STATUS_INTEGRITY,
 	SEG_STATUS_UNKNOWN
 } lv_seg_status_type_t;
 
@@ -53,6 +54,7 @@ struct lv_seg_status {
 		struct dm_status_thin *thin;
 		struct dm_status_thin_pool *thin_pool;
 		struct dm_status_writecache *writecache;
+		struct dm_status_integrity *integrity;
 		struct lv_status_vdo vdo_pool;
 	};
 };
@@ -144,8 +146,8 @@ int revert_lv(struct cmd_context *cmd, const struct logical_volume *lv);
  */
 int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, int use_layer,
 	    struct lvinfo *info, int with_open_count, int with_read_ahead);
-int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s, int use_layer,
-		    struct lvinfo *info, int with_open_count, int with_read_ahead);
+int lv_info_with_name_check(struct cmd_context *cmd, const struct logical_volume *lv,
+			    int use_layer, struct lvinfo *info);
 
 /*
  * Returns 1 if lv_info_and_seg_status structure has been populated,
@@ -162,10 +164,10 @@ int lv_info_with_seg_status(struct cmd_context *cmd,
 int lv_check_not_in_use(const struct logical_volume *lv, int error_if_used);
 
 /*
- * Returns 1 if activate_lv has been set: 1 = activate; 0 = don't.
+ * Returns 1 if activate has been set: 1 = activate; 0 = don't.
  */
 int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
-			 int *activate_lv, const struct logical_volume *lv);
+			 int *activate, const struct logical_volume *lv);
 /*
  * Checks against the auto_activation_volume_list and
  * returns 1 if the LV should be activated, 0 otherwise.
@@ -186,6 +188,7 @@ int lv_raid_dev_health(const struct logical_volume *lv, char **dev_health);
 int lv_raid_mismatch_count(const struct logical_volume *lv, uint64_t *cnt);
 int lv_raid_sync_action(const struct logical_volume *lv, char **sync_action);
 int lv_raid_message(const struct logical_volume *lv, const char *msg);
+int lv_writecache_message(const struct logical_volume *lv, const char *msg);
 int lv_cache_status(const struct logical_volume *cache_lv,
 		    struct lv_status_cache **status);
 int lv_thin_pool_percent(const struct logical_volume *lv, int metadata,
@@ -197,6 +200,7 @@ int lv_thin_pool_transaction_id(const struct logical_volume *lv,
 int lv_thin_device_id(const struct logical_volume *lv, uint32_t *device_id);
 int lv_vdo_pool_status(const struct logical_volume *lv, int flush,
 		       struct lv_status_vdo **status);
+int lv_vdo_pool_percent(const struct logical_volume *lv, dm_percent_t *percent);
 
 /*
  * Return number of LVs in the VG that are active.
@@ -242,6 +246,7 @@ struct dev_usable_check_params {
 	unsigned int check_suspended:1;
 	unsigned int check_error_target:1;
 	unsigned int check_reserved:1;
+	unsigned int check_lv:1;
 };
 
 /*
@@ -257,6 +262,7 @@ void fs_unlock(void);
 
 #define TARGET_NAME_CACHE "cache"
 #define TARGET_NAME_WRITECACHE "writecache"
+#define TARGET_NAME_INTEGRITY "integrity"
 #define TARGET_NAME_ERROR "error"
 #define TARGET_NAME_ERROR_OLD "erro"	/* Truncated in older kernels */
 #define TARGET_NAME_LINEAR "linear"
@@ -274,6 +280,7 @@ void fs_unlock(void);
 #define MODULE_NAME_CLUSTERED_MIRROR "clog"
 #define MODULE_NAME_CACHE TARGET_NAME_CACHE
 #define MODULE_NAME_WRITECACHE TARGET_NAME_WRITECACHE
+#define MODULE_NAME_INTEGRITY TARGET_NAME_INTEGRITY
 #define MODULE_NAME_ERROR TARGET_NAME_ERROR
 #define MODULE_NAME_LOG_CLUSTERED "log-clustered"
 #define MODULE_NAME_LOG_USERSPACE "log-userspace"

lib/activate/dev_manager.c

@@ -33,6 +33,7 @@
 #define MAX_TARGET_PARAMSIZE 50000
 #define LVM_UDEV_NOSCAN_FLAG DM_SUBSYSTEM_UDEV_FLAG0
 #define CRYPT_TEMP	"CRYPT-TEMP"
+#define CRYPT_SUBDEV	"CRYPT-SUBDEV"
 #define STRATIS		"stratis-"
 
 typedef enum {
@@ -45,7 +46,7 @@ typedef enum {
 } action_t;
 
 /* This list must match lib/misc/lvm-string.c:build_dm_uuid(). */
-const char *uuid_suffix_list[] = { "pool", "cdata", "cmeta", "tdata", "tmeta", "vdata", "vpool", NULL};
+const char *uuid_suffix_list[] = { "pool", "cdata", "cmeta", "cvol", "tdata", "tmeta", "vdata", "vpool", NULL};
 
 struct dlid_list {
 	struct dm_list list;
@@ -64,7 +65,6 @@ struct dev_manager {
 	int activation;                 /* building activation tree */
 	int suspend;			/* building suspend tree */
 	unsigned track_external_lv_deps;
-	struct dm_list pending_delete;	/* str_list of dlid(s) with pending delete */
 	unsigned track_pending_delete;
 	unsigned track_pvmove_deps;
 
@@ -85,6 +85,11 @@ int read_only_lv(const struct logical_volume *lv, const struct lv_activate_opts
 	if (lv_is_raid_image(lv) || lv_is_raid_metadata(lv))
 		return 0; /* Keep RAID SubLvs writable */
 
+	if (!layer) {
+		if (lv_is_thin_pool(lv))
+			return 1;
+	}
+
 	return (laopts->read_only || !(lv->status & LVM_WRITE));
 }
 
@@ -217,6 +222,10 @@ static int _get_segment_status_from_target_params(const char *target_name,
 		if (!dm_get_status_writecache(seg_status->mem, params, &(seg_status->writecache)))
 			return_0;
 		seg_status->type = SEG_STATUS_WRITECACHE;
+	} else if (segtype_is_integrity(segtype)) {
+		if (!dm_get_status_integrity(seg_status->mem, params, &(seg_status->integrity)))
+			return_0;
+		seg_status->type = SEG_STATUS_INTEGRITY;
 	} else
 		/*
 		 * TODO: Add support for other segment types too!
@@ -243,6 +252,7 @@ static uint32_t _seg_len(const struct lv_segment *seg)
 static int _info_run(const char *dlid, struct dm_info *dminfo,
 		     uint32_t *read_ahead,
 		     struct lv_seg_status *seg_status,
+		     const char *name_check,
 		     int with_open_count, int with_read_ahead,
 		     uint32_t major, uint32_t minor)
 {
@@ -253,6 +263,7 @@ static int _info_run(const char *dlid, struct dm_info *dminfo,
 	void *target = NULL;
 	uint64_t target_start, target_length, start, length;
 	char *target_name, *target_params;
+	const char *devname;
 
 	if (seg_status) {
 		dmtask = DM_DEVICE_STATUS;
@@ -266,7 +277,12 @@ static int _info_run(const char *dlid, struct dm_info *dminfo,
 				    with_open_count, with_flush, 0)))
 		return_0;
 
-	if (with_read_ahead && dminfo->exists) {
+	if (name_check && dminfo->exists &&
+	    (devname = dm_task_get_name(dmt)) &&
+	    (strcmp(name_check, devname) != 0))
+		dminfo->exists = 0;	/* mismatching name -> device does not exist */
+
+	if (with_read_ahead && read_ahead && dminfo->exists) {
 		if (!dm_task_get_read_ahead(dmt, read_ahead))
 			goto_out;
 	} else if (read_ahead)
@@ -287,6 +303,9 @@ static int _info_run(const char *dlid, struct dm_info *dminfo,
 		if (lv_is_vdo_pool(seg_status->seg->lv))
 			length = get_vdo_pool_virtual_size(seg_status->seg);
 
+		if (lv_is_integrity(seg_status->seg->lv))
+			length = seg_status->seg->integrity_data_sectors;
+
 		do {
 			target = dm_get_next_target(dmt, target, &target_start,
 						    &target_length, &target_name, &target_params);
@@ -378,7 +397,7 @@ static int _ignore_blocked_mirror_devices(struct device *dev,
 			if (!(tmp_dev = dev_create_file(buf, NULL, NULL, 0)))
 				goto_out;
 
-			tmp_dev->dev = MKDEV((dev_t)sm->logs[0].major, (dev_t)sm->logs[0].minor);
+			tmp_dev->dev = MKDEV(sm->logs[0].major, sm->logs[0].minor);
 			if (device_is_usable(tmp_dev, (struct dev_usable_check_params)
 					     { .check_empty = 1,
 					       .check_blocked = 1,
@@ -652,8 +671,14 @@ int device_is_usable(struct device *dev, struct dev_usable_check_params check)
 		}
 	}
 
+	if (check.check_lv && uuid && !strncmp(uuid, "LVM-", 4)) {
+		/* Skip LVs */
+		goto out;
+	}
+
 	if (check.check_reserved && uuid &&
 	    (!strncmp(uuid, CRYPT_TEMP, sizeof(CRYPT_TEMP) - 1) ||
+	     !strncmp(uuid, CRYPT_SUBDEV, sizeof(CRYPT_SUBDEV) - 1) ||
 	     !strncmp(uuid, STRATIS, sizeof(STRATIS) - 1))) {
 		/* Skip private crypto devices */
 		log_debug_activation("%s: Reserved uuid %s on %s device %s not usable.",
@@ -780,18 +805,19 @@ static int _original_uuid_format_check_required(struct cmd_context *cmd)
 
 static int _info(struct cmd_context *cmd,
 		 const char *name, const char *dlid,
-		 int with_open_count, int with_read_ahead,
+		 int with_open_count, int with_read_ahead, int with_name_check,
 		 struct dm_info *dminfo, uint32_t *read_ahead,
 		 struct lv_seg_status *seg_status)
 {
 	char old_style_dlid[sizeof(UUID_PREFIX) + 2 * ID_LEN];
 	const char *suffix, *suffix_position;
+	const char *name_check = (with_name_check) ? name : NULL;
 	unsigned i = 0;
 
 	log_debug_activation("Getting device info for %s [%s].", name, dlid);
 
 	/* Check for dlid */
-	if (!_info_run(dlid, dminfo, read_ahead, seg_status,
+	if (!_info_run(dlid, dminfo, read_ahead, seg_status, name_check,
 		       with_open_count, with_read_ahead, 0, 0))
 		return_0;
 
@@ -807,7 +833,8 @@ static int _info(struct cmd_context *cmd,
 			(void) strncpy(old_style_dlid, dlid, sizeof(old_style_dlid));
 			old_style_dlid[sizeof(old_style_dlid) - 1] = '\0';
 			if (!_info_run(old_style_dlid, dminfo, read_ahead, seg_status,
-				       with_open_count, with_read_ahead, 0, 0))
+				       name_check, with_open_count, with_read_ahead,
+				       0, 0))
 				return_0;
 			if (dminfo->exists)
 				return 1;
@@ -820,20 +847,59 @@ static int _info(struct cmd_context *cmd,
 
 	/* Check for dlid before UUID_PREFIX was added */
 	if (!_info_run(dlid + sizeof(UUID_PREFIX) - 1, dminfo, read_ahead, seg_status,
-		       with_open_count, with_read_ahead, 0, 0))
+		       name_check, with_open_count, with_read_ahead, 0, 0))
 		return_0;
 
 	return 1;
 }
 
+int dev_manager_remove_dm_major_minor(uint32_t major, uint32_t minor)
+{
+	struct dm_task *dmt;
+	int r = 0;
+
+	log_verbose("Removing dm dev %u:%u", major, minor);
+
+	if (!(dmt = dm_task_create(DM_DEVICE_REMOVE)))
+		return_0;
+
+	if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
+		log_error("Failed to set device number for remove %u:%u", major, minor);
+		goto out;
+	}
+
+	r = dm_task_run(dmt);
+out:
+	dm_task_destroy(dmt);
+
+	return r;
+}
+
 static int _info_by_dev(uint32_t major, uint32_t minor, struct dm_info *info)
 {
-	return _info_run(NULL, info, NULL, 0, 0, 0, major, minor);
+	return _info_run(NULL, info, NULL, NULL, NULL, 0, 0, major, minor);
+}
+
+int dev_manager_check_prefix_dm_major_minor(uint32_t major, uint32_t minor, const char *prefix)
+{
+	struct dm_task *dmt;
+	const char *uuid;
+	int r = 1;
+
+	if (!(dmt = _setup_task_run(DM_DEVICE_INFO, NULL, NULL, NULL, 0, major, minor, 0, 0, 0)))
+		return_0;
+
+	if (!(uuid = dm_task_get_uuid(dmt)) || strncasecmp(uuid, prefix, strlen(prefix)))
+		r = 0;
+
+	dm_task_destroy(dmt);
+
+	return r;
 }
 
 int dev_manager_info(struct cmd_context *cmd,
 		     const struct logical_volume *lv, const char *layer,
-		     int with_open_count, int with_read_ahead,
+		     int with_open_count, int with_read_ahead, int with_name_check,
 		     struct dm_info *dminfo, uint32_t *read_ahead,
 		     struct lv_seg_status *seg_status)
 {
@@ -846,7 +912,8 @@ int dev_manager_info(struct cmd_context *cmd,
 	if (!(dlid = build_dm_uuid(cmd->mem, lv, layer)))
 		goto_out;
 
-	if (!(r = _info(cmd, name, dlid, with_open_count, with_read_ahead,
+	if (!(r = _info(cmd, name, dlid,
+			with_open_count, with_read_ahead, with_name_check,
 			dminfo, read_ahead, seg_status)))
 		stack;
 out:
@@ -1258,8 +1325,6 @@ struct dev_manager *dev_manager_create(struct cmd_context *cmd,
 
 	dm_udev_set_sync_support(cmd->current_settings.udev_sync);
 
-	dm_list_init(&dm->pending_delete);
-
 	return dm;
 
       bad:
@@ -1449,6 +1514,40 @@ out:
 	return r;
 }
 
+int dev_manager_writecache_message(struct dev_manager *dm,
+				   const struct logical_volume *lv,
+				   const char *msg)
+{
+	int r = 0;
+	const char *dlid;
+	struct dm_task *dmt;
+	const char *layer = lv_layer(lv);
+
+	if (!lv_is_writecache(lv)) {
+		log_error(INTERNAL_ERROR "%s is not a writecache logical volume.",
+			  display_lvname(lv));
+		return 0;
+	}
+
+	if (!(dlid = build_dm_uuid(dm->mem, lv, layer)))
+		return_0;
+
+	if (!(dmt = _setup_task_run(DM_DEVICE_TARGET_MSG, NULL, NULL, dlid, 0, 0, 0, 0, 1, 0)))
+		return_0;
+
+	if (!dm_task_set_message(dmt, msg))
+		goto_out;
+
+	if (!dm_task_run(dmt))
+		goto_out;
+
+	r = 1;
+out:
+	dm_task_destroy(dmt);
+
+	return r;
+}
+
 int dev_manager_cache_status(struct dev_manager *dm,
 			     const struct logical_volume *lv,
 			     struct lv_status_cache **status)
@@ -1597,6 +1696,9 @@ int dev_manager_thin_percent(struct dev_manager *dm,
 	return 1;
 }
 
+/*
+ * Explore state of running DM table to obtain currently used deviceId
+ */
 int dev_manager_thin_device_id(struct dev_manager *dm,
 			       const struct logical_volume *lv,
 			       uint32_t *device_id)
@@ -1606,10 +1708,16 @@ int dev_manager_thin_device_id(struct dev_manager *dm,
 	struct dm_info info;
 	uint64_t start, length;
 	char *params, *target_type = NULL;
+	const char *layer = lv_layer(lv);
 	int r = 0;
 
+	if (lv_is_merging_origin(lv) && !lv_info(lv->vg->cmd, lv, 1, NULL, 0, 0))
+		/* If the merge has already happened, that table
+		 * can already be using correct LV without -real layer */
+		layer = NULL;
+
 	/* Build dlid for the thin layer */
-	if (!(dlid = build_dm_uuid(dm->mem, lv, lv_layer(lv))))
+	if (!(dlid = build_dm_uuid(dm->mem, lv, layer)))
 		return_0;
 
 	if (!(dmt = _setup_task_run(DM_DEVICE_TABLE, &info, NULL, dlid, 0, 0, 0, 0, 1, 0)))
@@ -1646,9 +1754,8 @@ out:
 
 int dev_manager_vdo_pool_status(struct dev_manager *dm,
 				const struct logical_volume *lv,
-				int flush,
-				char **vdo_params,
-				struct lv_status_vdo **vdo_status)
+				struct lv_status_vdo **vdo_status,
+				int flush)
 {
 	struct lv_status_vdo *status;
 	const char *dlid;
@@ -1659,7 +1766,6 @@ int dev_manager_vdo_pool_status(struct dev_manager *dm,
 	char *params = NULL;
 	int r = 0;
 
-	*vdo_params = NULL;
 	*vdo_status = NULL;
 
 	if (!(status = dm_pool_zalloc(dm->mem, sizeof(struct lv_status_vdo)))) {
@@ -1688,13 +1794,11 @@ int dev_manager_vdo_pool_status(struct dev_manager *dm,
 		goto out;
 	}
 
-	if (!(*vdo_params = dm_pool_strdup(dm->mem, params))) {
-		log_error("Cannot duplicate VDO status params.");
-		goto out;
-	}
+	if (!parse_vdo_pool_status(dm->mem, lv, params, status))
+		goto_out;
 
 	status->mem = dm->mem;
-	*vdo_status =  status;
+	*vdo_status = status;
 
 	r = 1;
 out:
@@ -1828,7 +1932,7 @@ static uint16_t _get_udev_flags(struct dev_manager *dm, const struct logical_vol
 		/* New thin-pool is regular LV with -tpool UUID suffix. */
 		udev_flags |= DM_UDEV_DISABLE_DISK_RULES_FLAG |
 		              DM_UDEV_DISABLE_OTHER_RULES_FLAG;
-	else if (layer || !lv_is_visible(lv) || lv_is_thin_pool(lv))
+	else if (layer || !lv_is_visible(lv) || lv_is_thin_pool(lv) || lv_is_vdo_pool(lv))
 		udev_flags |= DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG |
 			      DM_UDEV_DISABLE_DISK_RULES_FLAG |
 			      DM_UDEV_DISABLE_OTHER_RULES_FLAG;
@@ -1875,10 +1979,20 @@ static uint16_t _get_udev_flags(struct dev_manager *dm, const struct logical_vol
 
 static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 			    const struct logical_volume *lv, int origin_only);
-
+static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
+				const struct logical_volume *lv,
+				struct lv_activate_opts *laopts,
+				const char *layer);
+/*
+ * Check for device holders (ATM used only for removed pvmove targets)
+ * and add them into dtree structures.
+ * When 'laopts != NULL' add them as new nodes - which also corrects READ_AHEAD.
+ * Note: correct table are already explicitelly PRELOADED.
+ */
 static int _check_holder(struct dev_manager *dm, struct dm_tree *dtree,
-			 const struct logical_volume *lv, uint32_t major,
-			 const char *d_name)
+			 const struct logical_volume *lv,
+			 struct lv_activate_opts *laopts,
+			 uint32_t major, const char *d_name)
 {
 	const char *default_uuid_prefix = dm_uuid_prefix();
 	const size_t default_uuid_prefix_len = strlen(default_uuid_prefix);
@@ -1915,7 +2029,8 @@ static int _check_holder(struct dev_manager *dm, struct dm_tree *dtree,
 
 		if (!strncmp(uuid, (char*)&lv->vg->id, sizeof(lv->vg->id)) &&
 		    !dm_tree_find_node_by_uuid(dtree, uuid)) {
-			dm_strncpy((char*)&id, uuid, 2 * sizeof(struct id) + 1);
+			/* trims any UUID suffix (i.e. -cow) */
+			(void) dm_strncpy((char*)&id, uuid, 2 * sizeof(struct id) + 1);
 
 			/* If UUID is not yet in dtree, look for matching LV */
 			if (!(lv_det = find_lv_in_vg_by_lvid(lv->vg, &id))) {
@@ -1929,8 +2044,11 @@ static int _check_holder(struct dev_manager *dm, struct dm_tree *dtree,
 			log_debug_activation("Found holder %s of %s.",
 					     display_lvname(lv_det),
 					     display_lvname(lv));
-			if (!_add_lv_to_dtree(dm, dtree, lv_det, 0))
-				goto_out;
+			if (!laopts) {
+				if (!_add_lv_to_dtree(dm, dtree, lv_det, 0))
+					goto_out;
+			} else if (!_add_new_lv_to_dtree(dm, dtree, lv_det, laopts, 0))
+					goto_out;
 		}
 	}
 
@@ -1947,7 +2065,9 @@ out:
  * i.e. PVMOVE is being finished and final table is going to be resumed.
  */
 static int _add_holders_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
-				 const struct logical_volume *lv, struct dm_info *info)
+				 const struct logical_volume *lv,
+				 struct lv_activate_opts *laopts,
+				 const struct dm_info *info)
 {
 	const char *sysfs_dir = dm_sysfs_dir();
 	char sysfs_path[PATH_MAX];
@@ -1970,7 +2090,7 @@ static int _add_holders_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	while ((dirent = readdir(d)))
 		/* Expects minor is added to 'dm-' prefix */
 		if (!strncmp(dirent->d_name, "dm-", 3) &&
-		    !_check_holder(dm, dtree, lv, info->major, dirent->d_name))
+		    !_check_holder(dm, dtree, lv, laopts, info->major, dirent->d_name))
 			goto_out;
 
 	r = 1;
@@ -1990,10 +2110,10 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	if (!(name = dm_build_dm_name(dm->mem, lv->vg->name, lv->name, layer)))
 		return_0;
 
-	if (!(dlid = build_dm_uuid(dm->mem, lv, layer)))
+	if (!(dlid = build_dm_uuid(dm->track_pending_delete ? dm->cmd->pending_delete_mem : dm->mem, lv, layer)))
 		return_0;
 
-	if (!_info(dm->cmd, name, dlid, 1, 0, &info, NULL, NULL))
+	if (!_info(dm->cmd, name, dlid, 1, 0, 0, &info, NULL, NULL))
 		return_0;
 
 	/*
@@ -2032,7 +2152,7 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	if (info.exists && dm->track_pending_delete) {
 		log_debug_activation("Tracking pending delete for %s (%s).",
 				     display_lvname(lv), dlid);
-		if (!str_list_add(dm->mem, &dm->pending_delete, dlid))
+		if (!str_list_add(dm->cmd->pending_delete_mem, &dm->cmd->pending_delete, dlid))
 			return_0;
 	}
 
@@ -2042,7 +2162,7 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	 */
 	if (info.exists && !lv_is_pvmove(lv) &&
 	    !strchr(lv->name, '_') && !strncmp(lv->name, "pvmove", 6))
-		if (!_add_holders_to_dtree(dm, dtree, lv, &info))
+		if (!_add_holders_to_dtree(dm, dtree, lv, NULL, &info))
 			return_0;
 
 	return 1;
@@ -2231,6 +2351,10 @@ static int _pool_register_callback(struct dev_manager *dm,
 		return 1;
 #endif
 
+	/* Skip for single-device cache pool */
+	if (lv_is_cache(lv) && lv_is_cache_vol(first_seg(lv)->pool_lv))
+		return 1;
+
 	if (!(data = dm_pool_zalloc(dm->mem, sizeof(*data)))) {
 		log_error("Failed to allocated path for callback.");
 		return 0;
@@ -2264,6 +2388,51 @@ static int _pool_register_callback(struct dev_manager *dm,
 	return 1;
 }
 
+/* Add special devices _cmeta & _cdata on top of CacheVol to dm tree */
+static int _add_cvol_subdev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
+				     const struct logical_volume *lv, int meta_or_data)
+{
+	const char *layer = meta_or_data ? "cmeta" : "cdata";
+	struct dm_pool *mem = dm->track_pending_delete ? dm->cmd->pending_delete_mem : dm->mem;
+	const struct logical_volume *pool_lv = first_seg(lv)->pool_lv;
+	struct lv_segment *lvseg = first_seg(lv);
+	struct dm_info info;
+	char *name ,*dlid;
+	union lvid lvid = { { { "" } } };
+
+	memcpy(&lvid.id[0], &lv->vg->id, sizeof(struct id));
+	/* When ID is provided in form of metadata_id or data_id, otherwise use CVOL ID */
+	memcpy(&lvid.id[1],
+	       (meta_or_data && lvseg->metadata_id) ? lvseg->metadata_id :
+	       (lvseg->data_id) ? lvseg->data_id : &pool_lv->lvid.id[1], sizeof(struct id));
+
+	if (!(dlid = dm_build_dm_uuid(mem, UUID_PREFIX, (const char *)&lvid.s, layer)))
+		return_0;
+
+	/* Name is actually not really needed here, but aids debugging... */
+	if (!(name = dm_build_dm_name(dm->mem, lv->vg->name, pool_lv->name, layer)))
+		return_0;
+
+	if (!_info(dm->cmd, name, dlid, 1, 0, 0, &info, NULL, NULL))
+		return_0;
+
+	if (info.exists) {
+		if (!dm_tree_add_dev_with_udev_flags(dtree, info.major, info.minor,
+						     _get_udev_flags(dm, lv, layer, 0, 0, 0))) {
+			log_error("Failed to add device (%" PRIu32 ":%" PRIu32") to dtree.", info.major, info.minor);
+			return 0;
+		}
+		if (dm->track_pending_delete) {
+			log_debug_activation("Tracking pending delete for %s %s (%s).",
+					     layer, display_lvname(lv), dlid);
+			if (!str_list_add(mem, &dm->cmd->pending_delete, dlid))
+				return_0;
+		}
+	}
+
+	return 1;
+}
+
 /* Declaration to resolve suspend tree and message passing for thin-pool */
 static int _add_target_to_dtree(struct dev_manager *dm,
 				struct dm_tree_node *dnode,
@@ -2298,6 +2467,13 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		/* Unused cache pool is activated as metadata */
 	}
 
+	if (lv_is_cache(lv) && (plv = (first_seg(lv)->pool_lv)) && lv_is_cache_vol(plv)) {
+		if (!_add_cvol_subdev_to_dtree(dm, dtree, lv, 0) ||
+		    !_add_cvol_subdev_to_dtree(dm, dtree, lv, 1) ||
+		    !_add_dev_to_dtree(dm, dtree, plv, lv_layer(plv)))
+			return_0;
+	}
+
 	if (!origin_only && !_add_dev_to_dtree(dm, dtree, lv, NULL))
 		return_0;
 
@@ -2381,6 +2557,15 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		}
 	}
 
+	if (lv_is_vdo_pool(lv)) {
+		/*
+		 * For both origin_only and !origin_only
+		 * skips test for -vpool-real and vpool-cow
+		 */
+		if (!_add_dev_to_dtree(dm, dtree, lv, lv_layer(lv)))
+			return_0;
+	}
+
 	if (lv_is_cache(lv)) {
 		if (!origin_only && !dm->activation && !dm->track_pending_delete) {
 			/* Setup callback for non-activation partial tree */
@@ -2438,8 +2623,16 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		if (seg->metadata_lv &&
 		    !_add_lv_to_dtree(dm, dtree, seg->metadata_lv, 0))
 			return_0;
+		if (seg->writecache && seg_is_writecache(seg)) {
+			if (!_add_lv_to_dtree(dm, dtree, seg->writecache, dm->activation ? origin_only : 1))
+				return_0;
+		}
+		if (seg->integrity_meta_dev && seg_is_integrity(seg)) {
+			if (!_add_lv_to_dtree(dm, dtree, seg->integrity_meta_dev, dm->activation ? origin_only : 1))
+				return_0;
+		}
 		if (seg->pool_lv &&
-		    (lv_is_cache_pool(seg->pool_lv) || dm->track_external_lv_deps) &&
+		    (lv_is_cache_pool(seg->pool_lv) || lv_is_cache_vol(seg->pool_lv) || dm->track_external_lv_deps) &&
 		    /* When activating and not origin_only detect linear 'overlay' over pool */
 		    !_add_lv_to_dtree(dm, dtree, seg->pool_lv, dm->activation ? origin_only : 1))
 			return_0;
@@ -2448,7 +2641,8 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 			if (seg_type(seg, s) == AREA_LV && seg_lv(seg, s) &&
 			    /* origin only for cache without pending delete */
 			    (!dm->track_pending_delete || !lv_is_cache(lv)) &&
-			    !_add_lv_to_dtree(dm, dtree, seg_lv(seg, s), 0))
+			    !_add_lv_to_dtree(dm, dtree, seg_lv(seg, s),
+					      lv_is_vdo_pool(seg_lv(seg, s)) ? 1 : 0))
 				return_0;
 			if (seg_is_raid_with_meta(seg) && seg->meta_areas && seg_metalv(seg, s) &&
 			    !_add_lv_to_dtree(dm, dtree, seg_metalv(seg, s), 0))
@@ -2519,7 +2713,7 @@ static char *_add_error_or_zero_device(struct dev_manager *dm, struct dm_tree *d
 				      seg->lv->name, errid)))
 		return_NULL;
 
-	if (!_info(dm->cmd, name, dlid, 1, 0, &info, NULL, NULL))
+	if (!_info(dm->cmd, name, dlid, 1, 0, 0, &info, NULL, NULL))
 		return_NULL;
 
 	if (!info.exists) {
@@ -2674,8 +2868,11 @@ static int _add_layer_target_to_dtree(struct dev_manager *dm,
 	if (!(layer_dlid = build_dm_uuid(dm->mem, lv, lv_layer(lv))))
 		return_0;
 
+
 	/* Add linear mapping over layered LV */
-	if (!add_linear_area_to_dtree(dnode, lv->size, lv->vg->extent_size,
+	/* From VDO layer expose ONLY vdo pool header, we would need to use virtual size otherwise */
+	if (!add_linear_area_to_dtree(dnode, lv_is_vdo_pool(lv) ? first_seg(lv)->vdo_pool_header_size : lv->size,
+				      lv->vg->extent_size,
 				      lv->vg->cmd->use_linear_target,
 				      lv->vg->name, lv->name) ||
 	    !dm_tree_node_add_target_area(dnode, NULL, layer_dlid, 0))
@@ -2785,11 +2982,6 @@ static int _add_target_to_dtree(struct dev_manager *dm,
 						  &dm->pvmove_mirror_count);
 }
 
-static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
-				const struct logical_volume *lv,
-				struct lv_activate_opts *laopts,
-				const char *layer);
-
 static int _add_new_external_lv_to_dtree(struct dev_manager *dm,
 					 struct dm_tree *dtree,
 					 struct logical_volume *external_lv,
@@ -2884,16 +3076,22 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 	    !_add_new_lv_to_dtree(dm, dtree, seg->metadata_lv, laopts, NULL))
 		return_0;
 
-	if (seg->cachevol &&
-	    !_add_new_lv_to_dtree(dm, dtree, seg->cachevol, laopts, NULL))
-			return_0;
-
 	/* Add pool layer */
 	if (seg->pool_lv && !laopts->origin_only &&
 	    !_add_new_lv_to_dtree(dm, dtree, seg->pool_lv, laopts,
 				  lv_layer(seg->pool_lv)))
 		return_0;
 
+	if (seg->writecache && !laopts->origin_only &&
+	    !_add_new_lv_to_dtree(dm, dtree, seg->writecache, laopts,
+				  lv_layer(seg->writecache)))
+		return_0;
+
+	if (seg->integrity_meta_dev && !laopts->origin_only &&
+	    !_add_new_lv_to_dtree(dm, dtree, seg->integrity_meta_dev, laopts,
+				  lv_layer(seg->integrity_meta_dev)))
+		return_0;
+
 	/* Add any LVs used by this segment */
 	for (s = 0; s < seg->area_count; ++s) {
 		if ((seg_type(seg, s) == AREA_LV) &&
@@ -2902,7 +3100,9 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 		    /* origin only for cache without pending delete */
 		    (!dm->track_pending_delete || !seg_is_cache(seg)) &&
 		    !_add_new_lv_to_dtree(dm, dtree, seg_lv(seg, s),
-					  laopts, NULL))
+					  laopts,
+					  lv_is_vdo_pool(seg_lv(seg, s)) ?
+					  lv_layer(seg_lv(seg, s)) : NULL))
 			return_0;
 		if (seg_is_raid_with_meta(seg) && seg->meta_areas && seg_metalv(seg, s) &&
 		    !lv_is_raid_image_with_tracking(seg_lv(seg, s)) &&
@@ -2940,6 +3140,14 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	int save_pending_delete = dm->track_pending_delete;
 	int merge_in_progress = 0;
 
+	if (!(lvlayer = dm_pool_alloc(dm->mem, sizeof(*lvlayer)))) {
+		log_error("_add_new_lv_to_dtree: pool alloc failed for %s %s.",
+			  display_lvname(lv), layer);
+		return 0;
+	}
+	lvlayer->lv = lv;
+	lvlayer->visible_component = (laopts->component_lv == lv) ? 1 : 0;
+
 	log_debug_activation("Adding new LV %s%s%s to dtree", display_lvname(lv),
 			     layer ? "-" : "", layer ? : "");
 	/* LV with pending delete is never put new into a table */
@@ -2956,6 +3164,114 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		return 1;
 	}
 
+	if (lv_is_cache(lv) && lv_is_cache_vol(first_seg(lv)->pool_lv)) {
+		struct logical_volume *pool_lv = first_seg(lv)->pool_lv;
+		struct lv_segment *lvseg = first_seg(lv);
+		struct volume_group *vg = lv->vg;
+		struct dm_tree_node *dnode_meta;
+		struct dm_tree_node *dnode_data;
+		union lvid lvid_meta;
+		union lvid lvid_data;
+		char *name_meta;
+		char *name_data;
+		char *dlid_meta;
+		char *dlid_data;
+		char *dlid_pool;
+		uint64_t meta_len = first_seg(lv)->metadata_len;
+		uint64_t data_len = first_seg(lv)->data_len;
+		uint16_t udev_flags = _get_udev_flags(dm, lv, layer,
+					     laopts->noscan, laopts->temporary,
+					     0);
+
+		if (lv_is_pending_delete(lvseg->lv))
+			dm->track_pending_delete = 1;
+
+		log_debug("Add cachevol %s to dtree before cache %s.", pool_lv->name, lv->name);
+
+		if (!_add_new_lv_to_dtree(dm, dtree, pool_lv, laopts, lv_layer(pool_lv))) {
+			log_error("Failed to add cachevol to dtree before cache.");
+			return 0;
+		}
+
+		memset(&lvid_meta, 0, sizeof(lvid_meta));
+		memset(&lvid_data, 0, sizeof(lvid_meta));
+		memcpy(&lvid_meta.id[0], &vg->id, sizeof(struct id));
+		memcpy(&lvid_meta.id[1], lvseg->metadata_id ? : &pool_lv->lvid.id[1], sizeof(struct id));
+		memcpy(&lvid_data.id[0], &vg->id, sizeof(struct id));
+		memcpy(&lvid_data.id[1], lvseg->data_id ? : &pool_lv->lvid.id[1], sizeof(struct id));
+
+		if (!(dlid_meta = dm_build_dm_uuid(dm->mem, UUID_PREFIX, (const char *)&lvid_meta.s, "cmeta")))
+			return_0;
+		if (!(dlid_data = dm_build_dm_uuid(dm->mem, UUID_PREFIX, (const char *)&lvid_data.s, "cdata")))
+			return_0;
+
+		if (!(name_meta = dm_build_dm_name(dm->mem, vg->name, pool_lv->name, "cmeta")))
+			return_0;
+		if (!(name_data = dm_build_dm_name(dm->mem, vg->name, pool_lv->name, "cdata")))
+			return_0;
+
+		if (!(dlid_pool = build_dm_uuid(dm->mem, pool_lv, NULL)))
+			return_0;
+
+		/* add meta dnode */
+		if (!(dnode_meta = dm_tree_add_new_dev_with_udev_flags(dtree,
+								  name_meta,
+								  dlid_meta,
+								  -1, -1,
+								  read_only_lv(lv, laopts, layer),
+								  ((lv->vg->status & PRECOMMITTED) | laopts->revert) ? 1 : 0,
+								  lvlayer,
+								  udev_flags)))
+			return_0;
+
+		if (dm->track_pending_delete) {
+			log_debug_activation("Using error for pending meta delete %s.", display_lvname(lv));
+			if (!dm_tree_node_add_error_target(dnode_meta, (uint64_t)lv->vg->extent_size * meta_len))
+				return_0;
+		} else {
+			/* add load_segment to meta dnode: linear, size of meta area */
+			if (!add_linear_area_to_dtree(dnode_meta,
+						      meta_len,
+						      lv->vg->extent_size,
+						      lv->vg->cmd->use_linear_target,
+						      lv->vg->name, lv->name))
+				return_0;
+
+			/* add seg_area to prev load_seg: offset 0 maps to cachepool lv offset 0 */
+			if (!dm_tree_node_add_target_area(dnode_meta, NULL, dlid_pool, 0))
+				return_0;
+		}
+
+		/* add data dnode */
+		if (!(dnode_data = dm_tree_add_new_dev_with_udev_flags(dtree,
+								  name_data,
+								  dlid_data,
+								  -1, -1,
+								  read_only_lv(lv, laopts, layer),
+								  ((lv->vg->status & PRECOMMITTED) | laopts->revert) ? 1 : 0,
+								  lvlayer,
+								  udev_flags)))
+			return_0;
+
+		if (dm->track_pending_delete) {
+			log_debug_activation("Using error for pending data delete %s.", display_lvname(lv));
+			if (!dm_tree_node_add_error_target(dnode_data, (uint64_t)lv->vg->extent_size * data_len))
+				return_0;
+		} else {
+			/* add load_segment to data dnode: linear, size of data area */
+			if (!add_linear_area_to_dtree(dnode_data,
+						      data_len,
+						      lv->vg->extent_size,
+						      lv->vg->cmd->use_linear_target,
+						      lv->vg->name, lv->name))
+				return_0;
+
+			/* add seg_area to prev load_seg: offset 0 maps to cachepool lv after meta */
+			if (!dm_tree_node_add_target_area(dnode_data, NULL, dlid_pool, meta_len))
+				return_0;
+		}
+	}
+
 	/* FIXME Seek a simpler way to lay out the snapshot-merge tree. */
 
 	if (!layer && lv_is_merging_origin(lv)) {
@@ -3024,12 +3340,6 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	    dm_tree_node_get_context(dnode))
 		return 1;
 
-	if (!(lvlayer = dm_pool_alloc(dm->mem, sizeof(*lvlayer)))) {
-		log_error("_add_new_lv_to_dtree: pool alloc failed for %s %s.",
-			  display_lvname(lv), layer);
-		return 0;
-	}
-
 	lvlayer->lv = lv;
 	lvlayer->visible_component = (laopts->component_lv == lv) ? 1 : 0;
 
@@ -3099,8 +3409,9 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		if (!_add_snapshot_target_to_dtree(dm, dnode, lv, laopts))
 			return_0;
 	} else if (!layer && ((lv_is_thin_pool(lv) && !lv_is_new_thin_pool(lv)) ||
+                              lv_is_vdo_pool(lv) ||
 			      lv_is_external_origin(lv))) {
-		/* External origin or 'used' Thin pool is using layer */
+		/* External origin or 'used' Thin pool or VDO pool is using layer */
 		if (!_add_new_lv_to_dtree(dm, dtree, lv, laopts, lv_layer(lv)))
 			return_0;
 		if (!_add_layer_target_to_dtree(dm, dnode, lv))
@@ -3113,6 +3424,10 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 			if (max_stripe_size < seg->stripe_size * seg->area_count)
 				max_stripe_size = seg->stripe_size * seg->area_count;
 		}
+
+		if (!layer && lv_is_vdo_pool(lv) &&
+		    !_add_layer_target_to_dtree(dm, dnode, lv))
+			return_0;
 	}
 
 	/* Setup thin pool callback */
@@ -3120,7 +3435,7 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	    !_pool_register_callback(dm, dnode, lv))
 		return_0;
 
-	if (lv_is_cache(lv) &&
+	if (lv_is_cache(lv) && !lv_is_cache_vol(first_seg(lv)->pool_lv) &&
 	    /* Register callback only for layer activation or non-layered cache LV */
 	    (layer || !lv_layer(lv)) &&
 	    /* Register callback when metadata LV is NOT already active */
@@ -3128,6 +3443,17 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	    !_pool_register_callback(dm, dnode, lv))
 		return_0;
 
+	/*
+	 * Update tables for ANY PVMOVE holders for active LV where the name starts with 'pvmove',
+	 * but it's not anymore PVMOVE LV and also it's not a PVMOVE _mimage LV.
+	 * When resume happens, tables MUST be already preloaded with correct entries!
+	 * (since we can't preload different table while devices are suspended)
+	 */
+	if (!lv_is_pvmove(lv) && !strncmp(lv->name, "pvmove", 6) && !strchr(lv->name, '_') &&
+	    (dinfo = _cached_dm_info(dm->mem, dtree, lv, NULL)))
+		if (!_add_holders_to_dtree(dm, dtree, lv, laopts, dinfo))
+			return_0;
+
 	if (read_ahead == DM_READ_AHEAD_AUTO) {
 		/* we need RA at least twice a whole stripe - see the comment in md/raid0.c */
 		read_ahead = max_stripe_size * 2;
@@ -3247,13 +3573,6 @@ static int _clean_tree(struct dev_manager *dm, struct dm_tree_node *root, const
 	const char *name, *uuid;
 	struct dm_str_list *dl;
 
-	/* Deactivate any tracked pending delete nodes */
-	dm_list_iterate_items(dl, &dm->pending_delete) {
-		log_debug_activation("Deleting tracked UUID %s.", dl->str);
-		if (!dm_tree_deactivate_children(root, dl->str, strlen(dl->str)))
-			return_0;
-	}
-
 	while ((child = dm_tree_next_child(&handle, root, 0))) {
 		if (!(name = dm_tree_node_get_name(child)))
 			continue;
@@ -3274,10 +3593,28 @@ static int _clean_tree(struct dev_manager *dm, struct dm_tree_node *root, const
 		if (non_toplevel_tree_dlid && !strcmp(non_toplevel_tree_dlid, uuid))
 			continue;
 
-		if (!dm_tree_deactivate_children(root, uuid, strlen(uuid)))
+		if (!(uuid = dm_pool_strdup(dm->cmd->pending_delete_mem, uuid))) {
+			log_error("_clean_tree: Failed to duplicate uuid.");
+			return 0;
+		}
+
+		if (!str_list_add(dm->cmd->pending_delete_mem, &dm->cmd->pending_delete, uuid))
 			return_0;
 	}
 
+	/* Deactivate any tracked pending delete nodes */
+	if (!dm_list_empty(&dm->cmd->pending_delete) && !dm_get_suspended_counter()) {
+		fs_unlock();
+		dm_tree_set_cookie(root, fs_get_cookie());
+		dm_list_iterate_items(dl, &dm->cmd->pending_delete) {
+			log_debug_activation("Deleting tracked UUID %s.", dl->str);
+			if (!dm_tree_deactivate_children(root, dl->str, strlen(dl->str)))
+				return_0;
+		}
+		dm_list_init(&dm->cmd->pending_delete);
+		dm_pool_empty(dm->cmd->pending_delete_mem);
+	}
+
 	return 1;
 }
 
@@ -3358,7 +3695,10 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv,
 		/* Add all required new devices to tree */
 		if (!_add_new_lv_to_dtree(dm, dtree, lv, laopts,
 					  (lv_is_origin(lv) && laopts->origin_only) ? "real" :
-					  (lv_is_thin_pool(lv) && laopts->origin_only) ? "tpool" : NULL))
+					  (laopts->origin_only &&
+					   (lv_is_thin_pool(lv) ||
+					    lv_is_vdo_pool(lv))) ?
+					  lv_layer(lv) : NULL))
 			goto_out;
 
 		/* Preload any devices required before any suspensions */

lib/activate/dev_manager.h

@@ -47,7 +47,7 @@ void dev_manager_exit(void);
  */
 int dev_manager_info(struct cmd_context *cmd, const struct logical_volume *lv,
 		     const char *layer,
-		     int with_open_count, int with_read_ahead,
+		     int with_open_count, int with_read_ahead, int with_name_check,
 		     struct dm_info *dminfo, uint32_t *read_ahead,
 		     struct lv_seg_status *seg_status);
 
@@ -63,6 +63,9 @@ int dev_manager_raid_status(struct dev_manager *dm,
 int dev_manager_raid_message(struct dev_manager *dm,
 			     const struct logical_volume *lv,
 			     const char *msg);
+int dev_manager_writecache_message(struct dev_manager *dm,
+                                   const struct logical_volume *lv,
+                                   const char *msg);
 int dev_manager_cache_status(struct dev_manager *dm,
 			     const struct logical_volume *lv,
 			     struct lv_status_cache **status);
@@ -81,9 +84,8 @@ int dev_manager_thin_device_id(struct dev_manager *dm,
 			       uint32_t *device_id);
 int dev_manager_vdo_pool_status(struct dev_manager *dm,
 				const struct logical_volume *lv,
-				int flush,
-				char **vdo_params,
-				struct lv_status_vdo **vdo_status);
+				struct lv_status_vdo **vdo_status,
+				int flush);
 int dev_manager_suspend(struct dev_manager *dm, const struct logical_volume *lv,
 			struct lv_activate_opts *laopts, int lockfs, int flush_required);
 int dev_manager_activate(struct dev_manager *dm, const struct logical_volume *lv,
@@ -103,4 +105,8 @@ int dev_manager_execute(struct dev_manager *dm);
 int dev_manager_device_uses_vg(struct device *dev,
 			       struct volume_group *vg);
 
+int dev_manager_remove_dm_major_minor(uint32_t major, uint32_t minor);
+
+int dev_manager_check_prefix_dm_major_minor(uint32_t major, uint32_t minor, const char *prefix);
+
 #endif

lib/activate/fs.c

@@ -487,7 +487,8 @@ int fs_rename_lv(const struct logical_volume *lv, const char *dev,
 
 void fs_unlock(void)
 {
-	if (!prioritized_section()) {
+	/* Do not allow syncing device name with suspended devices */
+	if (!dm_get_suspended_counter()) {
 		log_debug_activation("Syncing device names");
 		/* Wait for all processed udev devices */
 		if (!dm_udev_wait(_fs_cookie))

lib/cache/lvmcache.h

@@ -41,14 +41,9 @@ struct lvmcache_vginfo;
 
 /*
  * vgsummary represents a summary of the VG that is read
- * without a lock.  The info does not come through vg_read(),
- * but through reading mdas.  It provides information about
- * the VG that is needed to lock the VG and then read it fully
- * with vg_read(), after which the VG summary should be checked
- * against the full VG metadata to verify it was correct (since
- * it was read without a lock.)
- *
- * Once read, vgsummary information is saved in lvmcache_vginfo.
+ * without a lock during label scan.  It's used to populate
+ * basic lvmcache vginfo/info during label scan prior to
+ * vg_read().
  */
 struct lvmcache_vgsummary {
 	const char *vgname;
@@ -57,10 +52,14 @@ struct lvmcache_vgsummary {
 	char *creation_host;
 	const char *system_id;
 	const char *lock_type;
+	uint32_t seqno;
 	uint32_t mda_checksum;
 	size_t mda_size;
-	int zero_offset;
-	int seqno;
+	int mda_num; /* 1 = summary from mda1, 2 = summary from mda2 */
+	unsigned mda_ignored:1;
+	unsigned zero_offset:1;
+	unsigned mismatch:1; /* lvmcache sets if this summary differs from previous values */
+	struct dm_list pvsummaries;
 };
 
 int lvmcache_init(struct cmd_context *cmd);
@@ -69,12 +68,13 @@ void lvmcache_destroy(struct cmd_context *cmd, int retain_orphans, int reset);
 
 int lvmcache_label_scan(struct cmd_context *cmd);
 int lvmcache_label_rescan_vg(struct cmd_context *cmd, const char *vgname, const char *vgid);
+int lvmcache_label_rescan_vg_rw(struct cmd_context *cmd, const char *vgname, const char *vgid);
 
 /* Add/delete a device */
 struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
-				   struct device *dev,
-				   const char *vgname, const char *vgid,
-				   uint32_t vgstatus);
+                                   struct device *dev, uint64_t label_sector,
+                                   const char *vgname, const char *vgid,
+                                   uint32_t vgstatus, int *is_duplicate);
 int lvmcache_add_orphan_vginfo(const char *vgname, struct format_type *fmt);
 void lvmcache_del(struct lvmcache_info *info);
 void lvmcache_del_dev(struct device *dev);
@@ -82,18 +82,15 @@ void lvmcache_del_dev(struct device *dev);
 /* Update things */
 int lvmcache_update_vgname_and_id(struct lvmcache_info *info,
 				  struct lvmcache_vgsummary *vgsummary);
-int lvmcache_update_vg(struct volume_group *vg, unsigned precommitted);
+int lvmcache_update_vg_from_read(struct volume_group *vg, unsigned precommitted);
+int lvmcache_update_vg_from_write(struct volume_group *vg);
 
 void lvmcache_lock_vgname(const char *vgname, int read_only);
 void lvmcache_unlock_vgname(const char *vgname);
 
 /* Queries */
-const struct format_type *lvmcache_fmt_from_vgname(struct cmd_context *cmd, const char *vgname, const char *vgid, unsigned revalidate_labels);
 int lvmcache_lookup_mda(struct lvmcache_vgsummary *vgsummary);
 
-/* Decrement and test if there are still vg holders in vginfo. */
-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);
@@ -103,14 +100,11 @@ const char *lvmcache_vgid_from_vgname(struct cmd_context *cmd, const char *vgnam
 struct device *lvmcache_device_from_pvid(struct cmd_context *cmd, const struct id *pvid, uint64_t *label_sector);
 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_get_vgnameids(struct cmd_context *cmd, int include_internal,
-                          struct dm_list *vgnameids);
-
-/* Returns list of struct dm_str_list containing pool-allocated copy of pvids */
-struct dm_list *lvmcache_get_pvids(struct cmd_context *cmd, const char *vgname,
-				const char *vgid);
+int lvmcache_get_vgnameids(struct cmd_context *cmd,
+                           struct dm_list *vgnameids,
+                           const char *only_this_vgname,
+                           int include_internal);
 
 void lvmcache_drop_metadata(const char *vgname, int drop_precommitted);
 void lvmcache_commit_metadata(const char *vgname);
@@ -127,7 +121,8 @@ void lvmcache_del_mdas(struct lvmcache_info *info);
 void lvmcache_del_das(struct lvmcache_info *info);
 void lvmcache_del_bas(struct lvmcache_info *info);
 int lvmcache_add_mda(struct lvmcache_info *info, struct device *dev,
-		     uint64_t start, uint64_t size, unsigned ignored);
+		     uint64_t start, uint64_t size, unsigned ignored,
+		     struct metadata_area **mda_new);
 int lvmcache_add_da(struct lvmcache_info *info, uint64_t start, uint64_t size);
 int lvmcache_add_ba(struct lvmcache_info *info, uint64_t start, uint64_t size);
 
@@ -163,19 +158,23 @@ int lvmcache_foreach_pv(struct lvmcache_vginfo *vginfo,
 uint64_t lvmcache_device_size(struct lvmcache_info *info);
 void lvmcache_set_device_size(struct lvmcache_info *info, uint64_t size);
 struct device *lvmcache_device(struct lvmcache_info *info);
-int lvmcache_is_orphan(struct lvmcache_info *info);
 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);
 
-int lvmcache_found_duplicate_pvs(void);
-
-void lvmcache_pvscan_duplicate_check(struct cmd_context *cmd);
-
-int lvmcache_get_unused_duplicate_devs(struct cmd_context *cmd, struct dm_list *head);
+struct metadata_area *lvmcache_get_mda(struct cmd_context *cmd,
+                                      const char *vgname,
+                                      struct device *dev,
+                                      int use_mda_num);
 
+bool lvmcache_has_duplicate_devs(void);
+void lvmcache_del_dev_from_duplicates(struct device *dev);
+bool lvmcache_dev_is_unused_duplicate(struct device *dev);
+int lvmcache_pvid_in_unused_duplicates(const char *pvid);
+int lvmcache_get_unused_duplicates(struct cmd_context *cmd, struct dm_list *head);
 int vg_has_duplicate_pvs(struct volume_group *vg);
 
+int lvmcache_found_duplicate_vgnames(void);
+
 int lvmcache_contains_lock_type_sanlock(struct cmd_context *cmd);
 
 void lvmcache_get_max_name_lengths(struct cmd_context *cmd,
@@ -183,34 +182,38 @@ void lvmcache_get_max_name_lengths(struct cmd_context *cmd,
 
 int lvmcache_vg_is_foreign(struct cmd_context *cmd, const char *vgname, const char *vgid);
 
-void lvmcache_lock_ordering(int enable);
+bool lvmcache_scan_mismatch(struct cmd_context *cmd, const char *vgname, const char *vgid);
 
-int lvmcache_dev_is_unchosen_duplicate(struct device *dev);
+int lvmcache_vginfo_has_pvid(struct lvmcache_vginfo *vginfo, char *pvid);
 
-void lvmcache_remove_unchosen_duplicate(struct device *dev);
-
-int lvmcache_pvid_in_unchosen_duplicates(const char *pvid);
-
-int lvmcache_get_vg_devs(struct cmd_context *cmd,
-			 struct lvmcache_vginfo *vginfo,
-			 struct dm_list *devs);
-void lvmcache_set_independent_location(const char *vgname);
-
-int lvmcache_scan_mismatch(struct cmd_context *cmd, const char *vgname, const char *vgid);
-
-/*
- * These are clvmd-specific functions and are not related to lvmcache.
- * FIXME: rename these with a clvm_ prefix in place of lvmcache_
- */
-void lvmcache_save_vg(struct volume_group *vg, int precommitted);
-struct volume_group *lvmcache_get_saved_vg(const char *vgid, int precommitted);
-struct volume_group *lvmcache_get_saved_vg_latest(const char *vgid);
-void lvmcache_drop_saved_vgid(const char *vgid);
+uint64_t lvmcache_max_metadata_size(void);
+void lvmcache_save_metadata_size(uint64_t val);
 
 int dev_in_device_list(struct device *dev, struct dm_list *head);
 
-struct cachedev *lvmcache_cachedev_from_pvid(const struct id *pvid);
-void lvmcache_update_vg_cachedevs(struct volume_group *vg);
-void lvmcache_del_cachedev(struct cachedev *cd);
+bool lvmcache_has_bad_metadata(struct device *dev);
+
+bool lvmcache_has_old_metadata(struct cmd_context *cmd, const char *vgname, const char *vgid, struct device *dev);
+
+void lvmcache_get_outdated_devs(struct cmd_context *cmd,
+                                const char *vgname, const char *vgid,
+                                struct dm_list *devs);
+void lvmcache_get_outdated_mdas(struct cmd_context *cmd,
+                                const char *vgname, const char *vgid,
+                                struct device *dev,
+                                struct dm_list **mdas);
+
+bool lvmcache_is_outdated_dev(struct cmd_context *cmd,
+                              const char *vgname, const char *vgid,
+                              struct device *dev);
+
+void lvmcache_del_outdated_devs(struct cmd_context *cmd,
+                                const char *vgname, const char *vgid);
+
+void lvmcache_save_bad_mda(struct lvmcache_info *info, struct metadata_area *mda);
+
+void lvmcache_get_bad_mdas(struct cmd_context *cmd,
+                           const char *vgname, const char *vgid,
+                           struct dm_list *bad_mda_list);
 
 #endif

lib/cache_segtype/cache.c

@@ -47,23 +47,33 @@ static int _cache_out_line(const char *line, void *_f)
 static void _cache_display(const struct lv_segment *seg)
 {
 	const struct dm_config_node *n;
-	const struct lv_segment *pool_seg =
-		seg_is_cache_pool(seg) ? seg : first_seg(seg->pool_lv);
+	const struct lv_segment *setting_seg = NULL;
+
+	if (seg_is_cache(seg) && lv_is_cache_vol(seg->pool_lv))
+		setting_seg = seg;
+
+	else if (seg_is_cache_pool(seg))
+		setting_seg = seg;
+
+	else if (seg_is_cache(seg))
+		setting_seg = first_seg(seg->pool_lv);
+	else
+		return;
 
 	log_print("  Chunk size\t\t%s",
-		  display_size(seg->lv->vg->cmd, pool_seg->chunk_size));
+		  display_size(seg->lv->vg->cmd, setting_seg->chunk_size));
 
-	if (pool_seg->cache_metadata_format != CACHE_METADATA_FORMAT_UNSELECTED)
-		log_print("  Metadata format\t%u", pool_seg->cache_metadata_format);
+	if (setting_seg->cache_metadata_format != CACHE_METADATA_FORMAT_UNSELECTED)
+		log_print("  Metadata format\t%u", setting_seg->cache_metadata_format);
 
-	if (pool_seg->cache_mode != CACHE_MODE_UNSELECTED)
-		log_print("  Mode\t\t%s", get_cache_mode_name(pool_seg));
+	if (setting_seg->cache_mode != CACHE_MODE_UNSELECTED)
+		log_print("  Mode\t\t%s", get_cache_mode_name(setting_seg));
 
-	if (pool_seg->policy_name)
-		log_print("  Policy\t\t%s", pool_seg->policy_name);
+	if (setting_seg->policy_name)
+		log_print("  Policy\t\t%s", setting_seg->policy_name);
 
-	if (pool_seg->policy_settings &&
-	    (n = pool_seg->policy_settings->child))
+	if (setting_seg->policy_settings &&
+	    (n = setting_seg->policy_settings->child))
 		dm_config_write_node(n, _cache_out_line, NULL);
 
 	log_print(" ");
@@ -99,32 +109,16 @@ static void _fix_missing_defaults(struct lv_segment *cpool_seg)
 	}
 }
 
-static int _cache_pool_text_import(struct lv_segment *seg,
-				   const struct dm_config_node *sn,
-				   struct dm_hash_table *pv_hash __attribute__((unused)))
+static int _settings_text_import(struct lv_segment *seg,
+				 const struct dm_config_node *sn)
 {
-	struct logical_volume *data_lv, *meta_lv;
 	const char *str = NULL;
 	struct dm_pool *mem = seg->lv->vg->vgmem;
 
-	if (!dm_config_has_node(sn, "data"))
-		return SEG_LOG_ERROR("Cache data not specified in");
-	if (!(str = dm_config_find_str(sn, "data", NULL)))
-		return SEG_LOG_ERROR("Cache data must be a string in");
-	if (!(data_lv = find_lv(seg->lv->vg, str)))
-		return SEG_LOG_ERROR("Unknown logical volume %s specified for "
-				     "cache data in", str);
-
-	if (!dm_config_has_node(sn, "metadata"))
-		return SEG_LOG_ERROR("Cache metadata not specified in");
-	if (!(str = dm_config_find_str(sn, "metadata", NULL)))
-		return SEG_LOG_ERROR("Cache metadata must be a string in");
-	if (!(meta_lv = find_lv(seg->lv->vg, str)))
-		return SEG_LOG_ERROR("Unknown logical volume %s specified for "
-				     "cache metadata in", str);
-
-	if (!dm_config_get_uint32(sn, "chunk_size", &seg->chunk_size))
-		return SEG_LOG_ERROR("Couldn't read cache chunk_size in");
+	if (dm_config_has_node(sn, "chunk_size")) {
+		if (!dm_config_get_uint32(sn, "chunk_size", &seg->chunk_size))
+			return SEG_LOG_ERROR("Couldn't read cache chunk_size in");
+	}
 
 	/*
 	 * Read in features:
@@ -146,16 +140,6 @@ static int _cache_pool_text_import(struct lv_segment *seg,
 			return SEG_LOG_ERROR("Failed to duplicate policy in");
 	}
 
-	if (dm_config_has_node(sn, "metadata_format")) {
-		if (!dm_config_get_uint32(sn, "metadata_format", &seg->cache_metadata_format) ||
-		    ((seg->cache_metadata_format != CACHE_METADATA_FORMAT_1) &&
-		     (seg->cache_metadata_format != CACHE_METADATA_FORMAT_2)))
-			return SEG_LOG_ERROR("Unknown cache metadata format %u number in",
-					     seg->cache_metadata_format);
-		if (seg->cache_metadata_format == CACHE_METADATA_FORMAT_2)
-			seg->lv->status |= LV_METADATA_FORMAT;
-	}
-
 	/*
 	 * Read in policy args:
 	 *   policy_settings {
@@ -184,6 +168,75 @@ static int _cache_pool_text_import(struct lv_segment *seg,
 			return_0;
 	}
 
+	return 1;
+}
+
+static int _settings_text_export(const struct lv_segment *seg,
+				 struct formatter *f)
+{
+	if (seg->chunk_size)
+		outf(f, "chunk_size = %" PRIu32, seg->chunk_size);
+
+	if (seg->cache_mode != CACHE_MODE_UNSELECTED) {
+		const char *cache_mode;
+		if (!(cache_mode = cache_mode_num_to_str(seg->cache_mode)))
+			return_0;
+		outf(f, "cache_mode = \"%s\"", cache_mode);
+	}
+
+	if (seg->policy_name) {
+		outf(f, "policy = \"%s\"", seg->policy_name);
+
+		if (seg->policy_settings) {
+			if (strcmp(seg->policy_settings->key, "policy_settings")) {
+				log_error(INTERNAL_ERROR "Incorrect policy_settings tree, %s.",
+					  seg->policy_settings->key);
+				return 0;
+			}
+			if (seg->policy_settings->child)
+				out_config_node(f, seg->policy_settings);
+		}
+	}
+
+	return 1;
+}
+
+static int _cache_pool_text_import(struct lv_segment *seg,
+				   const struct dm_config_node *sn,
+				   struct dm_hash_table *pv_hash __attribute__((unused)))
+{
+	struct logical_volume *data_lv, *meta_lv;
+	const char *str = NULL;
+
+	if (!dm_config_has_node(sn, "data"))
+		return SEG_LOG_ERROR("Cache data not specified in");
+	if (!(str = dm_config_find_str(sn, "data", NULL)))
+		return SEG_LOG_ERROR("Cache data must be a string in");
+	if (!(data_lv = find_lv(seg->lv->vg, str)))
+		return SEG_LOG_ERROR("Unknown logical volume %s specified for "
+				     "cache data in", str);
+
+	if (!dm_config_has_node(sn, "metadata"))
+		return SEG_LOG_ERROR("Cache metadata not specified in");
+	if (!(str = dm_config_find_str(sn, "metadata", NULL)))
+		return SEG_LOG_ERROR("Cache metadata must be a string in");
+	if (!(meta_lv = find_lv(seg->lv->vg, str)))
+		return SEG_LOG_ERROR("Unknown logical volume %s specified for "
+				     "cache metadata in", str);
+
+	if (dm_config_has_node(sn, "metadata_format")) {
+		if (!dm_config_get_uint32(sn, "metadata_format", &seg->cache_metadata_format) ||
+		    ((seg->cache_metadata_format != CACHE_METADATA_FORMAT_1) &&
+		     (seg->cache_metadata_format != CACHE_METADATA_FORMAT_2)))
+			return SEG_LOG_ERROR("Unknown cache metadata format %u number in",
+					     seg->cache_metadata_format);
+		if (seg->cache_metadata_format == CACHE_METADATA_FORMAT_2)
+			seg->lv->status |= LV_METADATA_FORMAT;
+	}
+
+	if (!_settings_text_import(seg, sn))
+		return_0;
+
 	if (!attach_pool_data_lv(seg, data_lv))
 		return_0;
 	if (!attach_pool_metadata_lv(seg, meta_lv))
@@ -207,11 +260,8 @@ static int _cache_pool_text_import_area_count(const struct dm_config_node *sn,
 static int _cache_pool_text_export(const struct lv_segment *seg,
 				   struct formatter *f)
 {
-	const char *cache_mode;
-
 	outf(f, "data = \"%s\"", seg_lv(seg, 0)->name);
 	outf(f, "metadata = \"%s\"", seg->metadata_lv->name);
-	outf(f, "chunk_size = %" PRIu32, seg->chunk_size);
 
 	switch (seg->cache_metadata_format) {
 	case CACHE_METADATA_FORMAT_UNSELECTED:
@@ -237,25 +287,9 @@ 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_UNSELECTED) {
-		if (!(cache_mode = get_cache_mode_name(seg)))
-			return_0;
-		outf(f, "cache_mode = \"%s\"", cache_mode);
-	}
 
-	if (seg->policy_name) {
-		outf(f, "policy = \"%s\"", seg->policy_name);
-
-		if (seg->policy_settings) {
-			if (strcmp(seg->policy_settings->key, "policy_settings")) {
-				log_error(INTERNAL_ERROR "Incorrect policy_settings tree, %s.",
-					  seg->policy_settings->key);
-				return 0;
-			}
-			if (seg->policy_settings->child)
-				out_config_node(f, seg->policy_settings);
-		}
-	}
+	if (!_settings_text_export(seg, f))
+		return_0;
 
 	return 1;
 }
@@ -443,6 +477,7 @@ static int _cache_text_import(struct lv_segment *seg,
 {
 	struct logical_volume *pool_lv, *origin_lv;
 	const char *name;
+	const char *uuid;
 
 	if (!dm_config_has_node(sn, "cache_pool"))
 		return SEG_LOG_ERROR("cache_pool not specified in");
@@ -469,12 +504,56 @@ static int _cache_text_import(struct lv_segment *seg,
 
 	seg->lv->status |= strstr(seg->lv->name, "_corig") ? LV_PENDING_DELETE : 0;
 
-	if (!attach_pool_lv(seg, pool_lv, NULL, NULL, NULL))
+	if (!_settings_text_import(seg, sn))
 		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_config_has_node(sn, "metadata_format")) {
+		if (!dm_config_get_uint32(sn, "metadata_format", &seg->cache_metadata_format))
+			return SEG_LOG_ERROR("Couldn't read cache metadata_format in");
+		if (seg->cache_metadata_format != CACHE_METADATA_FORMAT_2)
+			return SEG_LOG_ERROR("Unknown cache metadata format %u number in",
+					     seg->cache_metadata_format);
+	}
+
+	if (dm_config_has_node(sn, "metadata_start")) {
+		if (!dm_config_get_uint64(sn, "metadata_start", &seg->metadata_start))
+			return SEG_LOG_ERROR("Couldn't read metadata_start in");
+		if (!dm_config_get_uint64(sn, "metadata_len", &seg->metadata_len))
+			return SEG_LOG_ERROR("Couldn't read metadata_len in");
+		if (!dm_config_get_uint64(sn, "data_start", &seg->data_start))
+			return SEG_LOG_ERROR("Couldn't read data_start in");
+		if (!dm_config_get_uint64(sn, "data_len", &seg->data_len))
+			return SEG_LOG_ERROR("Couldn't read data_len in");
+
+		/* Will use CVOL ID, when metadata_id is not provided */
+		if (dm_config_has_node(sn, "metadata_id")) {
+			if (!(seg->metadata_id = dm_pool_alloc(seg->lv->vg->vgmem, sizeof(*seg->metadata_id))))
+				return SEG_LOG_ERROR("Couldn't allocate metadata_id in");
+			if (!dm_config_get_str(sn, "metadata_id", &uuid))
+				return SEG_LOG_ERROR("Couldn't read metadata_id in");
+			if (!id_read_format(seg->metadata_id, uuid))
+				return SEG_LOG_ERROR("Couldn't format metadata_id in");
+		}
+
+		/* Will use CVOL ID, when data_id is not provided */
+		if (dm_config_has_node(sn, "data_id")) {
+			if (!(seg->data_id = dm_pool_alloc(seg->lv->vg->vgmem, sizeof(*seg->data_id))))
+				return SEG_LOG_ERROR("Couldn't allocate data_id in");
+			if (!dm_config_get_str(sn, "data_id", &uuid))
+				return SEG_LOG_ERROR("Couldn't read data_id in");
+			if (!id_read_format(seg->data_id, uuid))
+				return SEG_LOG_ERROR("Couldn't format data_id in");
+		}
+		pool_lv->status |= LV_CACHE_VOL; /* Mark as cachevol LV */
+	} else {
+		/* Do not call this when LV is cache_vol. */
+		/* 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 (!attach_pool_lv(seg, pool_lv, NULL, NULL, NULL))
+		return_0;
 
 	return 1;
 }
@@ -489,6 +568,8 @@ static int _cache_text_import_area_count(const struct dm_config_node *sn,
 
 static int _cache_text_export(const struct lv_segment *seg, struct formatter *f)
 {
+	char buffer[40];
+
 	if (!seg_lv(seg, 0))
 		return_0;
 
@@ -498,6 +579,30 @@ static int _cache_text_export(const struct lv_segment *seg, struct formatter *f)
 	if (seg->cleaner_policy)
 		outf(f, "cleaner = 1");
 
+	if (lv_is_cache_vol(seg->pool_lv)) {
+		outf(f, "metadata_format = " FMTu32, seg->cache_metadata_format);
+
+		if (!_settings_text_export(seg, f))
+			return_0;
+
+		outf(f, "metadata_start = " FMTu64, seg->metadata_start);
+		outf(f, "metadata_len = " FMTu64, seg->metadata_len);
+		outf(f, "data_start = " FMTu64, seg->data_start);
+		outf(f, "data_len = " FMTu64, seg->data_len);
+
+		if (seg->metadata_id) {
+			if (!id_write_format(seg->metadata_id, buffer, sizeof(buffer)))
+				return_0;
+			outf(f, "metadata_id = \"%s\"", buffer);
+		}
+
+		if (seg->data_id) {
+			if (!id_write_format(seg->data_id, buffer, sizeof(buffer)))
+				return_0;
+			outf(f, "data_id = \"%s\"", buffer);
+		}
+	}
+
 	return 1;
 }
 
@@ -512,6 +617,9 @@ static int _cache_add_target_line(struct dev_manager *dm,
 				 uint32_t *pvmove_mirror_count __attribute__((unused)))
 {
 	struct lv_segment *cache_pool_seg;
+	struct lv_segment *setting_seg;
+	union lvid metadata_lvid;
+	union lvid data_lvid;
 	char *metadata_uuid, *data_uuid, *origin_uuid;
 	uint64_t feature_flags = 0;
 	unsigned attr;
@@ -521,15 +629,23 @@ static int _cache_add_target_line(struct dev_manager *dm,
 		return 0;
 	}
 
+	log_debug("cache_add_target_line lv %s pool %s", seg->lv->name, seg->pool_lv->name);
+
 	cache_pool_seg = first_seg(seg->pool_lv);
+
+	if (lv_is_cache_vol(seg->pool_lv))
+		setting_seg = seg;
+	else
+		setting_seg = cache_pool_seg;
+
 	if (seg->cleaner_policy)
 		/* With cleaner policy always pass writethrough */
 		feature_flags |= DM_CACHE_FEATURE_WRITETHROUGH;
 	else
-		switch (cache_pool_seg->cache_mode) {
+		switch (setting_seg->cache_mode) {
 		default:
 			log_error(INTERNAL_ERROR "LV %s has unknown cache mode %d.",
-				  display_lvname(seg->lv), cache_pool_seg->cache_mode);
+				  display_lvname(seg->lv), setting_seg->cache_mode);
 			/* Fall through */
 		case CACHE_MODE_WRITETHROUGH:
 			feature_flags |= DM_CACHE_FEATURE_WRITETHROUGH;
@@ -542,7 +658,7 @@ static int _cache_add_target_line(struct dev_manager *dm,
 			break;
 		}
 
-	switch (cache_pool_seg->cache_metadata_format) {
+	switch (setting_seg->cache_metadata_format) {
 	case CACHE_METADATA_FORMAT_1: break;
 	case CACHE_METADATA_FORMAT_2:
 		if (!_target_present(cmd, NULL, &attr))
@@ -550,7 +666,7 @@ static int _cache_add_target_line(struct dev_manager *dm,
 
 		if (!(attr & CACHE_FEATURE_METADATA2)) {
 			log_error("LV %s has metadata format %u unsuported by kernel.",
-				  display_lvname(seg->lv), cache_pool_seg->cache_metadata_format);
+				  display_lvname(seg->lv), setting_seg->cache_metadata_format);
 			return 0;
 		}
 		feature_flags |= DM_CACHE_FEATURE_METADATA2;
@@ -558,19 +674,50 @@ static int _cache_add_target_line(struct dev_manager *dm,
 		break;
 	default:
 		log_error(INTERNAL_ERROR "LV %s has unknown metadata format %u.",
-			  display_lvname(seg->lv), cache_pool_seg->cache_metadata_format);
+			  display_lvname(seg->lv), setting_seg->cache_metadata_format);
 		return 0;
 	}
 
-	if (!(metadata_uuid = build_dm_uuid(mem, cache_pool_seg->metadata_lv, NULL)))
-		return_0;
-
-	if (!(data_uuid = build_dm_uuid(mem, seg_lv(cache_pool_seg, 0), NULL)))
-		return_0;
-
 	if (!(origin_uuid = build_dm_uuid(mem, seg_lv(seg, 0), NULL)))
 		return_0;
 
+	if (!lv_is_cache_vol(seg->pool_lv)) {
+		/* We don't use start/len when using separate data/meta devices. */
+		if (seg->metadata_len || seg->data_len) {
+			log_error(INTERNAL_ERROR "LV %s using unsupported ranges with cache pool.",
+				 display_lvname(seg->lv));
+			return 0;
+		}
+
+		if (!(metadata_uuid = build_dm_uuid(mem, cache_pool_seg->metadata_lv, NULL)))
+			return_0;
+
+		if (!(data_uuid = build_dm_uuid(mem, seg_lv(cache_pool_seg, 0), NULL)))
+			return_0;
+	} else {
+		if (!seg->metadata_len || !seg->data_len || (seg->metadata_start == seg->data_start)) {
+			log_error(INTERNAL_ERROR "LV %s has invalid ranges metadata %llu %llu data %llu %llu.",
+				 display_lvname(seg->lv),
+				 (unsigned long long)seg->metadata_start,
+				 (unsigned long long)seg->metadata_len,
+				 (unsigned long long)seg->data_start,
+				 (unsigned long long)seg->data_len);
+			return 0;
+		}
+
+		memset(&metadata_lvid, 0, sizeof(metadata_lvid));
+		memset(&data_lvid, 0, sizeof(data_lvid));
+		memcpy(&metadata_lvid.id[0], &seg->lv->vg->id, sizeof(struct id));
+		memcpy(&metadata_lvid.id[1], (seg->metadata_id) ? : &seg->pool_lv->lvid.id[1], sizeof(struct id));
+		memcpy(&data_lvid.id[0], &seg->lv->vg->id, sizeof(struct id));
+		memcpy(&data_lvid.id[1], (seg->data_id) ? : &seg->pool_lv->lvid.id[1], sizeof(struct id));
+
+		if (!(metadata_uuid = dm_build_dm_uuid(mem, UUID_PREFIX, (const char *)&metadata_lvid.s, "cmeta")))
+			return_0;
+		if (!(data_uuid = dm_build_dm_uuid(mem, UUID_PREFIX, (const char *)&data_lvid.s, "cdata")))
+			return_0;
+	}
+
 	if (!dm_tree_node_add_cache_target(node, len,
 					   feature_flags,
 					   metadata_uuid,
@@ -579,8 +726,12 @@ static int _cache_add_target_line(struct dev_manager *dm,
 					   seg->cleaner_policy ? "cleaner" :
 						   /* undefined policy name -> likely an old "mq" */
 						   cache_pool_seg->policy_name ? : "mq",
-					   seg->cleaner_policy ? NULL : cache_pool_seg->policy_settings,
-					   cache_pool_seg->chunk_size))
+					   seg->cleaner_policy ? NULL : setting_seg->policy_settings,
+					   seg->metadata_start,
+					   seg->metadata_len,
+					   seg->data_start,
+					   seg->data_len,
+					   setting_seg->chunk_size))
 		return_0;
 
 	return 1;

lib/commands/toolcontext.c

@@ -22,6 +22,7 @@
 #include "lib/activate/activate.h"
 #include "lib/filters/filter.h"
 #include "lib/label/label.h"
+#include "lib/label/hints.h"
 #include "lib/misc/lvm-file.h"
 #include "lib/format_text/format-text.h"
 #include "lib/display/display.h"
@@ -32,10 +33,6 @@
 #include "lib/format_text/archiver.h"
 #include "lib/lvmpolld/lvmpolld-client.h"
 
-#ifdef HAVE_LIBDL
-#include "lib/misc/sharedlib.h"
-#endif
-
 #include <locale.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
@@ -235,6 +232,45 @@ static void _get_sysfs_dir(struct cmd_context *cmd, char *buf, size_t buf_size)
 	strncpy(buf, sys_mnt, buf_size);
 }
 
+static uint32_t _parse_debug_fields(struct cmd_context *cmd, int cfg, const char *cfgname)
+{
+	const struct dm_config_node *cn;
+	const struct dm_config_value *cv;
+	uint32_t debug_fields = 0;
+
+	if (!(cn = find_config_tree_array(cmd, cfg, NULL))) {
+		log_error(INTERNAL_ERROR "Unable to find configuration for log/%s.", cfgname);
+		return 0;
+	}
+
+	for (cv = cn->v; cv; cv = cv->next) {
+		if (cv->type != DM_CFG_STRING) {
+			log_verbose("log/%s contains a value which is not a string.  Ignoring.", cfgname);
+			continue;
+		}
+
+		if (!strcasecmp(cv->v.str, "all"))
+			return 0;
+
+		if (!strcasecmp(cv->v.str, "time"))
+			debug_fields |= LOG_DEBUG_FIELD_TIME;
+
+		else if (!strcasecmp(cv->v.str, "command"))
+			debug_fields |= LOG_DEBUG_FIELD_COMMAND;
+
+		else if (!strcasecmp(cv->v.str, "fileline"))
+			debug_fields |= LOG_DEBUG_FIELD_FILELINE;
+
+		else if (!strcasecmp(cv->v.str, "message"))
+			debug_fields |= LOG_DEBUG_FIELD_MESSAGE;
+
+		else
+			log_verbose("Unrecognised value for log/%s: %s", cfgname, cv->v.str);
+	}
+
+	return debug_fields;
+}
+
 static int _parse_debug_classes(struct cmd_context *cmd)
 {
 	const struct dm_config_node *cn;
@@ -323,8 +359,8 @@ static void _init_logging(struct cmd_context *cmd)
 	cmd->default_settings.msg_prefix = find_config_tree_str_allow_empty(cmd, log_prefix_CFG, NULL);
 	init_msg_prefix(cmd->default_settings.msg_prefix);
 
-	cmd->default_settings.cmd_name = find_config_tree_bool(cmd, log_command_names_CFG, NULL);
-	init_cmd_name(cmd->default_settings.cmd_name);
+	/* so that file and verbose output have a command prefix */
+	init_log_command(0, 0);
 
 	/* Test mode */
 	cmd->default_settings.test =
@@ -338,21 +374,19 @@ static void _init_logging(struct cmd_context *cmd)
 	log_file = find_config_tree_str(cmd, log_file_CFG, NULL);
 
 	if (log_file) {
-		release_log_memory();
 		fin_log();
 		init_log_file(log_file, append);
 	}
 
-	log_file = find_config_tree_str(cmd, log_activate_file_CFG, NULL);
-	if (log_file)
-		init_log_direct(log_file, append);
-
 	init_log_while_suspended(find_config_tree_bool(cmd, log_activation_CFG, NULL));
 
 	cmd->default_settings.debug_classes = _parse_debug_classes(cmd);
 	log_debug("Setting log debug classes to %d", cmd->default_settings.debug_classes);
 	init_debug_classes_logged(cmd->default_settings.debug_classes);
 
+	init_debug_file_fields(_parse_debug_fields(cmd, log_debug_file_fields_CFG, "debug_file_fields"));
+	init_debug_output_fields(_parse_debug_fields(cmd, log_debug_output_fields_CFG, "debug_output_fields"));
+
 	t = time(NULL);
 	ctime_r(&t, &timebuf[0]);
 	timebuf[24] = '\0';
@@ -681,6 +715,8 @@ static int _process_config(struct cmd_context *cmd)
 	if (!_init_system_id(cmd))
 		return_0;
 
+	init_io_memory_size(find_config_tree_int(cmd, global_io_memory_size_CFG, NULL));
+
 	return 1;
 }
 
@@ -1032,7 +1068,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
 
 #define MAX_FILTERS 10
 
-static struct dev_filter *_init_lvmetad_filter_chain(struct cmd_context *cmd)
+static struct dev_filter *_init_filter_chain(struct cmd_context *cmd)
 {
 	int nr_filt = 0;
 	const struct dm_config_node *cn;
@@ -1088,7 +1124,7 @@ static struct dev_filter *_init_lvmetad_filter_chain(struct cmd_context *cmd)
 	nr_filt++;
 
 	/* usable device filter. Required. */
-	if (!(filters[nr_filt] = usable_filter_create(cmd->dev_types, FILTER_MODE_NO_LVMETAD))) {
+	if (!(filters[nr_filt] = usable_filter_create(cmd, cmd->dev_types, FILTER_MODE_NO_LVMETAD))) {
 		log_error("Failed to create usabled device filter");
 		goto bad;
 	}
@@ -1141,65 +1177,45 @@ bad:
 }
 
 /*
- * The way the filtering is initialized depends on whether lvmetad is uesd or not.
- *
- * 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 ->
- *     usable device filter(FILTER_MODE_PRE_LVMETAD) ->
- *     mpath component filter -> partitioned filter ->
- *     md component filter -> fw raid filter
- *
- *   - cmd->filter - the filter chain used for lvmetad responses:
- *     persistent filter -> regex_filter -> usable device filter(FILTER_MODE_POST_LVMETAD)
- *
- *   - cmd->full_filter - the filter chain used for all the remaining situations:
- *     cmd->lvmetad_filter -> cmd->filter
- *
- * 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 ->
- *     regex_filter -> type filter -> usable device filter(FILTER_MODE_NO_LVMETAD) ->
+ *   cmd->filter == 
+ *     persistent(cache) filter -> sysfs filter -> internal filter -> global regex filter ->
+ *     regex_filter -> type filter -> usable device filter ->
  *     mpath component filter -> partitioned filter -> md component filter -> fw raid filter
  *
  */
 int init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
 {
-	struct dev_filter *filter = NULL, *filter_components[2] = {0};
+	struct dev_filter *pfilter, *filter = NULL, *filter_components[2] = {0};
 
 	if (!cmd->initialized.connections) {
 		log_error(INTERNAL_ERROR "connections must be initialized before filters");
 		return 0;
 	}
 
-	cmd->lvmetad_filter = _init_lvmetad_filter_chain(cmd);
-	if (!cmd->lvmetad_filter)
+	filter = _init_filter_chain(cmd);
+	if (!filter)
 		goto_bad;
 
 	init_ignore_suspended_devices(find_config_tree_bool(cmd, devices_ignore_suspended_devices_CFG, NULL));
 	init_ignore_lvm_mirrors(find_config_tree_bool(cmd, devices_ignore_lvm_mirrors_CFG, NULL));
 
 	/*
-	 * If lvmetad is used, there's a separation between pre-lvmetad filter chain
-	 * ("cmd->lvmetad_filter") applied only if scanning for lvmetad update and
-	 * post-lvmetad filter chain ("filter") applied on each lvmetad response.
-	 * However, if lvmetad is not used, these two chains are not separated
-	 * and we use exactly one filter chain during device scanning ("filter"
-	 * that includes also "cmd->lvmetad_filter" chain).
+	 * persisent filter is a cache of the previous result real filter result.
+	 * If a dev is found in persistent filter, the pass/fail result saved by
+	 * the pfilter is used.  If a dev does not existing in the persistent
+	 * filter, the dev is passed on to the real filter, and when the result
+	 * of the real filter is saved in the persistent filter.
+	 *
+	 * FIXME: we should apply the filter once at the start of the command,
+	 * and not call the filters repeatedly.  In that case we would not need
+	 * the persistent/caching filter layer.
 	 */
-	filter = cmd->lvmetad_filter;
-	cmd->lvmetad_filter = NULL;
-
-	if (!(filter = persistent_filter_create(cmd->dev_types, filter))) {
+	if (!(pfilter = persistent_filter_create(cmd->dev_types, filter))) {
 		log_verbose("Failed to create persistent device filter.");
 		goto bad;
 	}
 
-	cmd->filter = filter;
-
-	cmd->full_filter = filter;
+	cmd->filter = pfilter;
 
 	cmd->initialized.filters = 1;
 	return 1;
@@ -1221,10 +1237,6 @@ bad:
 		filter->destroy(filter);
 	}
 
-	/* if lvmetad is used, the cmd->lvmetad_filter is separate */
-	if (cmd->lvmetad_filter)
-		cmd->lvmetad_filter->destroy(cmd->lvmetad_filter);
-
 	cmd->initialized.filters = 0;
 	return 0;
 }
@@ -1298,24 +1310,6 @@ int lvm_register_segtype(struct segtype_library *seglib,
 	return 1;
 }
 
-static int _init_single_segtype(struct cmd_context *cmd,
-				struct segtype_library *seglib)
-{
-	struct segment_type *(*init_segtype_fn) (struct cmd_context *);
-	struct segment_type *segtype;
-
-	if (!(init_segtype_fn = dlsym(seglib->lib, "init_segtype"))) {
-		log_error("Shared library %s does not contain segment type "
-			  "functions", seglib->libname);
-		return 0;
-	}
-
-	if (!(segtype = init_segtype_fn(seglib->cmd)))
-		return_0;
-
-	return lvm_register_segtype(seglib, segtype);
-}
-
 static int _init_segtypes(struct cmd_context *cmd)
 {
 	int i;
@@ -1336,10 +1330,6 @@ static int _init_segtypes(struct cmd_context *cmd)
 		NULL
 	};
 
-#ifdef HAVE_LIBDL
-	const struct dm_config_node *cn;
-#endif
-
 	for (i = 0; init_segtype_array[i]; i++) {
 		if (!(segtype = init_segtype_array[i](cmd)))
 			return 0;
@@ -1366,60 +1356,15 @@ static int _init_segtypes(struct cmd_context *cmd)
 	if (!init_vdo_segtypes(cmd, &seglib))
 		return_0;
 #endif
+
+#ifdef WRITECACHE_INTERNAL
 	if (!init_writecache_segtypes(cmd, &seglib))
 		return 0;
-
-#ifdef HAVE_LIBDL
-	/* Load any formats in shared libs unless static */
-	if (!is_static() &&
-	    (cn = find_config_tree_array(cmd, global_segment_libraries_CFG, NULL))) {
-
-		const struct dm_config_value *cv;
-		int (*init_multiple_segtypes_fn) (struct cmd_context *,
-						  struct segtype_library *);
-
-		for (cv = cn->v; cv; cv = cv->next) {
-			if (cv->type != DM_CFG_STRING) {
-				log_error("Invalid string in config file: "
-					  "global/segment_libraries");
-				return 0;
-			}
-			seglib.libname = cv->v.str;
-			if (!(seglib.lib = load_shared_library(cmd,
-							seglib.libname,
-							"segment type", 0)))
-				return_0;
-
-			if ((init_multiple_segtypes_fn =
-			    dlsym(seglib.lib, "init_multiple_segtypes"))) {
-				if (dlsym(seglib.lib, "init_segtype"))
-					log_warn("WARNING: Shared lib %s has "
-						 "conflicting init fns.  Using"
-						 " init_multiple_segtypes().",
-						 seglib.libname);
-			} else
-				init_multiple_segtypes_fn =
-				    _init_single_segtype;
- 
-			if (!init_multiple_segtypes_fn(cmd, &seglib)) {
-				struct dm_list *sgtl, *tmp;
-				log_error("init_multiple_segtypes() failed: "
-					  "Unloading shared library %s",
-					  seglib.libname);
-				dm_list_iterate_safe(sgtl, tmp, &cmd->segtypes) {
-					segtype = dm_list_item(sgtl, struct segment_type);
-					if (segtype->library == seglib.lib) {
-						dm_list_del(&segtype->list);
-						segtype->ops->destroy(segtype);
-					}
-				}
-				dlclose(seglib.lib);
-				return_0;
-			}
-		}
-	}
 #endif
 
+	if (!init_integrity_segtypes(cmd, &seglib))
+		return 0;
+
 	return 1;
 }
 
@@ -1550,6 +1495,8 @@ void destroy_config_context(struct cmd_context *cmd)
 		dm_pool_destroy(cmd->mem);
 	if (cmd->libmem)
 		dm_pool_destroy(cmd->libmem);
+	if (cmd->pending_delete_mem)
+		dm_pool_destroy(cmd->pending_delete_mem);
 
 	free(cmd);
 }
@@ -1578,8 +1525,12 @@ struct cmd_context *create_config_context(void)
 	if (!(cmd->mem = dm_pool_create("command", 4 * 1024)))
 		goto out;
 
+	if (!(cmd->pending_delete_mem = dm_pool_create("pending_delete", 1024)))
+		goto_out;
+
 	dm_list_init(&cmd->config_files);
 	dm_list_init(&cmd->tags);
+	dm_list_init(&cmd->hints);
 
 	if (!_init_lvm_conf(cmd))
 		goto_out;
@@ -1724,6 +1675,9 @@ struct cmd_context *create_toolcontext(unsigned is_clvmd,
 		goto out;
 	}
 
+	if (!(cmd->pending_delete_mem = dm_pool_create("pending_delete", 1024)))
+		goto_out;
+
 	if (!_init_lvm_conf(cmd))
 		goto_out;
 
@@ -1755,6 +1709,8 @@ struct cmd_context *create_toolcontext(unsigned is_clvmd,
 						find_config_tree_array(cmd, devices_types_CFG, NULL))))
 		goto_out;
 
+	init_use_aio(find_config_tree_bool(cmd, global_use_aio_CFG, NULL));
+
 	if (!_init_dev_cache(cmd))
 		goto_out;
 
@@ -1770,8 +1726,6 @@ struct cmd_context *create_toolcontext(unsigned is_clvmd,
 	if (!init_lvmcache_orphans(cmd))
 		goto_out;
 
-	dm_list_init(&cmd->unused_duplicate_devs);
-
 	if (!_init_segtypes(cmd))
 		goto_out;
 
@@ -1791,6 +1745,8 @@ struct cmd_context *create_toolcontext(unsigned is_clvmd,
 	cmd->current_settings = cmd->default_settings;
 
 	cmd->initialized.config = 1;
+
+	dm_list_init(&cmd->pending_delete);
 out:
 	if (!cmd->initialized.config) {
 		destroy_toolcontext(cmd);
@@ -1816,27 +1772,11 @@ static void _destroy_segtypes(struct dm_list *segtypes)
 {
 	struct dm_list *sgtl, *tmp;
 	struct segment_type *segtype;
-	void *lib;
 
 	dm_list_iterate_safe(sgtl, tmp, segtypes) {
 		segtype = dm_list_item(sgtl, struct segment_type);
 		dm_list_del(&segtype->list);
-		lib = segtype->library;
 		segtype->ops->destroy(segtype);
-#ifdef HAVE_LIBDL
-		/*
-		 * If no segtypes remain from this library, close it.
-		 */
-		if (lib) {
-			struct segment_type *segtype2;
-			dm_list_iterate_items(segtype2, segtypes)
-				if (segtype2->library == lib)
-					goto skip_dlclose;
-			dlclose(lib);
-skip_dlclose:
-			;
-		}
-#endif
 	}
 }
 
@@ -1851,9 +1791,9 @@ static void _destroy_dev_types(struct cmd_context *cmd)
 
 static void _destroy_filters(struct cmd_context *cmd)
 {
-	if (cmd->full_filter) {
-		cmd->full_filter->destroy(cmd->full_filter);
-		cmd->lvmetad_filter = cmd->filter = cmd->full_filter = NULL;
+	if (cmd->filter) {
+		cmd->filter->destroy(cmd->filter);
+		cmd->filter = NULL;
 	}
 	cmd->initialized.filters = 0;
 }
@@ -1892,6 +1832,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
 	 */
 
 	activation_release();
+	hints_exit(cmd);
 	lvmcache_destroy(cmd, 0, 0);
 	label_scan_destroy(cmd);
 	label_exit();
@@ -1994,6 +1935,12 @@ int refresh_toolcontext(struct cmd_context *cmd)
 
 	cmd->initialized.config = 1;
 
+	if (!dm_list_empty(&cmd->pending_delete)) {
+		log_debug(INTERNAL_ERROR "Unprocessed pending delete for %d devices.",
+			  dm_list_size(&cmd->pending_delete));
+		dm_list_init(&cmd->pending_delete);
+	}
+
 	if (cmd->initialized.connections && !init_connections(cmd))
 		return_0;
 
@@ -2011,6 +1958,7 @@ void destroy_toolcontext(struct cmd_context *cmd)
 
 	archive_exit(cmd);
 	backup_exit(cmd);
+	hints_exit(cmd);
 	lvmcache_destroy(cmd, 0, 0);
 	label_scan_destroy(cmd);
 	label_exit();
@@ -2033,6 +1981,8 @@ void destroy_toolcontext(struct cmd_context *cmd)
 	if (cmd->libmem)
 		dm_pool_destroy(cmd->libmem);
 
+	if (cmd->pending_delete_mem)
+		dm_pool_destroy(cmd->pending_delete_mem);
 #ifndef VALGRIND_POOL
 	if (cmd->linebuffer) {
 		/* Reset stream buffering to defaults */
@@ -2061,7 +2011,6 @@ void destroy_toolcontext(struct cmd_context *cmd)
 
 	lvmpolld_disconnect();
 
-	release_log_memory();
 	activation_exit();
 	reset_log_duplicated();
 	fin_log();

lib/commands/toolcontext.h

@@ -44,7 +44,6 @@ struct config_info {
 	const char *fmt_name;
 	const char *dmeventd_executable;
 	uint64_t unit_factor;
-	int cmd_name;		/* Show command name? */
 	mode_t umask;
 	char unit_type;
 	char _padding[1];
@@ -149,10 +148,12 @@ struct cmd_context {
 	unsigned unknown_system_id:1;
 	unsigned include_historical_lvs:1;	/* also process/report/display historical LVs */
 	unsigned record_historical_lvs:1;	/* record historical LVs */
+	unsigned include_exported_vgs:1;
 	unsigned include_foreign_vgs:1;		/* report/display cmds can reveal foreign VGs */
 	unsigned include_shared_vgs:1;		/* report/display cmds can reveal lockd VGs */
 	unsigned include_active_foreign_vgs:1;	/* cmd should process foreign VGs with active LVs */
 	unsigned vg_read_print_access_error:1;	/* print access errors from vg_read */
+	unsigned allow_mixed_block_sizes:1;
 	unsigned force_access_clustered:1;
 	unsigned lockd_gl_disable:1;
 	unsigned lockd_vg_disable:1;
@@ -160,7 +161,10 @@ struct cmd_context {
 	unsigned lockd_gl_removed:1;
 	unsigned lockd_vg_default_sh:1;
 	unsigned lockd_vg_enforce_sh:1;
-	unsigned lockd_lv_sh:1;
+	unsigned lockd_lv_sh_for_ex:1;
+	unsigned lockd_global_ex:1;		/* set while global lock held ex (lockd) */
+	unsigned lockf_global_ex:1;		/* set while global lock held ex (flock) */
+	unsigned nolocking:1;
 	unsigned vg_notify:1;
 	unsigned lv_notify:1;
 	unsigned pv_notify:1;
@@ -170,15 +174,21 @@ struct cmd_context {
 	unsigned pvscan_cache_single:1;
 	unsigned can_use_one_scan:1;
 	unsigned is_clvmd:1;
+	unsigned md_component_detection:1;
 	unsigned use_full_md_check:1;
 	unsigned is_activating:1;
+	unsigned enable_hints:1;		/* hints are enabled for cmds in general */
+	unsigned use_hints:1;			/* if hints are enabled this cmd can use them */
+	unsigned pvscan_recreate_hints:1;	/* enable special case hint handling for pvscan --cache */
+	unsigned scan_lvs:1;
+	unsigned wipe_outdated_pvs:1;
 
 	/*
-	 * Filtering.
+	 * Devices and filtering.
 	 */
-	struct dev_filter *lvmetad_filter;	/* pre-lvmetad filter chain */
-	struct dev_filter *filter;		/* post-lvmetad filter chain */
-	struct dev_filter *full_filter;		/* lvmetad_filter + filter */
+	struct dev_filter *filter;
+	struct dm_list hints;
+	const char *md_component_checks;
 
 	/*
 	 * Configuration.
@@ -229,7 +239,8 @@ 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 */
+	struct dm_list pending_delete;		/* list of LVs for removal */
+	struct dm_pool *pending_delete_mem;	/* memory pool for pending deletes */
 };
 
 /*

lib/config/config.c

@@ -24,6 +24,7 @@
 #include "lib/misc/lvm-file.h"
 #include "lib/mm/memlock.h"
 #include "lib/label/label.h"
+#include "lib/metadata/metadata.h"
 
 #include <sys/stat.h>
 #include <sys/mman.h>
@@ -2333,6 +2334,11 @@ int load_pending_profiles(struct cmd_context *cmd)
 	return r;
 }
 
+int get_default_metadata_pvmetadatasize_CFG(struct cmd_context *cmd, struct profile *profile)
+{
+	return get_default_pvmetadatasize_sectors();
+}
+
 const char *get_default_devices_cache_dir_CFG(struct cmd_context *cmd, struct profile *profile)
 {
 	static char buf[PATH_MAX];

lib/config/config.h

@@ -311,5 +311,7 @@ int get_default_allocation_cache_pool_chunk_size_CFG(struct cmd_context *cmd, st
 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);
+int get_default_metadata_pvmetadatasize_CFG(struct cmd_context *cmd, struct profile *profile);
+#define get_default_unconfigured_metadata_pvmetadatasize_CFG NULL
 
 #endif

lib/config/config_settings.h

@@ -226,7 +226,7 @@ cfg(devices_dir_CFG, "dir", devices_CFG_SECTION, CFG_ADVANCED, CFG_TYPE_STRING,
 cfg_array(devices_scan_CFG, "scan", devices_CFG_SECTION, CFG_ADVANCED, CFG_TYPE_STRING, "#S/dev", vsn(1, 0, 0), NULL, 0, NULL,
 	"Directories containing device nodes to use with LVM.\n")
 
-cfg_array(devices_loopfiles_CFG, "loopfiles", devices_CFG_SECTION, CFG_DEFAULT_UNDEFINED | CFG_UNSUPPORTED, CFG_TYPE_STRING, NULL, vsn(1, 2, 0), NULL, vsn(3, 0, 0), NULL, NULL)
+cfg_array(devices_loopfiles_CFG, "loopfiles", devices_CFG_SECTION, CFG_DEFAULT_UNDEFINED | CFG_UNSUPPORTED, CFG_TYPE_STRING, NULL, vsn(1, 2, 0), NULL, vsn(2, 3, 0), NULL, NULL)
 
 cfg(devices_obtain_device_list_from_udev_CFG, "obtain_device_list_from_udev", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_OBTAIN_DEVICE_LIST_FROM_UDEV, vsn(2, 2, 85), NULL, 0, NULL,
 	"Obtain the list of available devices from udev.\n"
@@ -255,6 +255,20 @@ cfg(devices_external_device_info_source_CFG, "external_device_info_source", devi
 	"    compiled with udev support.\n"
 	"#\n")
 
+cfg(devices_hints_CFG, "hints", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_HINTS, vsn(2, 3, 2), NULL, 0, NULL,
+	"Use a local file to remember which devices have PVs on them.\n"
+	"Some commands will use this as an optimization to reduce device\n"
+	"scanning, and will only scan the listed PVs. Removing the hint file\n"
+	"will cause lvm to generate a new one. Disable hints if PVs will\n"
+	"be copied onto devices using non-lvm commands, like dd.\n"
+	"#\n"
+	"Accepted values:\n"
+	"  all\n"
+	"    Use all hints.\n"
+	"  none\n"
+	"    Use no hints.\n"
+	"#\n")
+
 cfg_array(devices_preferred_names_CFG, "preferred_names", devices_CFG_SECTION, CFG_ALLOW_EMPTY | CFG_DEFAULT_UNDEFINED , CFG_TYPE_STRING, NULL, vsn(1, 2, 19), NULL, 0, NULL,
 	"Select which path name to display for a block device.\n"
 	"If multiple path names exist for a block device, and LVM needs to\n"
@@ -274,7 +288,7 @@ cfg_array(devices_preferred_names_CFG, "preferred_names", devices_CFG_SECTION, C
 	"preferred_names = [ \"^/dev/mpath/\", \"^/dev/mapper/mpath\", \"^/dev/[hs]d\" ]\n"
 	"#\n")
 
-cfg_array(devices_filter_CFG, "filter", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, "#Sa|.*/|", vsn(1, 0, 0), NULL, 0, NULL,
+cfg_array(devices_filter_CFG, "filter", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, "#Sa|.*|", vsn(1, 0, 0), NULL, 0, NULL,
 	"Limit the block devices that are used by LVM commands.\n"
 	"This is a list of regular expressions used to accept or reject block\n"
 	"device path names. Each regex is delimited by a vertical bar '|'\n"
@@ -292,7 +306,7 @@ cfg_array(devices_filter_CFG, "filter", devices_CFG_SECTION, CFG_DEFAULT_COMMENT
 	"#\n"
 	"Example\n"
 	"Accept every block device:\n"
-	"filter = [ \"a|.*/|\" ]\n"
+	"filter = [ \"a|.*|\" ]\n"
 	"Reject the cdrom drive:\n"
 	"filter = [ \"r|/dev/cdrom|\" ]\n"
 	"Work with just loopback devices, e.g. for testing:\n"
@@ -300,10 +314,10 @@ cfg_array(devices_filter_CFG, "filter", devices_CFG_SECTION, CFG_DEFAULT_COMMENT
 	"Accept all loop devices and ide drives except hdc:\n"
 	"filter = [ \"a|loop|\", \"r|/dev/hdc|\", \"a|/dev/ide|\", \"r|.*|\" ]\n"
 	"Use anchors to be very specific:\n"
-	"filter = [ \"a|^/dev/hda8$|\", \"r|.*/|\" ]\n"
+	"filter = [ \"a|^/dev/hda8$|\", \"r|.*|\" ]\n"
 	"#\n")
 
-cfg_array(devices_global_filter_CFG, "global_filter", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, "#Sa|.*/|", vsn(2, 2, 98), NULL, 0, NULL,
+cfg_array(devices_global_filter_CFG, "global_filter", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, "#Sa|.*|", vsn(2, 2, 98), NULL, 0, NULL,
 	"Limit the block devices that are used by LVM system components.\n"
 	"Because devices/filter may be overridden from the command line, it is\n"
 	"not suitable for system-wide device filtering, e.g. udev.\n"
@@ -314,13 +328,13 @@ cfg_array(devices_global_filter_CFG, "global_filter", devices_CFG_SECTION, CFG_D
 cfg_runtime(devices_cache_CFG, "cache", devices_CFG_SECTION, 0, CFG_TYPE_STRING, vsn(1, 0, 0), vsn(1, 2, 19), NULL,
 	"This setting is no longer used.\n")
 
-cfg_runtime(devices_cache_dir_CFG, "cache_dir", devices_CFG_SECTION, 0, CFG_TYPE_STRING, vsn(1, 2, 19), vsn(3, 0, 0), NULL,
+cfg_runtime(devices_cache_dir_CFG, "cache_dir", devices_CFG_SECTION, 0, CFG_TYPE_STRING, vsn(1, 2, 19), vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
-cfg(devices_cache_file_prefix_CFG, "cache_file_prefix", devices_CFG_SECTION, CFG_ALLOW_EMPTY, CFG_TYPE_STRING, DEFAULT_CACHE_FILE_PREFIX, vsn(1, 2, 19), NULL, vsn(3, 0, 0), NULL,
+cfg(devices_cache_file_prefix_CFG, "cache_file_prefix", devices_CFG_SECTION, CFG_ALLOW_EMPTY, CFG_TYPE_STRING, DEFAULT_CACHE_FILE_PREFIX, vsn(1, 2, 19), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
-cfg(devices_write_cache_state_CFG, "write_cache_state", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, 1, vsn(1, 0, 0), NULL, vsn(3, 0, 0), NULL,
+cfg(devices_write_cache_state_CFG, "write_cache_state", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, 1, vsn(1, 0, 0), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
 cfg_array(devices_types_CFG, "types", devices_CFG_SECTION, CFG_DEFAULT_UNDEFINED | CFG_ADVANCED, CFG_TYPE_INT | CFG_TYPE_STRING, NULL, vsn(1, 0, 0), NULL, 0, NULL,
@@ -337,11 +351,47 @@ cfg(devices_sysfs_scan_CFG, "sysfs_scan", devices_CFG_SECTION, 0, CFG_TYPE_BOOL,
 	"This is a quick way of filtering out block devices that are not\n"
 	"present on the system. sysfs must be part of the kernel and mounted.)\n")
 
+cfg(devices_scan_lvs_CFG, "scan_lvs", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_SCAN_LVS, vsn(2, 2, 182), NULL, 0, NULL,
+	"Scan LVM LVs for layered PVs, allowing LVs to be used as PVs.\n"
+	"When 1, LVM will detect PVs layered on LVs, and caution must be\n"
+	"taken to avoid a host accessing a layered VG that may not belong\n"
+	"to it, e.g. from a guest image. This generally requires excluding\n"
+	"the LVs with device filters. Also, when this setting is enabled,\n"
+	"every LVM command will scan every active LV on the system (unless\n"
+	"filtered), which can cause performance problems on systems with\n"
+	"many active LVs. When this setting is 0, LVM will not detect or\n"
+	"use PVs that exist on LVs, and will not allow a PV to be created on\n"
+	"an LV. The LVs are ignored using a built in device filter that\n"
+	"identifies and excludes LVs.\n")
+
 cfg(devices_multipath_component_detection_CFG, "multipath_component_detection", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_MULTIPATH_COMPONENT_DETECTION, vsn(2, 2, 89), NULL, 0, NULL,
 	"Ignore devices that are components of DM multipath devices.\n")
 
 cfg(devices_md_component_detection_CFG, "md_component_detection", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_MD_COMPONENT_DETECTION, vsn(1, 0, 18), NULL, 0, NULL,
-	"Ignore devices that are components of software RAID (md) devices.\n")
+	"Enable detection and exclusion of MD component devices.\n"
+	"An MD component device is a block device that MD uses as part\n"
+	"of a software RAID virtual device. When an LVM PV is created\n"
+	"on an MD device, LVM must only use the top level MD device as\n"
+	"the PV, and should ignore the underlying component devices.\n"
+	"In cases where the MD superblock is located at the end of the\n"
+	"component devices, it is more difficult for LVM to consistently\n"
+	"identify an MD component, see the md_component_checks setting.\n")
+
+cfg(devices_md_component_checks_CFG, "md_component_checks", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_MD_COMPONENT_CHECKS, vsn(2, 3, 2), NULL, 0, NULL,
+	"The checks LVM should use to detect MD component devices.\n"
+	"MD component devices are block devices used by MD software RAID.\n"
+	"#\n"
+	"Accepted values:\n"
+	"  auto\n"
+	"    LVM will skip scanning the end of devices when it has other\n"
+	"    indications that the device is not an MD component.\n"
+	"  start\n"
+	"    LVM will only scan the start of devices for MD superblocks.\n"
+	"    This does not incur extra I/O by LVM.\n"
+	"  full\n"
+	"    LVM will scan the start and end of devices for MD superblocks.\n"
+	"    This requires an extra read at the end of devices.\n"
+	"#\n")
 
 cfg(devices_fw_raid_component_detection_CFG, "fw_raid_component_detection", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_FW_RAID_COMPONENT_DETECTION, vsn(2, 2, 112), NULL, 0, NULL,
 	"Ignore devices that are components of firmware RAID devices.\n"
@@ -349,16 +399,21 @@ cfg(devices_fw_raid_component_detection_CFG, "fw_raid_component_detection", devi
 	"detection to execute.\n")
 
 cfg(devices_md_chunk_alignment_CFG, "md_chunk_alignment", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_MD_CHUNK_ALIGNMENT, vsn(2, 2, 48), NULL, 0, NULL,
-	"Align PV data blocks with md device's stripe-width.\n"
-	"This applies if a PV is placed directly on an md device.\n")
+	"Align the start of a PV data area with md device's stripe-width.\n"
+	"This applies if a PV is placed directly on an md device.\n"
+	"default_data_alignment will be overriden if it is not aligned\n"
+	"with the value detected for this setting.\n"
+	"This setting is overriden by data_alignment_detection,\n"
+	"data_alignment, and the --dataalignment option.\n")
 
-cfg(devices_default_data_alignment_CFG, "default_data_alignment", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_DATA_ALIGNMENT, vsn(2, 2, 75), NULL, 0, NULL,
-	"Default alignment of the start of a PV data area in MB.\n"
-	"If set to 0, a value of 64KiB will be used.\n"
-	"Set to 1 for 1MiB, 2 for 2MiB, etc.\n")
+cfg(devices_default_data_alignment_CFG, "default_data_alignment", devices_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, FIRST_PE_AT_ONE_MB_IN_MB, vsn(2, 2, 75), NULL, 0, NULL,
+	"Align the start of a PV data area with this number of MiB.\n"
+	"Set to 1 for 1MiB, 2 for 2MiB, etc. Set to 0 to disable.\n"
+	"This setting is overriden by data_alignment and the --dataalignment\n"
+	"option.\n")
 
 cfg(devices_data_alignment_detection_CFG, "data_alignment_detection", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_DATA_ALIGNMENT_DETECTION, vsn(2, 2, 51), NULL, 0, NULL,
-	"Detect PV data alignment based on sysfs device information.\n"
+	"Align the start of a PV data area with sysfs io properties.\n"
 	"The start of a PV data area will be a multiple of minimum_io_size or\n"
 	"optimal_io_size exposed in sysfs. minimum_io_size is the smallest\n"
 	"request the device can perform without incurring a read-modify-write\n"
@@ -366,25 +421,27 @@ cfg(devices_data_alignment_detection_CFG, "data_alignment_detection", devices_CF
 	"preferred unit of receiving I/O, e.g. MD stripe width.\n"
 	"minimum_io_size is used if optimal_io_size is undefined (0).\n"
 	"If md_chunk_alignment is enabled, that detects the optimal_io_size.\n"
-	"This setting takes precedence over md_chunk_alignment.\n")
+	"default_data_alignment and md_chunk_alignment will be overriden\n"
+	"if they are not aligned with the value detected for this setting.\n"
+	"This setting is overriden by data_alignment and the --dataalignment\n"
+	"option.\n")
 
 cfg(devices_data_alignment_CFG, "data_alignment", devices_CFG_SECTION, 0, CFG_TYPE_INT, 0, vsn(2, 2, 45), NULL, 0, NULL,
-	"Alignment of the start of a PV data area in KiB.\n"
-	"If a PV is placed directly on an md device and md_chunk_alignment or\n"
-	"data_alignment_detection are enabled, then this setting is ignored.\n"
-	"Otherwise, md_chunk_alignment and data_alignment_detection are\n"
-	"disabled if this is set. Set to 0 to use the default alignment or the\n"
-	"page size, if larger.\n")
+	"Align the start of a PV data area with this number of KiB.\n"
+	"When non-zero, this setting overrides default_data_alignment.\n"
+	"Set to 0 to disable, in which case default_data_alignment\n"
+	"is used to align the first PE in units of MiB.\n"
+	"This setting is overriden by the --dataalignment option.\n")
 
 cfg(devices_data_alignment_offset_detection_CFG, "data_alignment_offset_detection", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_DATA_ALIGNMENT_OFFSET_DETECTION, vsn(2, 2, 50), NULL, 0, NULL,
-	"Detect PV data alignment offset based on sysfs device information.\n"
-	"The start of a PV aligned data area will be shifted by the\n"
+	"Shift the start of an aligned PV data area based on sysfs information.\n"
+	"After a PV data area is aligned, it will be shifted by the\n"
 	"alignment_offset exposed in sysfs. This offset is often 0, but may\n"
 	"be non-zero. Certain 4KiB sector drives that compensate for windows\n"
 	"partitioning will have an alignment_offset of 3584 bytes (sector 7\n"
 	"is the lowest aligned logical block, the 4KiB sectors start at\n"
 	"LBA -1, and consequently sector 63 is aligned on a 4KiB boundary).\n"
-	"pvcreate --dataalignmentoffset will skip this detection.\n")
+	"This setting is overriden by the --dataalignmentoffset option.\n")
 
 cfg(devices_ignore_suspended_devices_CFG, "ignore_suspended_devices", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_IGNORE_SUSPENDED_DEVICES, vsn(1, 2, 19), NULL, 0, NULL,
 	"Ignore DM devices that have I/O suspended while scanning devices.\n"
@@ -409,7 +466,7 @@ cfg(devices_ignore_lvm_mirrors_CFG, "ignore_lvm_mirrors", devices_CFG_SECTION, 0
 	"apply to LVM RAID types like 'raid1' which handle failures in a\n"
 	"different way, making them a better choice for VG stacking.\n")
 
-cfg(devices_disable_after_error_count_CFG, "disable_after_error_count", devices_CFG_SECTION, 0, CFG_TYPE_INT, 0, vsn(2, 2, 75), NULL, vsn(3, 0, 0), NULL,
+cfg(devices_disable_after_error_count_CFG, "disable_after_error_count", devices_CFG_SECTION, 0, CFG_TYPE_INT, 0, vsn(2, 2, 75), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
 cfg(devices_require_restorefile_with_uuid_CFG, "require_restorefile_with_uuid", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_REQUIRE_RESTOREFILE_WITH_UUID, vsn(2, 2, 73), NULL, 0, NULL,
@@ -445,6 +502,11 @@ cfg(devices_allow_changes_with_duplicate_pvs_CFG, "allow_changes_with_duplicate_
 	"Enabling this setting allows the VG to be used as usual even with\n"
 	"uncertain devices.\n")
 
+cfg(devices_allow_mixed_block_sizes_CFG, "allow_mixed_block_sizes", devices_CFG_SECTION, 0, CFG_TYPE_BOOL, 0, vsn(2, 3, 6), NULL, 0, NULL,
+	"Allow PVs in the same VG with different logical block sizes.\n"
+	"When allowed, the user is responsible to ensure that an LV is\n"
+	"using PVs with matching block sizes when necessary.\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"
@@ -471,7 +533,7 @@ cfg(allocation_maximise_cling_CFG, "maximise_cling", allocation_CFG_SECTION, 0,
 	"and revert to the previous algorithm.\n")
 
 cfg(allocation_use_blkid_wiping_CFG, "use_blkid_wiping", allocation_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_USE_BLKID_WIPING, vsn(2, 2, 105), "@DEFAULT_USE_BLKID_WIPING@", 0, NULL,
-	"Use blkid to detect existing signatures on new PVs and LVs.\n"
+	"Use blkid to detect and erase existing signatures on new PVs and LVs.\n"
 	"The blkid library can detect more signatures than the native LVM\n"
 	"detection code, but may take longer. LVM needs to be compiled with\n"
 	"blkid wiping support for this setting to apply. LVM native detection\n"
@@ -606,7 +668,7 @@ 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")
 
-#define VDO_1ST_VSN vsn(3, 0, 0)
+#define VDO_1ST_VSN vsn(2, 3, 0)
 cfg(allocation_vdo_use_compression_CFG, "vdo_use_compression", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_COMPRESSION, VDO_1ST_VSN, NULL, 0, NULL,
 	"Enables or disables compression when creating a VDO volume.\n"
 	"Compression may be disabled if necessary to maximize performance\n"
@@ -615,10 +677,17 @@ cfg(allocation_vdo_use_compression_CFG, "vdo_use_compression", allocation_CFG_SE
 cfg(allocation_vdo_use_deduplication_CFG, "vdo_use_deduplication", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_DEDUPLICATION, VDO_1ST_VSN, NULL, 0, NULL,
 	"Enables or disables deduplication when creating a VDO volume.\n"
 	"Deduplication may be disabled in instances where data is not expected\n"
-	"to have good deduplication rates but compression is still desired.")
+	"to have good deduplication rates but compression is still desired.\n")
 
-cfg(allocation_vdo_emulate_512_sectors_CFG, "vdo_emulate_512_sectors", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_EMULATE_512_SECTORS, VDO_1ST_VSN, NULL, 0, NULL,
-	"Specifies that the VDO volume is to emulate a 512 byte block device.\n")
+cfg(allocation_vdo_use_metadata_hints_CFG, "vdo_use_metadata_hints", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_METADATA_HINTS, VDO_1ST_VSN, NULL, 0, NULL,
+	"Enables or disables whether VDO volume should tag its latency-critical\n"
+	"writes with the REQ_SYNC flag. Some device mapper targets such as dm-raid5\n"
+	"process writes with this flag at a higher priority.\n"
+	"Default is enabled.\n")
+
+cfg(allocation_vdo_minimum_io_size_CFG, "vdo_minimum_io_size", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_MINIMUM_IO_SIZE, VDO_1ST_VSN, NULL, 0, NULL,
+	"The minimum IO size for VDO volume to accept, in bytes.\n"
+	"Valid values are 512 or 4096. The recommended and default value is 4096.\n")
 
 cfg(allocation_vdo_block_map_cache_size_mb_CFG, "vdo_block_map_cache_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_BLOCK_MAP_CACHE_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,
 	"Specifies the amount of memory in MiB allocated for caching block map\n"
@@ -626,34 +695,25 @@ cfg(allocation_vdo_block_map_cache_size_mb_CFG, "vdo_block_map_cache_size_mb", a
 	"at least 128MiB and less than 16TiB. The cache must be at least 16MiB\n"
 	"per logical thread. Note that there is a memory overhead of 15%.\n")
 
-cfg(allocation_vdo_block_map_period_CFG, "vdo_block_map_period", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_BLOCK_MAP_PERIOD, VDO_1ST_VSN, NULL, 0, NULL,
-	"Tunes the quantity of block map updates that can accumulate\n"
-	"before cache pages are flushed to disk. The value must be\n"
-	"at least 1 and less then 16380.\n"
-	"A lower value means shorter recovery time but lower performance.\n")
+// vdo format --blockMapPeriod
+cfg(allocation_vdo_block_map_era_length_CFG, "vdo_block_map_period", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_BLOCK_MAP_ERA_LENGTH, VDO_1ST_VSN, NULL, 0, NULL,
+	"The speed with which the block map cache writes out modified block map pages.\n"
+	"A smaller era length is likely to reduce the amount time spent rebuilding,\n"
+	"at the cost of increased block map writes during normal operation.\n"
+	"The maximum and recommended value is 16380; the minimum value is 1.\n")
 
 cfg(allocation_vdo_check_point_frequency_CFG, "vdo_check_point_frequency", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_CHECK_POINT_FREQUENCY, VDO_1ST_VSN, NULL, 0, NULL,
 	"The default check point frequency for VDO volume.\n")
 
+// vdo format
 cfg(allocation_vdo_use_sparse_index_CFG, "vdo_use_sparse_index", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_SPARSE_INDEX, VDO_1ST_VSN, NULL, 0, NULL,
 	"Enables sparse indexing for VDO volume.\n")
 
+// vdo format
 cfg(allocation_vdo_index_memory_size_mb_CFG, "vdo_index_memory_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_INDEX_MEMORY_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,
 	"Specifies the amount of index memory in MiB for VDO volume.\n"
 	"The value must be at least 256MiB and at most 1TiB.\n")
 
-cfg(allocation_vdo_use_read_cache_CFG, "vdo_use_read_cache", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_USE_READ_CACHE, VDO_1ST_VSN, NULL, 0, NULL,
-	"Enables or disables the read cache within the VDO volume.\n"
-	"The cache should be enabled if write workloads are expected\n"
-	"to have high levels of deduplication, or for read intensive\n"
-	"workloads of highly compressible data.\n")
-
-cfg(allocation_vdo_read_cache_size_mb_CFG, "vdo_read_cache_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_READ_CACHE_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,
-	"Specifies the extra VDO volume read cache size in MiB.\n"
-	"This space is in addition to a system-defined minimum.\n"
-	"The value must be less then 16TiB and 1.12 MiB of memory\n"
-	"will be used per MiB of read cache specified, per bio thread.\n")
-
 cfg(allocation_vdo_slab_size_mb_CFG, "vdo_slab_size_mb", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_SLAB_SIZE_MB, VDO_1ST_VSN, NULL, 0, NULL,
 	"Specifies the size in MiB of the increment by which a VDO is grown.\n"
 	"Using a smaller size constrains the total maximum physical size\n"
@@ -684,7 +744,7 @@ cfg(allocation_vdo_hash_zone_threads_CFG, "vdo_hash_zone_threads", allocation_CF
 	"processing based on the hash value computed from the block data.\n"
 	"The value must be at in range [0..100].\n"
 	"vdo_hash_zone_threads, vdo_logical_threads and vdo_physical_threads must be\n"
-	"either all zero or all non-zero.")
+	"either all zero or all non-zero.\n")
 
 cfg(allocation_vdo_logical_threads_CFG, "vdo_logical_threads", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_LOGICAL_THREADS, VDO_1ST_VSN, NULL, 0, NULL,
 	"Specifies the number of threads across which to subdivide parts of the VDO\n"
@@ -712,6 +772,16 @@ cfg(allocation_vdo_write_policy_CFG, "vdo_write_policy", allocation_CFG_SECTION,
 	"async - Writes are acknowledged after data has been cached for writing to stable storage.\n"
 	"        Data which has not been flushed is not guaranteed to persist in this mode.\n")
 
+cfg(allocation_vdo_max_discard_CFG, "vdo_max_discard", allocation_CFG_SECTION, CFG_PROFILABLE | CFG_PROFILABLE_METADATA | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_VDO_MAX_DISCARD, VDO_1ST_VSN, NULL, 0, NULL,
+	"Specified te maximum size of discard bio accepted, in 4096 byte blocks.\n"
+	"I/O requests to a VDO volume are normally split into 4096-byte blocks,\n"
+	"and processed up to 2048 at a time. However, discard requests to a VDO volume\n"
+	"can be automatically split to a larger size, up to <max discard> 4096-byte blocks\n"
+	"in a single bio, and are limited to 1500 at a time.\n"
+	"Increasing this value may provide better overall performance, at the cost of\n"
+	"increased latency for the individual discard requests.\n"
+	"The default and minimum is 1. The maximum is UINT_MAX / 4096.\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"
@@ -780,7 +850,7 @@ cfg(log_level_CFG, "level", log_CFG_SECTION, 0, CFG_TYPE_INT, DEFAULT_LOGLEVEL,
 	"There are 6 syslog-like log levels currently in use: 2 to 7 inclusive.\n"
 	"7 is the most verbose (LOG_DEBUG).\n")
 
-cfg(log_indent_CFG, "indent", log_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_INDENT, vsn(1, 0, 0), NULL, 0, NULL,
+cfg(log_indent_CFG, "indent", log_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_INDENT, vsn(1, 0, 0), NULL, 0, NULL,
 	"Indent messages according to their severity.\n")
 
 cfg(log_command_names_CFG, "command_names", log_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_CMD_NAME, vsn(1, 0, 0), NULL, 0, NULL,
@@ -806,6 +876,14 @@ cfg_array(log_debug_classes_CFG, "debug_classes", log_CFG_SECTION, CFG_ALLOW_EMP
 	"available: memory, devices, io, activation, allocation,\n"
 	"metadata, cache, locking, lvmpolld. Use \"all\" to see everything.\n")
 
+cfg_array(log_debug_file_fields_CFG, "debug_file_fields", log_CFG_SECTION, CFG_DEFAULT_COMMENTED | CFG_ADVANCED, CFG_TYPE_STRING, "#Stime#Scommand#Sfileline#Smessage", vsn(2, 3, 2), NULL, 0, NULL,
+	  "The fields included in debug output written to log file.\n"
+	  "Use \"all\" to include everything (the default).\n")
+
+cfg_array(log_debug_output_fields_CFG, "debug_output_fields", log_CFG_SECTION, CFG_DEFAULT_COMMENTED | CFG_ADVANCED, CFG_TYPE_STRING, "#Stime#Scommand#Sfileline#Smessage", vsn(2, 3, 2), NULL, 0, NULL,
+	  "The fields included in debug output written to stderr.\n"
+	  "Use \"all\" to include everything (the default).\n")
+
 cfg(backup_backup_CFG, "backup", backup_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_BACKUP_ENABLED, vsn(1, 0, 0), NULL, 0, NULL,
 	"Maintain a backup of the current metadata configuration.\n"
 	"Think very hard before turning this off!\n")
@@ -861,16 +939,16 @@ cfg(global_activation_CFG, "activation", global_CFG_SECTION, 0, CFG_TYPE_BOOL, D
 	"is not present in the kernel, disabling this should suppress\n"
 	"the error messages.\n")
 
-cfg(global_fallback_to_lvm1_CFG, "fallback_to_lvm1", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, 0, vsn(1, 0, 18), NULL, vsn(3, 0, 0), NULL,
+cfg(global_fallback_to_lvm1_CFG, "fallback_to_lvm1", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, 0, vsn(1, 0, 18), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
-cfg(global_format_CFG, "format", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_FORMAT, vsn(1, 0, 0), NULL, vsn(3, 0, 0), NULL,
+cfg(global_format_CFG, "format", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_FORMAT, vsn(1, 0, 0), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
-cfg_array(global_format_libraries_CFG, "format_libraries", global_CFG_SECTION, CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 0), NULL, vsn(3, 0, 0), NULL,
+cfg_array(global_format_libraries_CFG, "format_libraries", global_CFG_SECTION, CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 0), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.")
 
-cfg_array(global_segment_libraries_CFG, "segment_libraries", global_CFG_SECTION, CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 18), NULL, 0, NULL, NULL)
+cfg_array(global_segment_libraries_CFG, "segment_libraries", global_CFG_SECTION, CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 18), NULL, vsn(2, 3, 3), NULL, NULL)
 
 cfg(global_proc_CFG, "proc", global_CFG_SECTION, CFG_ADVANCED, CFG_TYPE_STRING, DEFAULT_PROC_DIR, vsn(1, 0, 0), NULL, 0, NULL,
 	"Location of proc filesystem.\n")
@@ -878,16 +956,16 @@ cfg(global_proc_CFG, "proc", global_CFG_SECTION, CFG_ADVANCED, CFG_TYPE_STRING,
 cfg(global_etc_CFG, "etc", global_CFG_SECTION, 0, CFG_TYPE_STRING, DEFAULT_ETC_DIR, vsn(2, 2, 117), "@CONFDIR@", 0, NULL,
 	"Location of /etc system configuration directory.\n")
 
-cfg(global_locking_type_CFG, "locking_type", global_CFG_SECTION, 0, CFG_TYPE_INT, 1, vsn(1, 0, 0), NULL, vsn(3, 0, 0), NULL,
+cfg(global_locking_type_CFG, "locking_type", global_CFG_SECTION, 0, CFG_TYPE_INT, 1, vsn(1, 0, 0), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.")
 
 cfg(global_wait_for_locks_CFG, "wait_for_locks", global_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_WAIT_FOR_LOCKS, vsn(2, 2, 50), NULL, 0, NULL,
 	"When disabled, fail if a lock request would block.\n")
 
-cfg(global_fallback_to_clustered_locking_CFG, "fallback_to_clustered_locking", global_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_FALLBACK_TO_CLUSTERED_LOCKING, vsn(2, 2, 42), NULL, vsn(3, 0, 0), NULL,
+cfg(global_fallback_to_clustered_locking_CFG, "fallback_to_clustered_locking", global_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_FALLBACK_TO_CLUSTERED_LOCKING, vsn(2, 2, 42), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
-cfg(global_fallback_to_local_locking_CFG, "fallback_to_local_locking", global_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_FALLBACK_TO_LOCAL_LOCKING, vsn(2, 2, 42), NULL, vsn(3, 0, 0), NULL,
+cfg(global_fallback_to_local_locking_CFG, "fallback_to_local_locking", global_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_FALLBACK_TO_LOCAL_LOCKING, vsn(2, 2, 42), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
 cfg(global_locking_dir_CFG, "locking_dir", global_CFG_SECTION, 0, CFG_TYPE_STRING, DEFAULT_LOCK_DIR, vsn(1, 0, 0), "@DEFAULT_LOCK_DIR@", 0, NULL,
@@ -907,7 +985,7 @@ cfg(global_prioritise_write_locks_CFG, "prioritise_write_locks", global_CFG_SECT
 cfg(global_library_dir_CFG, "library_dir", global_CFG_SECTION, CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 0), NULL, 0, NULL,
 	"Search this directory first for shared libraries.\n")
 
-cfg(global_locking_library_CFG, "locking_library", global_CFG_SECTION, CFG_ALLOW_EMPTY | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_LOCKING_LIB, vsn(1, 0, 0), NULL, vsn(3, 0, 0), NULL,
+cfg(global_locking_library_CFG, "locking_library", global_CFG_SECTION, CFG_ALLOW_EMPTY | CFG_DEFAULT_COMMENTED, CFG_TYPE_STRING, DEFAULT_LOCKING_LIB, vsn(1, 0, 0), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
 cfg(global_abort_on_internal_errors_CFG, "abort_on_internal_errors", global_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_ABORT_ON_INTERNAL_ERRORS, vsn(2, 2, 57), NULL, 0, NULL,
@@ -950,6 +1028,16 @@ cfg(global_mirror_segtype_default_CFG, "mirror_segtype_default", global_CFG_SECT
 	"    fashion in a cluster.\n"
 	"#\n")
 
+cfg(global_support_mirrored_mirror_log_CFG, "support_mirrored_mirror_log", global_CFG_SECTION, 0, CFG_TYPE_BOOL, 0, vsn(2, 3, 2), NULL, 0, NULL,
+	"Enable mirrored 'mirror' log type for testing.\n"
+	"#\n"
+	"This type is deprecated to create or convert to but can\n"
+	"be enabled to test that activation of existing mirrored\n"
+	"logs and conversion to disk/core works.\n"
+	"#\n"
+	"Not supported for regular operation!\n"
+	"\n")
+
 cfg(global_raid10_segtype_default_CFG, "raid10_segtype_default", global_CFG_SECTION, 0, CFG_TYPE_STRING, DEFAULT_RAID10_SEGTYPE, vsn(2, 2, 99), "@DEFAULT_RAID10_SEGTYPE@", 0, NULL,
 	"The segment type used by the -i -m combination.\n"
 	"The --type raid10|mirror option overrides this setting.\n"
@@ -994,12 +1082,24 @@ cfg(global_lvdisplay_shows_full_device_path_CFG, "lvdisplay_shows_full_device_pa
 	"Previously this was always shown as /dev/vgname/lvname even when that\n"
 	"was never a valid path in the /dev filesystem.\n")
 
-cfg(global_use_lvmetad_CFG, "use_lvmetad", global_CFG_SECTION, 0, CFG_TYPE_BOOL, 0, vsn(2, 2, 93), 0, vsn(3, 0, 0), NULL,
+cfg(global_event_activation_CFG, "event_activation", global_CFG_SECTION, 0, CFG_TYPE_BOOL, 1, vsn(2, 3, 1), 0, 0, NULL,
+	"Activate LVs based on system-generated device events.\n"
+	"When a device appears on the system, a system-generated event runs\n"
+	"the pvscan command to activate LVs if the new PV completes the VG.\n"
+	"Use auto_activation_volume_list to select which LVs should be\n"
+	"activated from these events (the default is all.)\n"
+	"When event_activation is disabled, the system will generally run\n"
+	"a direct activation command to activate LVs in complete VGs.\n")
+
+cfg(global_use_lvmetad_CFG, "use_lvmetad", global_CFG_SECTION, 0, CFG_TYPE_BOOL, 0, vsn(2, 2, 93), 0, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
-cfg(global_lvmetad_update_wait_time_CFG, "lvmetad_update_wait_time", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(2, 2, 151), NULL, vsn(3, 0, 0), NULL,
+cfg(global_lvmetad_update_wait_time_CFG, "lvmetad_update_wait_time", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(2, 2, 151), NULL, vsn(2, 3, 0), NULL,
 	"This setting is no longer used.\n")
 
+cfg(global_use_aio_CFG, "use_aio", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_USE_AIO, vsn(2, 2, 183), NULL, 0, NULL,
+	"Use async I/O when reading and writing devices.\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"
@@ -1162,6 +1262,14 @@ cfg(global_notify_dbus_CFG, "notify_dbus", global_CFG_SECTION, 0, CFG_TYPE_BOOL,
 	"When enabled, an LVM command that changes PVs, changes VG metadata,\n"
 	"or changes the activation state of an LV will send a notification.\n")
 
+cfg(global_io_memory_size_CFG, "io_memory_size", global_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_IO_MEMORY_SIZE_KB, vsn(2, 3, 2), NULL, 0, NULL,
+	"The amount of memory in KiB that LVM allocates to perform disk io.\n"
+	"LVM performance may benefit from more io memory when there are many\n"
+	"disks or VG metadata is large. Increasing this size may be necessary\n"
+	"when a single copy of VG metadata is larger than the current setting.\n"
+	"This value should usually not be decreased from the default; setting\n"
+	"it too low can result in lvm failing to read VGs.\n")
+
 cfg(activation_udev_sync_CFG, "udev_sync", activation_CFG_SECTION, 0, CFG_TYPE_BOOL, DEFAULT_UDEV_SYNC, vsn(2, 2, 51), NULL, 0, NULL,
 	"Use udev notifications to synchronize udev and LVM.\n"
 	"The --nodevsync option overrides this setting.\n"
@@ -1591,12 +1699,19 @@ cfg(metadata_vgmetadatacopies_CFG, "vgmetadatacopies", metadata_CFG_SECTION, CFG
 	"and allows you to control which metadata areas are used at the\n"
 	"individual PV level using pvchange --metadataignore y|n.\n")
 
-cfg(metadata_pvmetadatasize_CFG, "pvmetadatasize", metadata_CFG_SECTION, CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_PVMETADATASIZE, vsn(1, 0, 0), NULL, 0, NULL,
-	"Approximate number of sectors to use for each metadata copy.\n"
-	"VGs with large numbers of PVs or LVs, or VGs containing complex LV\n"
-	"structures, may need additional space for VG metadata. The metadata\n"
-	"areas are treated as circular buffers, so unused space becomes filled\n"
-	"with an archive of the most recent previous versions of the metadata.\n")
+cfg_runtime(metadata_pvmetadatasize_CFG, "pvmetadatasize", metadata_CFG_SECTION, CFG_DEFAULT_UNDEFINED, CFG_TYPE_INT, vsn(1, 0, 0), 0, NULL,
+	"The default size of the metadata area in units of 512 byte sectors.\n"
+	"The metadata area begins at an offset of the page size from the start\n"
+	"of the device. The first PE is by default at 1 MiB from the start of\n"
+	"the device. The space between these is the default metadata area size.\n"
+	"The actual size of the metadata area may be larger than what is set\n"
+	"here due to default_data_alignment making the first PE a MiB multiple.\n"
+	"The metadata area begins with a 512 byte header and is followed by a\n"
+	"circular buffer used for VG metadata text. The maximum size of the VG\n"
+	"metadata is about half the size of the metadata buffer. VGs with large\n"
+	"numbers of PVs or LVs, or VGs containing complex LV structures, may need\n"
+	"additional space for VG metadata. The --metadatasize option overrides\n"
+	"this setting.\n")
 
 cfg(metadata_pvmetadataignore_CFG, "pvmetadataignore", metadata_CFG_SECTION, CFG_ADVANCED | CFG_DEFAULT_COMMENTED, CFG_TYPE_BOOL, DEFAULT_PVMETADATAIGNORE, vsn(2, 2, 69), NULL, 0, NULL,
 	"Ignore metadata areas on a new PV.\n"
@@ -1606,14 +1721,14 @@ cfg(metadata_pvmetadataignore_CFG, "pvmetadataignore", metadata_CFG_SECTION, CFG
 
 cfg(metadata_stripesize_CFG, "stripesize", metadata_CFG_SECTION, CFG_ADVANCED | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, DEFAULT_STRIPESIZE, vsn(1, 0, 0), NULL, 0, NULL, NULL)
 
-cfg_array(metadata_dirs_CFG, "dirs", metadata_CFG_SECTION, CFG_ADVANCED | CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 0), NULL, vsn(3, 0, 0), NULL,
+cfg_array(metadata_dirs_CFG, "dirs", metadata_CFG_SECTION, CFG_ADVANCED | CFG_DEFAULT_UNDEFINED, CFG_TYPE_STRING, NULL, vsn(1, 0, 0), NULL, vsn(2, 3, 0), NULL,
 	  "This setting is no longer used.\n")
 
-cfg_section(metadata_disk_areas_CFG_SUBSECTION, "disk_areas", metadata_CFG_SECTION, CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, vsn(1, 0, 0), vsn(3, 0, 0), NULL, NULL)
-cfg_section(disk_area_CFG_SUBSECTION, "disk_area", metadata_disk_areas_CFG_SUBSECTION, CFG_NAME_VARIABLE | CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, vsn(1, 0, 0), vsn(3, 0, 0), NULL, NULL)
-cfg(disk_area_start_sector_CFG, "start_sector", disk_area_CFG_SUBSECTION, CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(1, 0, 0), NULL, vsn(3, 0, 0), NULL, NULL)
-cfg(disk_area_size_CFG, "size", disk_area_CFG_SUBSECTION, CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(1, 0, 0), NULL, vsn(3, 0, 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, vsn(3, 0, 0), NULL, NULL)
+cfg_section(metadata_disk_areas_CFG_SUBSECTION, "disk_areas", metadata_CFG_SECTION, CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, vsn(1, 0, 0), vsn(2, 3, 0), NULL, NULL)
+cfg_section(disk_area_CFG_SUBSECTION, "disk_area", metadata_disk_areas_CFG_SUBSECTION, CFG_NAME_VARIABLE | CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, vsn(1, 0, 0), vsn(2, 3, 0), NULL, NULL)
+cfg(disk_area_start_sector_CFG, "start_sector", disk_area_CFG_SUBSECTION, CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(1, 0, 0), NULL, vsn(2, 3, 0), NULL, NULL)
+cfg(disk_area_size_CFG, "size", disk_area_CFG_SUBSECTION, CFG_UNSUPPORTED | CFG_DEFAULT_COMMENTED, CFG_TYPE_INT, 0, vsn(1, 0, 0), NULL, vsn(2, 3, 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, vsn(2, 3, 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"

lib/config/defaults.h

@@ -18,8 +18,18 @@
 
 #include "device_mapper/vdo/vdo_limits.h"
 
-#define DEFAULT_PE_ALIGN 2048
-#define DEFAULT_PE_ALIGN_OLD 128
+
+/*
+ * By default the first PE is placed at 1 MiB.
+ *
+ * If default_data_alignment is 2, then the first PE
+ * is placed at 2 * 1 MiB.
+ *
+ * If default_data_alignment is 3, then the first PE
+ * is placed at 3 * 1 MiB.
+ */
+#define FIRST_PE_AT_ONE_MB_IN_SECTORS 2048  /* 1 MiB in 512 byte sectors */
+#define FIRST_PE_AT_ONE_MB_IN_MB         1
 
 #define DEFAULT_ARCHIVE_ENABLED 1
 #define DEFAULT_BACKUP_ENABLED 1
@@ -60,6 +70,7 @@
 #define DEFAULT_METADATA_READ_ONLY 0
 #define DEFAULT_LVDISPLAY_SHOWS_FULL_DEVICE_PATH 0
 #define DEFAULT_UNKNOWN_DEVICE_NAME "[unknown]"
+#define DEFAULT_USE_AIO 1
 
 #define DEFAULT_SANLOCK_LV_EXTEND_MB 256
 
@@ -113,6 +124,8 @@
 #define DEFAULT_THIN_POOL_CHUNK_SIZE_POLICY "generic"
 #define DEFAULT_THIN_POOL_CHUNK_SIZE	    64	  /* KB */
 #define DEFAULT_THIN_POOL_CHUNK_SIZE_PERFORMANCE 512 /* KB */
+/* Chunk size big enough it no longer needs jump by power-of-2 */
+#define DEFAULT_THIN_POOL_CHUNK_SIZE_ALIGNED 1024 /* KB */
 #define DEFAULT_THIN_POOL_DISCARDS "passdown"
 #define DEFAULT_THIN_POOL_ZERO 1
 #define DEFAULT_POOL_METADATA_SPARE 1 /* thin + cache */
@@ -142,23 +155,23 @@
 /* VDO defaults */
 #define DEFAULT_VDO_USE_COMPRESSION	(true)
 #define DEFAULT_VDO_USE_DEDUPLICATION	(true)
-#define DEFAULT_VDO_EMULATE_512_SECTORS	(false)
+#define DEFAULT_VDO_USE_METADATA_HINTS	(true)
+#define DEFAULT_VDO_MINIMUM_IO_SIZE	(4096)
 #define DEFAULT_VDO_BLOCK_MAP_CACHE_SIZE_MB	(DM_VDO_BLOCK_MAP_CACHE_SIZE_MINIMUM_MB)
-#define DEFAULT_VDO_BLOCK_MAP_PERIOD	(DM_VDO_BLOCK_MAP_PERIOD_MAXIMUM)
+#define DEFAULT_VDO_BLOCK_MAP_ERA_LENGTH (DM_VDO_BLOCK_MAP_ERA_LENGTH_MAXIMUM)
 #define DEFAULT_VDO_USE_SPARSE_INDEX	(false)
 #define DEFAULT_VDO_CHECK_POINT_FREQUENCY	(0)
 #define DEFAULT_VDO_INDEX_MEMORY_SIZE_MB	(DM_VDO_INDEX_MEMORY_SIZE_MINIMUM_MB)
-#define DEFAULT_VDO_USE_READ_CACHE	(false)
-#define DEFAULT_VDO_READ_CACHE_SIZE_MB	(0)
 #define DEFAULT_VDO_SLAB_SIZE_MB	(2 * 1024)  // 2GiB ... 19 slabbits
 #define DEFAULT_VDO_ACK_THREADS		(1)
-#define DEFAULT_VDO_BIO_THREADS		(1)
+#define DEFAULT_VDO_BIO_THREADS		(4)
 #define DEFAULT_VDO_BIO_ROTATION	(64)
 #define DEFAULT_VDO_CPU_THREADS		(2)
 #define DEFAULT_VDO_HASH_ZONE_THREADS	(1)
 #define DEFAULT_VDO_LOGICAL_THREADS	(1)
 #define DEFAULT_VDO_PHYSICAL_THREADS	(1)
 #define DEFAULT_VDO_WRITE_POLICY	"auto"
+#define DEFAULT_VDO_MAX_DISCARD		(DM_VDO_MAX_DISCARD_MINIMUM)
 
 #define DEFAULT_VDO_FORMAT_OPTIONS_CONFIG "#S" ""
 /*
@@ -179,7 +192,6 @@
 #define DEFAULT_RECORD_LVS_HISTORY 0
 #define DEFAULT_LVS_HISTORY_RETENTION_TIME 0
 #define DEFAULT_PVMETADATAIGNORE 0
-#define DEFAULT_PVMETADATASIZE 255
 #define DEFAULT_PVMETADATACOPIES 1
 #define DEFAULT_VGMETADATACOPIES 0
 #define DEFAULT_LABELSECTOR UINT64_C(1)
@@ -211,7 +223,7 @@
 #define DEFAULT_VERBOSE 0
 #define DEFAULT_SILENT 0
 #define DEFAULT_LOGLEVEL 0
-#define DEFAULT_INDENT 1
+#define DEFAULT_INDENT 0
 #define DEFAULT_ABORT_ON_INTERNAL_ERRORS 0
 #define DEFAULT_UNITS "r"
 #define DEFAULT_SUFFIX 1
@@ -264,7 +276,7 @@
 #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,cachevol,pool_lv,origin,data_percent,metadata_percent,move_pv,copy_percent,mirror_log,convert_lv,lv_uuid,lv_profile"
+#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"
 #define DEFAULT_PVS_COLS_VERB "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,dev_size,pv_uuid"
 #define DEFAULT_SEGS_COLS_VERB "lv_name,vg_name,lv_attr,seg_start,seg_size,stripes,segtype,stripesize,chunksize"
@@ -300,4 +312,12 @@
 #define DEFAULT_VDO_POOL_AUTOEXTEND_THRESHOLD 100
 #define DEFAULT_VDO_POOL_AUTOEXTEND_PERCENT 20
 
+#define DEFAULT_SCAN_LVS 0
+
+#define DEFAULT_HINTS "all"
+
+#define DEFAULT_IO_MEMORY_SIZE_KB 8192
+
+#define DEFAULT_MD_COMPONENT_CHECKS "auto"
+
 #endif				/* _LVM_DEFAULTS_H */

lib/device/bcache.c

@@ -12,8 +12,6 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#define _GNU_SOURCE
-
 #include "lib/device/bcache.h"
 
 #include "base/data-struct/radix-tree.h"
@@ -31,7 +29,6 @@
 #include <libaio.h>
 #include <unistd.h>
 #include <linux/fs.h>
-#include <sys/ioctl.h>
 #include <sys/user.h>
 
 #define SECTOR_SHIFT 9L
@@ -158,6 +155,10 @@ static void _async_destroy(struct io_engine *ioe)
 	free(e);
 }
 
+static int _last_byte_fd;
+static uint64_t _last_byte_offset;
+static int _last_byte_sector_size;
+
 static bool _async_issue(struct io_engine *ioe, enum dir d, int fd,
 			 sector_t sb, sector_t se, void *data, void *context)
 {
@@ -165,12 +166,100 @@ static bool _async_issue(struct io_engine *ioe, enum dir d, int fd,
 	struct iocb *cb_array[1];
 	struct control_block *cb;
 	struct async_engine *e = _to_async(ioe);
+	sector_t offset;
+	sector_t nbytes;
+	sector_t limit_nbytes;
+	sector_t orig_nbytes;
+	sector_t extra_nbytes = 0;
 
 	if (((uintptr_t) data) & e->page_mask) {
 		log_warn("misaligned data buffer");
 		return false;
 	}
 
+	offset = sb << SECTOR_SHIFT;
+	nbytes = (se - sb) << SECTOR_SHIFT;
+
+	/*
+	 * If bcache block goes past where lvm wants to write, then clamp it.
+	 */
+	if ((d == DIR_WRITE) && _last_byte_offset && (fd == _last_byte_fd)) {
+		if (offset > _last_byte_offset) {
+			log_error("Limit write at %llu len %llu beyond last byte %llu",
+				  (unsigned long long)offset,
+				  (unsigned long long)nbytes,
+				  (unsigned long long)_last_byte_offset);
+			return false;
+		}
+
+		/*
+		 * If the bcache block offset+len goes beyond where lvm is
+		 * intending to write, then reduce the len being written
+		 * (which is the bcache block size) so we don't write past
+		 * the limit set by lvm.  If after applying the limit, the
+		 * resulting size is not a multiple of the sector size (512
+		 * or 4096) then extend the reduced size to be a multiple of
+		 * the sector size (we don't want to write partial sectors.)
+		 */
+		if (offset + nbytes > _last_byte_offset) {
+			limit_nbytes = _last_byte_offset - offset;
+
+			if (limit_nbytes % _last_byte_sector_size) {
+				extra_nbytes = _last_byte_sector_size - (limit_nbytes % _last_byte_sector_size);
+
+				/*
+				 * adding extra_nbytes to the reduced nbytes (limit_nbytes)
+				 * should make the final write size a multiple of the
+				 * sector size.  This should never result in a final size
+				 * larger than the bcache block size (as long as the bcache
+				 * block size is a multiple of the sector size).
+				 */
+				if (limit_nbytes + extra_nbytes > nbytes) {
+					log_warn("Skip extending write at %llu len %llu limit %llu extra %llu sector_size %llu",
+						 (unsigned long long)offset,
+						 (unsigned long long)nbytes,
+						 (unsigned long long)limit_nbytes,
+						 (unsigned long long)extra_nbytes,
+						 (unsigned long long)_last_byte_sector_size);
+					extra_nbytes = 0;
+				}
+			}
+
+			orig_nbytes = nbytes;
+
+			if (extra_nbytes) {
+				log_debug("Limit write at %llu len %llu to len %llu rounded to %llu",
+					  (unsigned long long)offset,
+					  (unsigned long long)nbytes,
+					  (unsigned long long)limit_nbytes,
+					  (unsigned long long)(limit_nbytes + extra_nbytes));
+				nbytes = limit_nbytes + extra_nbytes;
+			} else {
+				log_debug("Limit write at %llu len %llu to len %llu",
+					  (unsigned long long)offset,
+					  (unsigned long long)nbytes,
+					  (unsigned long long)limit_nbytes);
+				nbytes = limit_nbytes;
+			}
+
+			/*
+			 * This shouldn't happen, the reduced+extended
+			 * nbytes value should never be larger than the
+			 * bcache block size.
+			 */
+			if (nbytes > orig_nbytes) {
+				log_error("Invalid adjusted write at %llu len %llu adjusted %llu limit %llu extra %llu sector_size %llu",
+					  (unsigned long long)offset,
+					  (unsigned long long)orig_nbytes,
+					  (unsigned long long)nbytes,
+					  (unsigned long long)limit_nbytes,
+					  (unsigned long long)extra_nbytes,
+					  (unsigned long long)_last_byte_sector_size);
+				return false;
+			}
+		}
+	}
+
 	cb = _cb_alloc(e->cbs, context);
 	if (!cb) {
 		log_warn("couldn't allocate control block");
@@ -181,10 +270,22 @@ static bool _async_issue(struct io_engine *ioe, enum dir d, int fd,
 
 	cb->cb.aio_fildes = (int) fd;
 	cb->cb.u.c.buf = data;
-	cb->cb.u.c.offset = sb << SECTOR_SHIFT;
-	cb->cb.u.c.nbytes = (se - sb) << SECTOR_SHIFT;
+	cb->cb.u.c.offset = offset;
+	cb->cb.u.c.nbytes = nbytes;
 	cb->cb.aio_lio_opcode = (d == DIR_READ) ? IO_CMD_PREAD : IO_CMD_PWRITE;
 
+#if 0
+	if (d == DIR_READ) {
+		log_debug("io R off %llu bytes %llu",
+			  (unsigned long long)cb->cb.u.c.offset,
+			  (unsigned long long)cb->cb.u.c.nbytes);
+	} else {
+		log_debug("io W off %llu bytes %llu",
+			  (unsigned long long)cb->cb.u.c.offset,
+			  (unsigned long long)cb->cb.u.c.nbytes);
+	}
+#endif
+
 	cb_array[0] = &cb->cb;
 	do {
 		r = io_submit(e->aio_context, 1, cb_array);
@@ -198,7 +299,15 @@ static bool _async_issue(struct io_engine *ioe, enum dir d, int fd,
 	return true;
 }
 
-#define MAX_IO 1024
+/*
+ * MAX_IO is returned to the layer above via bcache_max_prefetches() which
+ * tells the caller how many devices to submit io for concurrently.  There will
+ * be an open file descriptor for each of these, so keep it low enough to avoid
+ * reaching the default max open file limit (1024) when there are over 1024
+ * devices being scanned.
+ */
+
+#define MAX_IO 256
 #define MAX_EVENT 64
 
 static bool _async_wait(struct io_engine *ioe, io_complete_fn fn)
@@ -265,7 +374,7 @@ struct io_engine *create_async_io_engine(void)
 	e->aio_context = 0;
 	r = io_setup(MAX_IO, &e->aio_context);
 	if (r < 0) {
-		log_warn("io_setup failed");
+		log_debug("io_setup failed %d", r);
 		free(e);
 		return NULL;
 	}
@@ -308,8 +417,11 @@ static void _sync_destroy(struct io_engine *ioe)
 static bool _sync_issue(struct io_engine *ioe, enum dir d, int fd,
                         sector_t sb, sector_t se, void *data, void *context)
 {
-        int r;
-        uint64_t len = (se - sb) * 512, where;
+	int rv;
+	off_t off;
+	uint64_t where;
+	uint64_t pos = 0;
+	uint64_t len = (se - sb) * 512;
 	struct sync_engine *e = _to_sync(ioe);
 	struct sync_io *io = malloc(sizeof(*io));
 	if (!io) {
@@ -318,32 +430,137 @@ static bool _sync_issue(struct io_engine *ioe, enum dir d, int fd,
 	}
 
 	where = sb * 512;
-	r = lseek(fd, where, SEEK_SET);
-	if (r < 0) {
-        	log_warn("unable to seek to position %llu", (unsigned long long) where);
-        	return false;
+	off = lseek(fd, where, SEEK_SET);
+	if (off == (off_t) -1) {
+		log_warn("Device seek error %d for offset %llu", errno, (unsigned long long)where);
+		free(io);
+		return false;
+	}
+	if (off != (off_t) where) {
+		log_warn("Device seek failed for offset %llu", (unsigned long long)where);
+		free(io);
+		return false;
 	}
 
-	while (len) {
-        	do {
-                	if (d == DIR_READ)
-                                r = read(fd, data, len);
-                        else
-                                r = write(fd, data, len);
+	/*
+	 * If bcache block goes past where lvm wants to write, then clamp it.
+	 */
+	if ((d == DIR_WRITE) && _last_byte_offset && (fd == _last_byte_fd)) {
+		uint64_t offset = where;
+		uint64_t nbytes = len;
+		sector_t limit_nbytes = 0;
+		sector_t extra_nbytes = 0;
+		sector_t orig_nbytes = 0;
 
-        	} while ((r < 0) && ((r == EINTR) || (r == EAGAIN)));
+		if (offset > _last_byte_offset) {
+			log_error("Limit write at %llu len %llu beyond last byte %llu",
+				  (unsigned long long)offset,
+				  (unsigned long long)nbytes,
+				  (unsigned long long)_last_byte_offset);
+			free(io);
+			return false;
+		}
 
-        	if (r < 0) {
-                	log_warn("io failed %d", r);
-                	return false;
-        	}
+		if (offset + nbytes > _last_byte_offset) {
+			limit_nbytes = _last_byte_offset - offset;
 
-                len -= r;
+			if (limit_nbytes % _last_byte_sector_size) {
+				extra_nbytes = _last_byte_sector_size - (limit_nbytes % _last_byte_sector_size);
+
+				/*
+				 * adding extra_nbytes to the reduced nbytes (limit_nbytes)
+				 * should make the final write size a multiple of the
+				 * sector size.  This should never result in a final size
+				 * larger than the bcache block size (as long as the bcache
+				 * block size is a multiple of the sector size).
+				 */
+				if (limit_nbytes + extra_nbytes > nbytes) {
+					log_warn("Skip extending write at %llu len %llu limit %llu extra %llu sector_size %llu",
+						 (unsigned long long)offset,
+						 (unsigned long long)nbytes,
+						 (unsigned long long)limit_nbytes,
+						 (unsigned long long)extra_nbytes,
+						 (unsigned long long)_last_byte_sector_size);
+					extra_nbytes = 0;
+				}
+			}
+
+			orig_nbytes = nbytes;
+
+			if (extra_nbytes) {
+				log_debug("Limit write at %llu len %llu to len %llu rounded to %llu",
+					  (unsigned long long)offset,
+					  (unsigned long long)nbytes,
+					  (unsigned long long)limit_nbytes,
+					  (unsigned long long)(limit_nbytes + extra_nbytes));
+				nbytes = limit_nbytes + extra_nbytes;
+			} else {
+				log_debug("Limit write at %llu len %llu to len %llu",
+					  (unsigned long long)offset,
+					  (unsigned long long)nbytes,
+					  (unsigned long long)limit_nbytes);
+				nbytes = limit_nbytes;
+			}
+
+			/*
+			 * This shouldn't happen, the reduced+extended
+			 * nbytes value should never be larger than the
+			 * bcache block size.
+			 */
+			if (nbytes > orig_nbytes) {
+				log_error("Invalid adjusted write at %llu len %llu adjusted %llu limit %llu extra %llu sector_size %llu",
+					  (unsigned long long)offset,
+					  (unsigned long long)orig_nbytes,
+					  (unsigned long long)nbytes,
+					  (unsigned long long)limit_nbytes,
+					  (unsigned long long)extra_nbytes,
+					  (unsigned long long)_last_byte_sector_size);
+				return false;
+			}
+		}
+
+		where = offset;
+		len = nbytes;
 	}
 
-	if (len) {
-        	log_warn("short io %u bytes remaining", (unsigned) len);
+	while (pos < len) {
+		if (d == DIR_READ)
+			rv = read(fd, (char *)data + pos, len - pos);
+		else
+			rv = write(fd, (char *)data + pos, len - pos);
+
+		if (rv == -1 && errno == EINTR)
+			continue;
+		if (rv == -1 && errno == EAGAIN)
+			continue;
+
+		if (!rv)
+			break;
+
+		if (rv < 0) {
+			if (d == DIR_READ)
+				log_debug("Device read error %d offset %llu len %llu", errno,
+					  (unsigned long long)(where + pos),
+					  (unsigned long long)(len - pos));
+			else
+				log_debug("Device write error %d offset %llu len %llu", errno,
+					  (unsigned long long)(where + pos),
+					  (unsigned long long)(len - pos));
+			free(io);
+			return false;
+		}
+		pos += rv;
+	}
+
+	if (pos < len) {
+		if (d == DIR_READ)
+			log_warn("Device read short %u bytes remaining", (unsigned)(len - pos));
+		else
+			log_warn("Device write short %u bytes remaining", (unsigned)(len - pos));
+		/*
+        	free(io);
         	return false;
+		*/
 	}
 
 
@@ -740,7 +957,7 @@ static struct block *_new_block(struct bcache *cache, int fd, block_address i, b
 					_writeback(cache, 16);  // FIXME: magic number
 				_wait_io(cache);
 			} else {
-				log_error("bcache no new blocks for fd %d index %u",
+				log_debug("bcache no new blocks for fd %d index %u",
 					  fd, (uint32_t) i);
 				return NULL;
 			}
@@ -749,7 +966,6 @@ static struct block *_new_block(struct bcache *cache, int fd, block_address i, b
 
 	if (b) {
 		dm_list_init(&b->list);
-		dm_list_init(&b->hash);
 		b->flags = 0;
 		b->fd = fd;
 		b->index = i;
@@ -871,6 +1087,11 @@ struct bcache *bcache_create(sector_t block_sectors, unsigned nr_cache_blocks,
 	unsigned max_io = engine->max_io(engine);
 	long pgsize = sysconf(_SC_PAGESIZE);
 
+	if (pgsize < 0) {
+		log_warn("WARNING: _SC_PAGESIZE returns negative value.");
+		return NULL;
+	}
+
 	if (!nr_cache_blocks) {
 		log_warn("bcache must have at least one cache block");
 		return NULL;
@@ -933,7 +1154,8 @@ void bcache_destroy(struct bcache *cache)
 	if (cache->nr_locked)
 		log_warn("some blocks are still locked");
 
-	bcache_flush(cache);
+	if (!bcache_flush(cache))
+		stack;
 	_wait_all(cache);
 	_exit_free_list(cache);
 	radix_tree_destroy(cache->rtree);
@@ -1154,9 +1376,63 @@ bool bcache_invalidate_fd(struct bcache *cache, int fd)
 	it.success = true;
 	it.it.visit = _invalidate_v;
 	radix_tree_iterate(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.fd), &it.it);
-	radix_tree_remove_prefix(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.fd));
+
+	if (it.success)
+		radix_tree_remove_prefix(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.fd));
+
 	return it.success;
 }
 
 //----------------------------------------------------------------
 
+static bool _abort_v(struct radix_tree_iterator *it,
+                     uint8_t *kb, uint8_t *ke, union radix_value v)
+{
+	struct block *b = v.ptr;
+
+	if (b->ref_count) {
+		log_fatal("bcache_abort: block (%d, %llu) still held",
+			 b->fd, (unsigned long long) b->index);
+		return true;
+	}
+
+	_unlink_block(b);
+	_free_block(b);
+
+	// We can't remove the block from the radix tree yet because
+	// we're in the middle of an iteration.
+	return true;
+}
+
+void bcache_abort_fd(struct bcache *cache, int fd)
+{
+        union key k;
+	struct radix_tree_iterator it;
+
+	k.parts.fd = fd;
+
+	it.visit = _abort_v;
+	radix_tree_iterate(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.fd), &it);
+	radix_tree_remove_prefix(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.fd));
+}
+
+//----------------------------------------------------------------
+
+void bcache_set_last_byte(struct bcache *cache, int fd, uint64_t offset, int sector_size)
+{
+	_last_byte_fd = fd;
+	_last_byte_offset = offset;
+	_last_byte_sector_size = sector_size;
+	if (!sector_size)
+		_last_byte_sector_size = 512;
+}
+
+void bcache_unset_last_byte(struct bcache *cache, int fd)
+{
+	if (_last_byte_fd == fd) {
+		_last_byte_fd = 0;
+		_last_byte_offset = 0;
+		_last_byte_sector_size = 0;
+	}
+}
+

lib/device/bcache.h

@@ -15,7 +15,6 @@
 #ifndef BCACHE_H
 #define BCACHE_H
 
-#include "configure.h"
 #include "device_mapper/all.h"
 
 #include <linux/fs.h>
@@ -62,7 +61,6 @@ struct block {
 
 	struct bcache *cache;
 	struct dm_list list;
-	struct dm_list hash;
 
 	unsigned flags;
 	unsigned ref_count;
@@ -146,6 +144,13 @@ bool bcache_invalidate(struct bcache *cache, int fd, block_address index);
  */
 bool bcache_invalidate_fd(struct bcache *cache, int fd);
 
+/*
+ * Call this function if flush, or invalidate fail and you do not
+ * wish to retry the writes.  This will throw away any dirty data
+ * not written.  If any blocks for fd are held, then it will call
+ * abort().
+ */
+void bcache_abort_fd(struct bcache *cache, int fd);
 
 //----------------------------------------------------------------
 // The next four functions are utilities written in terms of the above api.
@@ -159,6 +164,9 @@ bool bcache_write_bytes(struct bcache *cache, int fd, uint64_t start, size_t len
 bool bcache_zero_bytes(struct bcache *cache, int fd, uint64_t start, size_t len);
 bool bcache_set_bytes(struct bcache *cache, int fd, uint64_t start, size_t len, uint8_t val);
 
+void bcache_set_last_byte(struct bcache *cache, int fd, uint64_t offset, int sector_size);
+void bcache_unset_last_byte(struct bcache *cache, int fd);
+
 //----------------------------------------------------------------
 
 #endif

lib/device/dev-cache.c

@@ -15,6 +15,7 @@
 
 #include "base/memory/zalloc.h"
 #include "lib/misc/lib.h"
+#include "lib/device/dev-type.h"
 #include "lib/datastruct/btree.h"
 #include "lib/config/config.h"
 #include "lib/commands/toolcontext.h"
@@ -25,7 +26,6 @@
 #include <libudev.h>
 #endif
 #include <unistd.h>
-#include <sys/param.h>
 #include <dirent.h>
 
 struct dev_iter {
@@ -64,8 +64,6 @@ static int _insert(const char *path, const struct stat *info,
 /* Setup non-zero members of passed zeroed 'struct device' */
 static void _dev_init(struct device *dev)
 {
-	dev->phys_block_size = -1;
-	dev->block_size = -1;
 	dev->fd = -1;
 	dev->read_ahead = -1;
 
@@ -480,7 +478,7 @@ static struct device *_get_device_for_sysfs_dev_name_using_devno(const char *dev
 		return NULL;
 	}
 
-	devno = MKDEV((dev_t)major, (dev_t)minor);
+	devno = MKDEV(major, 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.
@@ -667,10 +665,9 @@ struct dm_list *dev_cache_get_dev_list_for_lvid(const char *lvid)
 
 void dev_cache_failed_path(struct device *dev, const char *path)
 {
-	struct device *dev_by_path;
 	struct dm_str_list *strl;
 
-	if ((dev_by_path = (struct device *) dm_hash_lookup(_cache.names, path)))
+	if (dm_hash_lookup(_cache.names, path))
 		dm_hash_remove(_cache.names, path);
 
 	dm_list_iterate_items(strl, &dev->aliases) {
@@ -949,7 +946,7 @@ static int _dev_cache_iterate_sysfs_for_index(const char *path)
 			continue;
 		}
 
-		devno = MKDEV((dev_t)major, (dev_t)minor);
+		devno = MKDEV(major, 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)) ||
@@ -1090,7 +1087,7 @@ out:
 static void _insert_dirs(struct dm_list *dirs)
 {
 	struct dir_list *dl;
-	struct udev *udev;
+	struct udev *udev = NULL;
 	int with_udev;
 
 	with_udev = obtain_device_list_from_udev() &&
@@ -1302,8 +1299,8 @@ static int _check_for_open_devices(int close_immediate)
 			log_error("Device '%s' has been left open (%d remaining references).",
 				  dev_name(dev), dev->open_count);
 			num_open++;
-			if (close_immediate)
-				dev_close_immediate(dev);
+			if (close_immediate && !dev_close_immediate(dev))
+				stack;
 		}
 	}
 
@@ -1475,7 +1472,7 @@ struct device *dev_cache_get(struct cmd_context *cmd, const char *name, struct d
 		return d;
 
 	if (f && !(d->flags & DEV_REGULAR)) {
-		ret = f->passes_filter(cmd, f, d);
+		ret = f->passes_filter(cmd, f, d, NULL);
 
 		if (ret == -EAGAIN) {
 			log_debug_devs("get device by name defer filter %s", dev_name(d));
@@ -1507,7 +1504,7 @@ static struct device *_dev_cache_seek_devt(dev_t dev)
  * TODO This is very inefficient. We probably want a hash table indexed by
  * major:minor for keys to speed up these lookups.
  */
-struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t dev, struct dev_filter *f)
+struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t dev, struct dev_filter *f, int *filtered)
 {
 	char path[PATH_MAX];
 	const char *sysfs_dir;
@@ -1515,6 +1512,9 @@ struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t dev, struct
 	struct device *d = _dev_cache_seek_devt(dev);
 	int ret;
 
+	if (filtered)
+		*filtered = 0;
+
 	if (d && (d->flags & DEV_REGULAR))
 		return d;
 
@@ -1548,7 +1548,7 @@ struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t dev, struct
 	if (!f)
 		return d;
 
-	ret = f->passes_filter(cmd, f, d);
+	ret = f->passes_filter(cmd, f, d, NULL);
 
 	if (ret == -EAGAIN) {
 		log_debug_devs("get device by number defer filter %s", dev_name(d));
@@ -1559,6 +1559,8 @@ struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t dev, struct
 	if (ret)
 		return d;
 
+	if (filtered)
+		*filtered = 1;
 	return NULL;
 }
 
@@ -1605,7 +1607,7 @@ struct device *dev_iter_get(struct cmd_context *cmd, struct dev_iter *iter)
 		f = iter->filter;
 
 		if (f && !(d->flags & DEV_REGULAR)) {
-			ret = f->passes_filter(cmd, f, d);
+			ret = f->passes_filter(cmd, f, d, NULL);
 
 			if (ret == -EAGAIN) {
 				log_debug_devs("get device by iter defer filter %s", dev_name(d));
@@ -1631,3 +1633,21 @@ const char *dev_name(const struct device *dev)
 	return (dev && dev->aliases.n) ? dm_list_item(dev->aliases.n, struct dm_str_list)->str :
 	    unknown_device_name();
 }
+
+bool dev_cache_has_md_with_end_superblock(struct dev_types *dt)
+{
+	struct btree_iter *iter = btree_first(_cache.devices);
+	struct device *dev;
+
+	while (iter) {
+		dev = btree_get_data(iter);
+
+		if (dev_is_md_with_end_superblock(dt, dev))
+			return true;
+
+		iter = btree_next(iter);
+	}
+
+	return false;
+}
+

lib/device/dev-cache.h

@@ -17,6 +17,7 @@
 #define _LVM_DEV_CACHE_H
 
 #include "lib/device/device.h"
+#include "lib/device/dev-type.h"
 #include "lib/misc/lvm-wrappers.h"
 
 struct cmd_context;
@@ -25,11 +26,12 @@ struct cmd_context;
  * predicate for devices.
  */
 struct dev_filter {
-	int (*passes_filter) (struct cmd_context *cmd, struct dev_filter *f, struct device *dev);
+	int (*passes_filter) (struct cmd_context *cmd, struct dev_filter *f, struct device *dev, const char *use_filter_name);
 	void (*destroy) (struct dev_filter *f);
 	void (*wipe) (struct dev_filter *f);
 	void *private;
 	unsigned use_count;
+	const char *name;
 };
 
 int dev_cache_index_devs(void);
@@ -54,8 +56,7 @@ int dev_cache_add_dir(const char *path);
 struct device *dev_cache_get(struct cmd_context *cmd, const char *name, struct dev_filter *f);
 const char *dev_cache_filtered_reason(const char *name);
 
-// TODO
-struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t device, struct dev_filter *f);
+struct device *dev_cache_get_by_devt(struct cmd_context *cmd, dev_t device, struct dev_filter *f, int *filtered);
 
 void dev_set_preferred_name(struct dm_str_list *sl, struct device *dev);
 
@@ -71,4 +72,6 @@ void dev_reset_error_count(struct cmd_context *cmd);
 
 void dev_cache_failed_path(struct device *dev, const char *path);
 
+bool dev_cache_has_md_with_end_superblock(struct dev_types *dt);
+
 #endif