WIP: base: adapt Makefile to stable branch

It broke some unit tests, for v. little benefit

.gitignore

@@ -14,14 +14,8 @@
 *.so
 *.so.*
 *.sw*
-*.su
-*.patch
 *~
 
-# gcov files:
-*.gcda
-*.gcno
-
 .export.sym
 .exported_symbols_generated
 .gdb_history
@@ -31,37 +25,17 @@ make.tmpl
 
 /autom4te.cache/
 /autoscan.log
-/build/
-/config.cache
 /config.log
 /config.status
 /configure.scan
-/cscope.*
-/html/
-/python/
-/reports/
+/cscope.out
 /tags
 /tmp/
 
-coverity/coverity_model.xml
-
-/.cache/
-/compile_commands.json
-
-/doc/.ikiwiki
-/public
-
-/libdm/.symver_check
-
-daemons/clvmd
-daemons/dmfilemapd
-daemons/lvmetad/
 
 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
@@ -86,7 +60,6 @@ test/lib/pvremove
 test/lib/pvresize
 test/lib/pvs
 test/lib/pvscan
-test/lib/securetest
 test/lib/vgcfgbackup
 test/lib/vgcfgrestore
 test/lib/vgchange
@@ -115,8 +88,6 @@ test/api/thin_percent.t
 test/api/vglist.t
 test/api/vgtest.t
 test/lib/aux
-test/lib/cache-mq.profile
-test/lib/cache-smq.profile
 test/lib/check
 test/lib/clvmd
 test/lib/dm-version-expected
@@ -126,7 +97,6 @@ test/lib/dmstats
 test/lib/fail
 test/lib/flavour-ndev-cluster
 test/lib/flavour-ndev-cluster-lvmpolld
-test/lib/flavour-ndev-devicesfile
 test/lib/flavour-ndev-lvmetad
 test/lib/flavour-ndev-lvmetad-lvmpolld
 test/lib/flavour-ndev-lvmpolld
@@ -136,7 +106,6 @@ test/lib/flavour-udev-cluster-lvmpolld
 test/lib/flavour-udev-lvmetad
 test/lib/flavour-udev-lvmetad-lvmpolld
 test/lib/flavour-udev-lvmlockd-dlm
-test/lib/flavour-udev-lvmlockd-idm
 test/lib/flavour-udev-lvmlockd-sanlock
 test/lib/flavour-udev-lvmlockd-test
 test/lib/flavour-udev-lvmpolld
@@ -149,13 +118,8 @@ test/lib/lvm
 test/lib/lvm-wrapper
 test/lib/lvmchange
 test/lib/lvmdbusd.profile
-test/lib/lvmdevices
 test/lib/lvmetad
-test/lib/lvmlockctl
-test/lib/lvmlockd
 test/lib/lvmpolld
-test/lib/lvm_import_vdo
-test/lib/lvm_vdo_wrapper
 test/lib/not
 test/lib/paths
 test/lib/paths-common
@@ -165,7 +129,5 @@ test/lib/test
 test/lib/thin-performance.profile
 test/lib/utils
 test/lib/version-expected
-test/lib/vgimportdevices
-
 test/unit/dmraid_t.c
 test/unit/unit-test

.gitlab-ci.yml

@@ -1,104 +0,0 @@
-stages:
-  - approve
-  - test
-
-approve1:
-  stage: approve
-  script:
-    - echo "Approved..."
-  rules:
-    # TODO: Filter only safe repositories, or user in developers
-    - if: $CI_PROJECT_PATH != "csonto/lvm2" && $CI_PROJECT_PATH != "lvmteam/lvm2"
-      when: manual
-    # TODO: for other branches than main/rhel: run pipeline only when requested:
-    - if: $CI_COMMIT_BRANCH != "main" && $CI_COMMIT_BRANCH !~ "^rhel.*"
-      when: manual
-    - when: on_success
-  allow_failure: false
-
-
-pages:
-  image: elecnix/ikiwiki
-  stage: test
-  script:
-    - ikiwiki --setup ikiwiki.setup --libdir themes/ikistrap/lib
-  artifacts:
-    paths:
-      - public
-  only:
-    refs:
-      - main
-    changes:
-      - doc/**/*
-      - ikiwiki.setup
-
-
-# TODO:
-# - check results of autoreconf and make generate - may need additional commit
-#     - we need a particular setup (rawhide OR latest supported fedora?)
-# - do make rpm and publish results as artifacts - we will use packit/COPR for this eventually
-
-# Run on any commits to main (master), rhel8, rhel9 branches
-test-job:
-  stage: test
-  parallel:
-    matrix:
-      - TAG: rhel8
-        CONFIGURE: >
-          --with-cluster=internal
-          --enable-cmirrord
-      - TAG: rhel9
-        CONFIGURE: >
-          --with-default-use-devices-file=1
-          --enable-app-machineid
-          --enable-editline
-          --disable-readline
-  artifacts:
-    paths:
-      - test/results/
-    expire_in: 1 week
-  tags:
-      - ${TAG}
-  timeout: 2h
-  script:
-    # Common options go here, diffs to the above matrix
-    - >
-      ./configure ${CONFIGURE}
-      --enable-fsadm
-      --enable-write_install
-      --enable-pkgconfig
-      --enable-cmdlib
-      --enable-dmeventd
-      --enable-blkid_wiping
-      --enable-udev_sync
-      --with-thin=internal
-      --with-cache=internal
-      --enable-lvmpolld
-      --enable-lvmlockd-dlm --enable-lvmlockd-dlmcontrol
-      --enable-lvmlockd-sanlock
-      --enable-dbus-service --enable-notify-dbus
-      --enable-dmfilemapd
-      --with-writecache=internal
-      --with-vdo=internal --with-vdo-format=/usr/bin/vdoformat
-      --with-integrity=internal
-      --disable-silent-rules
-    - make
-    - rm -rf test/results
-    - mkdir -p /dev/shm/lvm2-test
-    - mount -o remount,dev /dev/shm
-    # TODO: Need to distinguish failed test from failed harness
-    # TODO: Also need a way to find if run is incomplete, e.g. full disk resulting in many skipped tests
-    - VERBOSE=0 BATCH=1 LVM_TEST_DIR=/dev/shm/lvm2-test make check || true
-    - rm -rf /dev/shm/lvm2-test
-    - cut -d' ' -f2 test/results/list | sort | uniq -c
-    # Filter artifacts - keep only logs from tests which are not pass
-    - cd test/results && rm $(grep 'passed$' list | cut -d' ' -f1 | sed -e 's|/|_|g' -e 's|.*|\0.txt|')
-    # TODO: Keep a list of known failures, and translate into regexp - or simply use python...
-    - if grep failed test/results/list | grep -v '\\\(dbustest\|lvconvert-mirror\)\.sh' | sort; then false; else true; fi
-  rules:
-    # Filter only safe repositories, or user in developers:
-    # NOTE: Already done in approve stage, may be more caution than necessary
-    - if: $CI_PROJECT_PATH != "csonto/lvm2" && $CI_PROJECT_PATH != "lvmteam/lvm2"
-      when: manual
-    - when: on_success
-

Makefile.in

@@ -18,7 +18,7 @@ top_builddir = @top_builddir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 
-SUBDIRS = libdm conf daemons include lib libdaemon man scripts tools
+SUBDIRS = conf daemons include lib libdaemon libdm man scripts device_mapper tools
 
 ifeq ("@UDEV_RULES@", "yes")
   SUBDIRS += udev
@@ -28,6 +28,14 @@ ifeq ("@INTL@", "yes")
   SUBDIRS += po
 endif
 
+ifeq ("@APPLIB@", "yes")
+  SUBDIRS += liblvm
+endif
+
+ifeq ("@PYTHON_BINDINGS@", "yes")
+  SUBDIRS += python
+endif
+
 ifeq ($(MAKECMDGOALS),clean)
   SUBDIRS += test
 endif
@@ -35,32 +43,37 @@ endif
 ifeq ($(MAKECMDGOALS),distclean)
   SUBDIRS = conf include man test scripts \
     libdaemon lib tools daemons libdm \
-    udev po
+    udev po liblvm python device_mapper
 tools.distclean: test.distclean
 endif
-DISTCLEAN_DIRS += lcov_reports* autom4te.cache
+DISTCLEAN_DIRS += lcov_reports*
 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
 
-lib: include libdaemon $(BASE_TARGET) $(DEVICE_MAPPER_TARGET)
-daemons: lib libdaemon tools
-scripts: lib
-tools: lib libdaemon
+libdm: include $(top_builddir)/base/libbase.a
+libdaemon: include $(top_builddir)/base/libbase.a
+lib: libdm libdaemon $(top_builddir)/base/libbase.a
+liblvm: lib $(top_builddir)/base/libbase.a
+daemons: lib libdaemon tools $(top_builddir)/base/libbase.a
+tools: lib libdaemon device-mapper $(top_builddir)/base/libbase.a
 po: tools daemons
 man: tools
 all_man: tools
-test: tools daemons
-unit-test  run-unit-test: test libdm
+scripts: liblvm libdm
+test: tools daemons $(top_builddir)/base/libbase.a
+unit-test: lib $(top_builddir)/base/libbase.a
+run-unit-test: unit-test
 
+lib.device-mapper: include.device-mapper
+libdm.device-mapper: include.device-mapper
+liblvm.device-mapper: include.device-mapper
 daemons.device-mapper: libdm.device-mapper
 tools.device-mapper: libdm.device-mapper
+scripts.device-mapper: include.device-mapper
 device-mapper: tools.device-mapper daemons.device-mapper man.device-mapper
-device_mapper: device-mapper
 
 ifeq ("@INTL@", "yes")
 lib.pofile: include.pofile
@@ -70,22 +83,25 @@ po.pofile: tools.pofile daemons.pofile
 pofile: po.pofile
 endif
 
+ifeq ("@PYTHON_BINDINGS@", "yes")
+python: liblvm
+endif
+
 ifneq ("$(CFLOW_CMD)", "")
 tools.cflow: libdm.cflow lib.cflow
 daemons.cflow: tools.cflow
 cflow: include.cflow
 endif
 
-CSCOPE_DIRS = base daemons device_mapper include lib libdaemon scripts tools libdm test
 ifneq ("@CSCOPE_CMD@", "")
 cscope.out:
-	@CSCOPE_CMD@ -b -R $(patsubst %,-s%,$(addprefix $(srcdir)/,$(CSCOPE_DIRS)))
+	@CSCOPE_CMD@ -b -R -s$(top_srcdir)
 all: cscope.out
 endif
 DISTCLEAN_TARGETS += cscope.out
 CLEAN_DIRS += autom4te.cache
 
-check check_system check_cluster check_local check_lvmpolld check_lvmlockd_test check_lvmlockd_dlm check_lvmlockd_sanlock: test
+check check_system check_cluster check_local check_lvmetad check_lvmpolld check_lvmlockd_test check_lvmlockd_dlm check_lvmlockd_sanlock unit-test run-unit-test: test
 	$(MAKE) -C test $(@)
 
 conf.generate man.generate: tools
@@ -110,13 +126,13 @@ rpm: dist
 	$(LN_S) -f $(abs_top_srcdir)/spec/build.inc $(rpmbuilddir)/SOURCES
 	$(LN_S) -f $(abs_top_srcdir)/spec/macros.inc $(rpmbuilddir)/SOURCES
 	$(LN_S) -f $(abs_top_srcdir)/spec/packages.inc $(rpmbuilddir)/SOURCES
-	DM_VER=$$(cut -d- -f1 $(top_srcdir)/VERSION_DM);\
-	GIT_VER=$$(cd $(top_srcdir); git describe | cut -d- --output-delimiter=. -f2,3 || echo 0);\
-	$(SED) -e "s,\(device_mapper_version\) [0-9.]*$$,\1 $$DM_VER," \
+	DM_VER=$$(cut -d' ' -f1 $(top_srcdir)/VERSION_DM | cut -d- -f1);\
+	GIT_VER=$$(cd $(top_srcdir); git describe | cut -s -d- --output-delimiter=. -f2,3);\
+	sed -e "s,\(device_mapper_version\) [0-9.]*$$,\1 $$DM_VER," \
 	    -e "s,^\(Version:[^0-9%]*\)[0-9.]*$$,\1 $(LVM_VER)," \
-	    -e "s,^\(Release:[^0-9%]*\)[0-9.]\+,\1 $$GIT_VER," \
+	    -e "s,^\(Release:[^0-9%]*\)[0-9.]\+,\1 $${GIT_VER:-"0"}," \
 	    $(top_srcdir)/spec/source.inc >$(rpmbuilddir)/SOURCES/source.inc
-	V=$(V) rpmbuild -v --define "_topdir $(rpmbuilddir)" -ba $(top_srcdir)/spec/lvm2.spec
+	rpmbuild -v --define "_topdir $(rpmbuilddir)" -ba $(top_srcdir)/spec/lvm2.spec
 
 generate: conf.generate man.generate
 	$(MAKE) -C conf generate
@@ -127,7 +143,6 @@ all_man:
 
 install_system_dirs:
 	$(INSTALL_DIR) $(DESTDIR)$(DEFAULT_SYS_DIR)
-	$(INSTALL_ROOT_DIR) $(DESTDIR)$(DEFAULT_SYS_DIR)/devices
 	$(INSTALL_ROOT_DIR) $(DESTDIR)$(DEFAULT_ARCHIVE_DIR)
 	$(INSTALL_ROOT_DIR) $(DESTDIR)$(DEFAULT_BACKUP_DIR)
 	$(INSTALL_ROOT_DIR) $(DESTDIR)$(DEFAULT_CACHE_DIR)
@@ -148,37 +163,27 @@ install_systemd_units:
 install_all_man:
 	$(MAKE) -C man install_all_man
 
+ifeq ("@PYTHON_BINDINGS@", "yes")
+install_python_bindings:
+	$(MAKE) -C liblvm/python install_python_bindings
+endif
+
 install_tmpfiles_configuration:
 	$(MAKE) -C scripts install_tmpfiles_configuration
 
-help:
-	@echo -e "\nAvailable targets:"
-	@echo "  all			Default target."
-	@echo "  all_man		Build all man pages with generators."
-	@echo "  clean			Remove all compile files."
-	@echo "  device-mapper		Device mapper part of lvm2."
-	@echo "  dist			Generate distributable file."
-	@echo "  distclean		Remove all build files."
-	@echo "  generate		Generate man pages for sources."
-	@echo "  help			Display callable targets."
-	@echo "  install		Install all files."
-	@echo "  install_all_man	Install all man pages."
-	@echo "  install_cluster	Install cmirrord."
-	@echo "  install_device-mapper	Install device mapper files."
-	@echo "  install_initscripts	Install initialization scripts."
-	@echo "  install_lvm2		Install lvm2 files."
-	@echo "  install_systemd_units	Install systemd units."
-	@echo "  lcov			Generate lcov output."
-	@echo "  lcov-dated		Generate lcov with timedate suffix."
-	@echo "  lcov-reset		Reset lcov counters"
-	@echo "  man			Build man pages."
-	@echo "  print-VARIABLE		Resolve make variable."
-	@echo "  rpm			Build rpm."
-	@echo "  run-unit-test		Run unit tests."
-	@echo "  tags			Generate c/etags."
+LCOV_TRACES = libdm.info lib.info liblvm.info tools.info \
+	libdaemon/client.info libdaemon/server.info \
+	test/unit.info \
+	daemons/clvmd.info \
+	daemons/dmeventd.info \
+	daemons/lvmetad.info \
+	daemons/lvmlockd.info \
+	daemons/lvmpolld.info
+
+CLEAN_TARGETS += $(LCOV_TRACES)
 
 ifneq ("$(LCOV)", "")
-.PHONY: lcov-reset lcov lcov-dated
+.PHONY: lcov-reset lcov lcov-dated $(LCOV_TRACES)
 
 ifeq ($(MAKECMDGOALS),lcov-dated)
 LCOV_REPORTS_DIR := lcov_reports-$(shell date +%Y%m%d%k%M%S)
@@ -188,26 +193,34 @@ LCOV_REPORTS_DIR := lcov_reports
 endif
 
 lcov-reset:
-	$(LCOV) --zerocounters --directory $(top_builddir)
+	$(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/" \
+		>$@
 
 ifneq ("$(GENHTML)", "")
-lcov:
-	$(RM) -rf $(LCOV_REPORTS_DIR)
+lcov: $(LCOV_TRACES)
+	$(RM) -r $(LCOV_REPORTS_DIR)
 	$(MKDIR_P) $(LCOV_REPORTS_DIR)
-	-$(LCOV) --capture --directory $(top_builddir) --ignore-errors source,negative,gcov \
-		--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
+	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
 endif
 
 endif
 
-ifneq ($(shell which ctags 2>/dev/null),)
+ifneq ($(shell which ctags),)
 .PHONY: tags
 tags:
-	test -z "$(shell find $(addprefix $(top_srcdir)/,$(CSCOPE_DIRS)) -type f -name '*.[ch]' -newer tags 2>/dev/null | head -1)" || $(RM) tags
-	test -f tags || find $(addprefix $(top_srcdir)/,$(CSCOPE_DIRS)) -maxdepth 5 -type f -name '*.[ch]' -exec ctags -a '{}' +
+	test -z "$(shell find $(top_srcdir) -type f -name '*.[ch]' -newer tags 2>/dev/null | head -1)" || $(RM) tags
+	test -f tags || find $(top_srcdir) -maxdepth 5 -type f -name '*.[ch]' -exec ctags -a '{}' +
 
 CLEAN_TARGETS += tags
 endif

README

@@ -7,33 +7,24 @@ There is no warranty - see COPYING and COPYING.LIB.
 
 Tarballs are available from:
   ftp://sourceware.org/pub/lvm2/
+  ftp://sources.redhat.com/pub/lvm2/
   https://github.com/lvmteam/lvm2/releases
 
 The source code is stored in git:
-  https://gitlab.com/lvmteam/lvm2
-Clone:
-  git clone git@gitlab.com:lvmteam/lvm2.git
-Anonymous access:
-  git clone https://gitlab.com/lvmteam/lvm2.git
-Mirrored to:
-* https://github.com/lvmteam/lvm2
+  https://sourceware.org/git/?p=lvm2.git
+  git clone git://sourceware.org/git/lvm2.git
+mirrored to:
+  https://github.com/lvmteam/lvm2
   git clone https://github.com/lvmteam/lvm2.git
   git clone git@github.com:lvmteam/lvm2.git
-* https://sourceware.org/git/?p=lvm2.git
-  git clone https://sourceware.org/git/lvm2.git
-  git clone git://sourceware.org/git/lvm2.git
 
 Mailing list for general discussion related to LVM2:
-  linux-lvm@lists.linux.dev
-  Subscribe via email to: linux-lvm+subscribe@lists.linux.dev
-  Archive https://lore.kernel.org/linux-lvm/
-  Older archive https://listman.redhat.com/archives/linux-lvm/
+  linux-lvm@redhat.com
+  Subscribe from https://www.redhat.com/mailman/listinfo/linux-lvm
 
 Mailing lists for LVM2 development, patches and commits:
-  lvm-devel@lists.linux.dev
-  Subscribe via email to: lvm-devel+subscribe@lists.linux.dev
-  Archive https://lore.kernel.org/lvm-devel/
-  Older archive https://listman.redhat.com/archives/lvm-devel/
+  lvm-devel@redhat.com
+  Subscribe from https://www.redhat.com/mailman/listinfo/lvm-devel
 
   lvm2-commits@lists.fedorahosted.org (Read-only archive of commits)
   Subscribe from https://fedorahosted.org/mailman/listinfo/lvm2-commits
@@ -49,12 +40,8 @@ Website:
 Report upstream bugs at:
   https://bugzilla.redhat.com/enter_bug.cgi?product=LVM%20and%20device-mapper
 or open issues at:
-  https://gitlab.com/groups/lvmteam/-/issues
   https://github.com/lvmteam/lvm2/issues
 
-The source code repository used until 7th June 2012 is accessible using CVS:
+The source code repository used until 7th June 2012 is accessible here:
+  http://sources.redhat.com/cgi-bin/cvsweb.cgi/LVM2/?cvsroot=lvm2.
 
-  cvs -d :pserver:cvs@sourceware.org:/cvs/lvm2 login cvs
-  cvs -d :pserver:cvs@sourceware.org:/cvs/lvm2 checkout LVM2
-
-The password is cvs.

TESTING

@@ -21,15 +21,10 @@ You MUST disable (or mask) any LVM daemons:
 - clvmd
 - cmirrord
 
-Some lvm.conf options should be set:
-
-- global/event_activation = 0
-- activation/monitoring = 0
-
 For running cluster tests, we are using singlenode locking. Pass
 `--with-clvmd=singlenode` to configure.
 
-NOTE: This is useful only for testing, and should not be used in production
+NOTE: This is useful only for testing, and should not be used in produciton
 code.
 
 To run D-Bus daemon tests, existing D-Bus session is required.

VERSION

@@ -1 +1 @@
-2.03.31(2)-git (2025-01-14)
+2.02.187(2)-git (2019-08-27)

VERSION_DM

@@ -1 +1 @@
-1.02.205-git (2025-01-14)
+1.02.166-git (2019-08-27)

WHATS_NEW_DM

@@ -1,153 +1,28 @@
-Version 1.02.205 - 
-===================
-
-Version 1.02.204 - 14th January 2025
-====================================
-  Create /dev/disk/by-diskseq/<DISKSEQ> symlink for public DM devices.
-
-Version 1.02.203 - 09th December 2024
-=====================================
-
-Version 1.02.202 - 04th November 2024
-=====================================
-  Introduce dm_config_parse_only_section to stop parsing after section.
-  For shorter string use on stack buffers when generating sections.
-  Enhance dm_config tokenizer.
-
-Version 1.02.201 - 02nd October 2024
-====================================
-  Cleanup udev sync semaphore if dm_{udev_create,task_set}_cookie fails.
-  Improve error messages on failed udev cookie create/inc/dec operation.
-
-Version 1.02.200 - 23rd August 2024
+Version 1.02.166 - 
 ===================================
-
-Version 1.02.199 - 12nd July 2024
-=================================
-
-Version 1.02.198 - 16th May 2024
-================================
-  Fix static only compilation of libdevmapper.a and dmsetup tool.
-  Use better code for closing opened descriptors when starting dmeventd.
-  Correct dmeventd -R for systemd environment.
-  Restart of dmeventd -R checks pid file to detect running dmeventd first.
-  Query with dmeventd -i quickly ends when there is no running dmeventd.
-  Enhance dm_get_status_raid to handle mismatching status or reported legs.
-  Create /dev/disk/by-label symlinks for DM devs that have crypto as next layer.
-  Persist udev db for DM devs on cleanup used in initrd to rootfs transition.
-  Process synthetic udev events other than 'add/change' as 'change' events.
-  Increase DM_UDEV_RULES_VSN to 3 to indicate changed udev rules.
-  Rename DM_NOSCAN to .DM_NOSCAN so it's not stored in udev db.
-  Rename DM_SUSPENDED to .DM_SUSPENDED so it's not stored in udev db.
-  Do not import DM_UDEV_DISABLE_OTHER_RULES_FLAG from db in 10-dm-disk.rules.
-  Test DISK_RO after importing properties from db in 10-dm.rules.
-  Also import ID_FS_TYPE in 13-dm-disk.rules from db if needed.
-
-Version 1.02.197 - 21st November 2023
-=====================================
-  Fix invalid JSON report if using DM_REPORT_OUTPUT_MULTIPLE_TIMES and selection.
-  Propagate ioctl errno from dm_task_run when creating new table line.
-  Add support for group aliases in dmstats.
-  Add support for exit-on file for dmeventd to reduce shutdown delays.
-  Add configure option --with-dmeventd-exit-on-path to specify default path.
-  Add dmsetup --headings none|abbrev|full to set report headings type.
-  Add DM_REPORT_OUTPUT_FIELD_IDS_IN_HEADINGS to provide alternative headings.
-
-Version 1.02.196 - 02nd August 2023
-===================================
-
-Version 1.02.195 - 21st April 2023
-==================================
-
-Version 1.02.193 - 21st March 2023
-==================================
-
-Version 1.02.191 - 21st February 2023
-=====================================
-  Improve parallel creation of /dev/mapper/control device node.
-  Import previous ID_FS_* udev records in 13-dm-disk.rules for suspended DM dev.
-  Remove NAME="mapper/control" rule from 10-dm.rules to avoid udev warnings.
-
-Version 1.02.189 - 22nd December 2022
-=====================================
-  Improve 'dmsetup create' without given table line with new kernels.
-
-Version 1.02.187 - 10th November 2022
-=====================================
-  Add DM_REPORT_GROUP_JSON_STD for more JSON standard compliant output format.
-
-Version 1.02.185 - 18th May 2022
-================================
-
-Version 1.02.183 - 07th February 2022
-=====================================
-  Unmangle UUIDs for DM_DEVICE_LIST ioctl.
-
-Version 1.02.181 - 20th October 2021
-====================================
-  Add IMA support with 'dmsetup measure' command.
-  Add defines DM_NAME_LIST_FLAG_HAS_UUID, DM_NAME_LIST_FLAG_DOESNT_HAVE_UUID.
-  Enhance tracking of activated devices when preloading dm tree.
-  Fix bug in construction of cache table line (regression from 1.02.159).
-
-Version 1.02.179 - 11th August 2021
-===================================
-
-Version 1.02.177 - 07th May 2021
-================================
-  Configure proceeds without libaio to allow build of device-mapper only.
-  Fix symbol versioning build with -O2 -flto.
-  Add dm_tree_node_add_thin_pool_target_v1 with crop_metadata support.
-
-Version 1.02.175 - 08th January 2021
-====================================
-
-Version 1.02.173 - 09th August 2020
-===================================
-  Add support for VDO in blkdeactivate script.
-
-Version 1.02.171 - 26th March 2020
-==================================
-  Try to remove all created devices on dm preload tree error path.
-  Fix dm_list iterators with gcc 10 optimization (-ftree-pta).
-  Dmeventd handles timer without looping on short intervals.
-
-Version 1.02.169 - 11th February 2020
-=====================================
-  Enhance error messages for device creation.
-
-Version 1.02.167 - 30th November 2019
-=====================================
-
-Version 1.02.165 - 23rd October 2019
-====================================
   Add support for DM_DEVICE_GET_TARGET_VERSION.
+
+Version 1.02.164 - 27th August 2019
+===================================
   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.
+Version 1.02.158 - 13th May 2019
+================================
+
+Version 1.02.156 - 22nd March 2019
+==================================
+  Ensure migration_threshold for cache is at least 8 chunks.
   Enhance ioctl flattening and add parameters only when needed.
-  Add DM_DEVICE_ARM_POLL for API completeness matching kernel.
+  Add DM_DEVICE_ARM_POLL for API completness matching kernel.
+
+Version 1.02.154 - 07th December 2018
+=====================================
   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
+Version 1.02.152 - 30th October 2018
 ====================================
   Add hot fix to avoiding locking collision when monitoring thin-pools.
 
@@ -169,7 +44,7 @@ Version 1.02.147-rc1 - 24th May 2018
   Reuse uname() result for mirror target.
   Recognize also mounted btrfs through dm_device_has_mounted_fs().
   Add missing log_error() into dm_stats_populate() returning 0.
-  Avoid calling dm_stats_populate() for DM devices without any stats regions.
+  Avoid calling dm_stats_populat() for DM devices without any stats regions.
   Support DM_DEBUG_WITH_LINE_NUMBERS envvar for debug msg with source:line.
   Configured command for thin pool threshold handling gets whole environment.
   Fix tests for failing dm_snprintf() in stats code.
@@ -218,7 +93,7 @@ Version 1.02.141 - 28th June 2017
   Add dm_percent_to_round_float for adjusted percentage rounding.
   Reset array with dead rimage devices once raid gets in sync.
   Drop unneeded --config option from raid dmeventd plugin.
-  dm_get_status_raid() handle better some inconsistent md statuses.
+  dm_get_status_raid() handle better some incosistent md statuses.
   Accept truncated files in calls to dm_stats_update_regions_from_fd().
   Restore Warning by 5% increment when thin-pool is over 80% (1.02.138).
 
@@ -413,7 +288,7 @@ Version 1.02.112 - 28th November 2015
 =====================================
   Show error message when trying to create unsupported raid type.
   Improve preloading sequence of an active thin-pool target.
-  Drop extra space from cache target line to fix unneeded table reloads.
+  Drop extra space from cache target line to fix unneded table reloads.
 
 Version 1.02.111 - 23rd November 2015
 =====================================
@@ -428,7 +303,7 @@ Version 1.02.110 - 30th October 2015
   Disable thin monitoring plugin when it fails too often (>10 times).
   Fix/restore parsing of empty field '-' when processing dmeventd event.
   Enhance dm_tree_node_size_changed() to recognize size reduction.
-  Support exit on idle for dmeventd (1 hour).
+  Support exit on idle for dmenventd (1 hour).
   Add support to allow unmonitor device from plugin itself.
   New design for thread co-operation in dmeventd.
   Dmeventd read device status with 'noflush'.
@@ -601,7 +476,7 @@ Version 1.02.93 - 21st January 2015
 Version 1.02.92 - 24th November 2014
 ====================================
   Fix memory corruption with sorting empty string lists (1.02.86).
-  Fix man dmsetup.8 syntax warning of Groff.
+  Fix man dmsetup.8 syntax warning of Groff
   Accept unquoted strings and / in place of {} when parsing configs.
 
 Version 1.02.91 - 11th November 2014
@@ -620,7 +495,7 @@ Version 1.02.90 - 1st September 2014
 Version 1.02.89 - 26th August 2014
 ==================================
   Improve libdevmapper-event select() error handling.
-  Add extra check for matching transaction_id after message submitting.
+  Add extra check for matching transation_id after message submitting.
   Add dm_report_field_string_list_unsorted for str. list report without sorting.
   Support --deferred with dmsetup remove to defer removal of open devices.
   Update dm-ioctl.h to include DM_DEFERRED_REMOVE flag.
@@ -652,7 +527,7 @@ Version 1.02.86 - 23rd June 2014
   Add DM_REPORT_FIELD_TYPE_STRING_LIST: separate string and string list fields.
   Add dm_str_list to libdevmapper for string list type definition and its reuse.
   Add dmsetup -S/--select to define selection criteria for dmsetup reports.
-  Add dm_report_init_with_selection to initialize report with selection criteria.
+  Add dm_report_init_with_selection to intialize report with selection criteria.
   Add DM_REPORT_FIELD_TYPE_SIZE: separate number and size reporting fields.
   Use RemoveOnStop for dm-event.socket systemd unit.
   Document env var 'DM_DEFAULT_NAME_MANGLING_MODE' in dmsetup man page.
@@ -707,7 +582,7 @@ Version 1.02.82 - 4th October 2013
 
 Version 1.02.81 - 23rd September 2013
 =====================================
-  Tidy dmeventd fifo initialization.
+  Tidy dmeventd fifo initialisation.
 
 Version 1.02.80 - 20th September 2013
 =====================================
@@ -732,7 +607,7 @@ Version 1.02.78 - 24th July 2013
   Always return success on dmeventd -V command call.
   Fix parsing of 64bit snapshot status in dmeventd snapshot plugin.
   Add dm_get_status_snapshot() for parsing snapshot status.
-  Detect mounted fs also via reading /proc/self/mountinfo.
+  Detecte mounted fs also via reading /proc/self/mountinfo.
   Add dm_mountinfo_read() for parsing /proc/self/mountinfo.
   Report error for nonexisting devices in dmeventd communication.
   Prevent double free error after dmeventd call of _fill_device_data().
@@ -829,7 +704,7 @@ Version 1.02.71 - 20th February 2012
   Add "watch" rule to 13-dm-disk.rules.
   Detect failing fifo and skip 20s retry communication period.
   Add DM_DEFAULT_NAME_MANGLING_MODE environment variable as an override.
-  Add dm_lib_init to automatically initialize device-mapper library on load.
+  Add dm_lib_init to automatically initialise device-mapper library on load.
   Replace any '\' char with '\\' in dm table specification on input.
   Add mangle command to dmsetup to provide renaming to correct mangled form.
   Add 'mangled_name' and 'unmangled_name' fields to dmsetup info -c -o.
@@ -923,7 +798,7 @@ Version 1.02.66 - 12th August 2011
   Fix memory leak in dmsetup _message() memory allocation error path.
   Use new oom killer adjustment interface (oom_score_adj) when available.
   Add systemd unit files for dmeventd.
-  Fix read-only identical table reload suppression.
+  Fix read-only identical table reload supression.
 
 Version 1.02.65 - 8th July 2011
 ===============================
@@ -938,7 +813,7 @@ Version 1.02.65 - 8th July 2011
   Add dm_get_suspended_counter() for number of devs in suspended state by lib.
   Fix "all" report field prefix matching to include label fields with pv_all.
   Delay resuming new preloaded mirror devices with core logs in deptree code.
-  Accept new kernel version 3 uname formats in initialization.
+  Accept new kernel version 3 uname formats in initialisation.
 
 Version 1.02.64 - 29th April 2011
 ==================================
@@ -952,7 +827,7 @@ Version 1.02.64 - 29th April 2011
   Improve stack debug reporting in dm_task_create().
   Fallback to control node creation only if node doesn't exist yet.
   Change dm_hash binary functions to take void *key instead of char *.
-  Fix uninitialized memory use with empty params in _reload_with_suppression_v4.
+  Fix uninitialised memory use with empty params in _reload_with_suppression_v4.
   Lower severity of selabel_lookup and matchpathcon failure to log_debug.
   Add test for failed allocation from dm_task_set_uuid() in dmeventd.
   Add dm_event_get_version to dmeventd for use with -R.
@@ -1121,7 +996,7 @@ Version 1.02.44 - 15th February 2010
 
 Version 1.02.43 - 21st January 2010
 ===================================
-  Remove bitset, hash and pool headers superseded by libdevmapper.h.
+  Remove bitset, hash and pool headers superceded by libdevmapper.h.
   Fix off-by-one error causing bad cluster mirror table construction.
 
 Version 1.02.42 - 14th January 2010
@@ -1177,7 +1052,7 @@ Version 1.02.37 - 15th September 2009
 Version 1.02.36 - 6th August 2009
 =================================
   Add udevcookies, udevcomplete, udevcomplete_all and --noudevwait to dmsetup.
-  Add libdevmapper functions to support synchronization with udev.
+  Add libdevmapper functions to support synchronisation with udev.
 
 Version 1.02.35 - 28th July 2009
 ================================
@@ -1245,7 +1120,7 @@ Version 1.02.27 - 25th June 2008
 
 Version 1.02.26 - 6th June 2008
 ===============================
-  Initialize params buffer to empty string in _emit_segment.
+  Initialise params buffer to empty string in _emit_segment.
   Skip add_dev_node when ioctls disabled.
   Make dm_hash_iter safe against deletion.
   Accept a NULL pointer to dm_free silently.
@@ -1301,7 +1176,7 @@ Version 1.02.20 - 15th June 2007
 
 Version 1.02.19 - 27th April 2007
 =================================
-  Standardize protective include file #defines.
+  Standardise protective include file #defines.
   Add regex functions to library.
   Avoid trailing separator in reports when there are hidden sort fields.
   Fix segfault in 'dmsetup status' without --showkeys against crypt target.
@@ -1332,7 +1207,7 @@ Version 1.02.16 - 25th January 2007
   Streamline dm_report_field_* interface.
   Add cmdline debug & version options to dmeventd.
   Add DM_LIB_VERSION definition to configure.h.
-  Suppress 'Unrecognized field' error if report field is 'help'.
+  Suppress 'Unrecognised field' error if report field is 'help'.
   Add --separator and --sort to dmsetup (unused).
   Make alignment flag optional when specifying report fields.
 
@@ -1580,5 +1455,3 @@ Version 1.00.08 - 27 Feb 2004
   Fixed DESTDIR for make install/install_static_lib.
   Updated README/INSTALL to reflect move to sources.redhat.com.
   Updated autoconf files to 2003-06-17.
-
-

acinclude.m4

@@ -62,24 +62,6 @@ AC_DEFUN([AC_TRY_LDFLAGS],
     fi
 ])
 
-
-dnl PKG_CHECK_VAR(VARIABLE, MODULE, CONFIG-VARIABLE,
-dnl [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
-dnl -------------------------------------------
-dnl Since: 0.28
-dnl
-dnl Retrieves the value of the pkg-config variable for the given module.
-AC_DEFUN([PKG_CHECK_VAR],
-[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
-AC_ARG_VAR([$1], [value of $3 for $2, overriding pkg-config])dnl
-
-_PKG_CONFIG([$1], [variable="][$3]["], [$2])
-AS_VAR_COPY([$1], [pkg_cv_][$1])
-
-AS_VAR_IF([$1], [""], [$5], [$4])dnl
-])dnl PKG_CHECK_VAR
-
-
 # ===========================================================================
 #      http://www.gnu.org/software/autoconf-archive/ax_gcc_builtin.html
 # ===========================================================================

aclocal.m4

@@ -1,6 +1,6 @@
-# generated automatically by aclocal 1.17 -*- Autoconf -*-
+# generated automatically by aclocal 1.15 -*- Autoconf -*-
 
-# Copyright (C) 1996-2024 Free Software Foundation, Inc.
+# Copyright (C) 1996-2014 Free Software Foundation, Inc.
 
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -13,7 +13,7 @@
 
 m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
 # ===========================================================================
-#     https://www.gnu.org/software/autoconf-archive/ax_python_module.html
+#     http://www.gnu.org/software/autoconf-archive/ax_python_module.html
 # ===========================================================================
 #
 # SYNOPSIS
@@ -37,7 +37,7 @@ m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun
 #   and this notice are preserved. This file is offered as-is, without any
 #   warranty.
 
-#serial 9
+#serial 8
 
 AU_ALIAS([AC_PYTHON_MODULE], [AX_PYTHON_MODULE])
 AC_DEFUN([AX_PYTHON_MODULE],[
@@ -69,9 +69,9 @@ AC_DEFUN([AX_PYTHON_MODULE],[
     fi
 ])
 
-# pkg.m4 - Macros to locate and use pkg-config.   -*- Autoconf -*-
-# serial 12 (pkg-config-0.29.2)
-
+dnl pkg.m4 - Macros to locate and utilise pkg-config.   -*- Autoconf -*-
+dnl serial 11 (pkg-config-0.29)
+dnl
 dnl Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
 dnl Copyright © 2012-2015 Dan Nicholson <dbn.lists@gmail.com>
 dnl
@@ -112,13 +112,13 @@ dnl
 dnl See the "Since" comment for each macro you use to see what version
 dnl of the macros you require.
 m4_defun([PKG_PREREQ],
-[m4_define([PKG_MACROS_VERSION], [0.29.2])
+[m4_define([PKG_MACROS_VERSION], [0.29])
 m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1,
     [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])])
 ])dnl PKG_PREREQ
 
-dnl PKG_PROG_PKG_CONFIG([MIN-VERSION], [ACTION-IF-NOT-FOUND])
-dnl ---------------------------------------------------------
+dnl PKG_PROG_PKG_CONFIG([MIN-VERSION])
+dnl ----------------------------------
 dnl Since: 0.16
 dnl
 dnl Search for the pkg-config tool and set the PKG_CONFIG variable to
@@ -126,12 +126,6 @@ dnl first found in the path. Checks that the version of pkg-config found
 dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.9.0 is
 dnl used since that's the first version where most current features of
 dnl pkg-config existed.
-dnl
-dnl If pkg-config is not found or older than specified, it will result
-dnl in an empty PKG_CONFIG variable. To avoid widespread issues with
-dnl scripts not checking it, ACTION-IF-NOT-FOUND defaults to aborting.
-dnl You can specify [PKG_CONFIG=false] as an action instead, which would
-dnl result in pkg-config tests failing, but no bogus error messages.
 AC_DEFUN([PKG_PROG_PKG_CONFIG],
 [m4_pattern_forbid([^_?PKG_[A-Z_]+$])
 m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
@@ -152,9 +146,6 @@ if test -n "$PKG_CONFIG"; then
 		AC_MSG_RESULT([no])
 		PKG_CONFIG=""
 	fi
-fi
-if test -z "$PKG_CONFIG"; then
-	m4_default([$2], [AC_MSG_ERROR([pkg-config not found])])
 fi[]dnl
 ])dnl PKG_PROG_PKG_CONFIG
 
@@ -166,7 +157,7 @@ dnl Check to see whether a particular set of modules exists. Similar to
 dnl PKG_CHECK_MODULES(), but does not set variables or print errors.
 dnl
 dnl Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
-dnl only at the first occurrence in configure.ac, so if the first place
+dnl only at the first occurence in configure.ac, so if the first place
 dnl it's called might be skipped (such as if it is within an "if", you
 dnl have to call PKG_CHECK_EXISTS manually
 AC_DEFUN([PKG_CHECK_EXISTS],
@@ -222,7 +213,7 @@ AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
 AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
 
 pkg_failed=no
-AC_MSG_CHECKING([for $2])
+AC_MSG_CHECKING([for $1])
 
 _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
 _PKG_CONFIG([$1][_LIBS], [libs], [$2])
@@ -232,17 +223,17 @@ and $1[]_LIBS to avoid the need to call pkg-config.
 See the pkg-config man page for more details.])
 
 if test $pkg_failed = yes; then
-        AC_MSG_RESULT([no])
+   	AC_MSG_RESULT([no])
         _PKG_SHORT_ERRORS_SUPPORTED
         if test $_pkg_short_errors_supported = yes; then
-                $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
-        else
-                $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
+	        $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
+        else 
+	        $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
         fi
-        # Put the nasty error message in config.log where it belongs
-        echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
+	# Put the nasty error message in config.log where it belongs
+	echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
 
-        m4_default([$4], [AC_MSG_ERROR(
+	m4_default([$4], [AC_MSG_ERROR(
 [Package requirements ($2) were not met:
 
 $$1_PKG_ERRORS
@@ -253,8 +244,8 @@ installed software in a non-standard prefix.
 _PKG_TEXT])[]dnl
         ])
 elif test $pkg_failed = untried; then
-        AC_MSG_RESULT([no])
-        m4_default([$4], [AC_MSG_FAILURE(
+     	AC_MSG_RESULT([no])
+	m4_default([$4], [AC_MSG_FAILURE(
 [The pkg-config script could not be found or is too old.  Make sure it
 is in your PATH or set the PKG_CONFIG environment variable to the full
 path to pkg-config.
@@ -264,10 +255,10 @@ _PKG_TEXT
 To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
         ])
 else
-        $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
-        $1[]_LIBS=$pkg_cv_[]$1[]_LIBS
+	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
+	$1[]_LIBS=$pkg_cv_[]$1[]_LIBS
         AC_MSG_RESULT([yes])
-        $3
+	$3
 fi[]dnl
 ])dnl PKG_CHECK_MODULES
 
@@ -354,75 +345,7 @@ AS_VAR_COPY([$1], [pkg_cv_][$1])
 AS_VAR_IF([$1], [""], [$5], [$4])dnl
 ])dnl PKG_CHECK_VAR
 
-dnl PKG_WITH_MODULES(VARIABLE-PREFIX, MODULES,
-dnl   [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND],
-dnl   [DESCRIPTION], [DEFAULT])
-dnl ------------------------------------------
-dnl
-dnl Prepare a "--with-" configure option using the lowercase
-dnl [VARIABLE-PREFIX] name, merging the behaviour of AC_ARG_WITH and
-dnl PKG_CHECK_MODULES in a single macro.
-AC_DEFUN([PKG_WITH_MODULES],
-[
-m4_pushdef([with_arg], m4_tolower([$1]))
-
-m4_pushdef([description],
-           [m4_default([$5], [build with ]with_arg[ support])])
-
-m4_pushdef([def_arg], [m4_default([$6], [auto])])
-m4_pushdef([def_action_if_found], [AS_TR_SH([with_]with_arg)=yes])
-m4_pushdef([def_action_if_not_found], [AS_TR_SH([with_]with_arg)=no])
-
-m4_case(def_arg,
-            [yes],[m4_pushdef([with_without], [--without-]with_arg)],
-            [m4_pushdef([with_without],[--with-]with_arg)])
-
-AC_ARG_WITH(with_arg,
-     AS_HELP_STRING(with_without, description[ @<:@default=]def_arg[@:>@]),,
-    [AS_TR_SH([with_]with_arg)=def_arg])
-
-AS_CASE([$AS_TR_SH([with_]with_arg)],
-            [yes],[PKG_CHECK_MODULES([$1],[$2],$3,$4)],
-            [auto],[PKG_CHECK_MODULES([$1],[$2],
-                                        [m4_n([def_action_if_found]) $3],
-                                        [m4_n([def_action_if_not_found]) $4])])
-
-m4_popdef([with_arg])
-m4_popdef([description])
-m4_popdef([def_arg])
-
-])dnl PKG_WITH_MODULES
-
-dnl PKG_HAVE_WITH_MODULES(VARIABLE-PREFIX, MODULES,
-dnl   [DESCRIPTION], [DEFAULT])
-dnl -----------------------------------------------
-dnl
-dnl Convenience macro to trigger AM_CONDITIONAL after PKG_WITH_MODULES
-dnl check._[VARIABLE-PREFIX] is exported as make variable.
-AC_DEFUN([PKG_HAVE_WITH_MODULES],
-[
-PKG_WITH_MODULES([$1],[$2],,,[$3],[$4])
-
-AM_CONDITIONAL([HAVE_][$1],
-               [test "$AS_TR_SH([with_]m4_tolower([$1]))" = "yes"])
-])dnl PKG_HAVE_WITH_MODULES
-
-dnl PKG_HAVE_DEFINE_WITH_MODULES(VARIABLE-PREFIX, MODULES,
-dnl   [DESCRIPTION], [DEFAULT])
-dnl ------------------------------------------------------
-dnl
-dnl Convenience macro to run AM_CONDITIONAL and AC_DEFINE after
-dnl PKG_WITH_MODULES check. HAVE_[VARIABLE-PREFIX] is exported as make
-dnl and preprocessor variable.
-AC_DEFUN([PKG_HAVE_DEFINE_WITH_MODULES],
-[
-PKG_HAVE_WITH_MODULES([$1],[$2],[$3],[$4])
-
-AS_IF([test "$AS_TR_SH([with_]m4_tolower([$1]))" = "yes"],
-        [AC_DEFINE([HAVE_][$1], 1, [Enable ]m4_tolower([$1])[ support])])
-])dnl PKG_HAVE_DEFINE_WITH_MODULES
-
-# Copyright (C) 1999-2024 Free Software Foundation, Inc.
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -456,14 +379,8 @@ AC_DEFUN([AM_PATH_PYTHON],
   dnl Find a Python interpreter.  Python versions prior to 2.0 are not
   dnl supported. (2.0 was released on October 16, 2000).
   m4_define_default([_AM_PYTHON_INTERPRETER_LIST],
-[python python3 dnl
- python3.20 python3.19 python3.18 python3.17 python3.16 dnl
- python3.15 python3.14 python3.13 python3.12 python3.11 python3.10 dnl
- python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 dnl
- python3.2 python3.1 python3.0 dnl
- python2 dnl
- python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 dnl
- python2.0])
+[python python2 python3 python3.3 python3.2 python3.1 python3.0 python2.7 dnl
+ python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 python2.0])
 
   AC_ARG_VAR([PYTHON], [the Python interpreter])
 
@@ -504,141 +421,34 @@ AC_DEFUN([AM_PATH_PYTHON],
   ])
 
   if test "$PYTHON" = :; then
-    dnl Run any user-specified action, or abort.
+  dnl Run any user-specified action, or abort.
     m4_default([$3], [AC_MSG_ERROR([no suitable Python interpreter found])])
   else
 
-  dnl Query Python for its version number.  Although site.py simply uses
-  dnl sys.version[:3], printing that failed with Python 3.10, since the
-  dnl trailing zero was eliminated. So now we output just the major
-  dnl and minor version numbers, as numbers. Apparently the tertiary
-  dnl version is not of interest.
-  dnl
+  dnl Query Python for its version number.  Getting [:3] seems to be
+  dnl the best way to do this; it's what "site.py" does in the standard
+  dnl library.
+
   AC_CACHE_CHECK([for $am_display_PYTHON version], [am_cv_python_version],
-    [am_cv_python_version=`$PYTHON -c "import sys; print ('%u.%u' % sys.version_info[[:2]])"`])
+    [am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version[[:3]])"`])
   AC_SUBST([PYTHON_VERSION], [$am_cv_python_version])
 
-  dnl At times, e.g., when building shared libraries, you may want
+  dnl Use the values of $prefix and $exec_prefix for the corresponding
+  dnl values of PYTHON_PREFIX and PYTHON_EXEC_PREFIX.  These are made
+  dnl distinct variables so they can be overridden if need be.  However,
+  dnl general consensus is that you shouldn't need this ability.
+
+  AC_SUBST([PYTHON_PREFIX], ['${prefix}'])
+  AC_SUBST([PYTHON_EXEC_PREFIX], ['${exec_prefix}'])
+
+  dnl At times (like when building shared libraries) you may want
   dnl to know which OS platform Python thinks this is.
-  dnl
+
   AC_CACHE_CHECK([for $am_display_PYTHON platform], [am_cv_python_platform],
     [am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`])
   AC_SUBST([PYTHON_PLATFORM], [$am_cv_python_platform])
 
-  dnl emacs-page
-  dnl If --with-python-sys-prefix is given, use the values of sys.prefix
-  dnl and sys.exec_prefix for the corresponding values of PYTHON_PREFIX
-  dnl and PYTHON_EXEC_PREFIX. Otherwise, use the GNU ${prefix} and
-  dnl ${exec_prefix} variables.
-  dnl
-  dnl The two are made distinct variables so they can be overridden if
-  dnl need be, although general consensus is that you shouldn't need
-  dnl this separation.
-  dnl
-  dnl Also allow directly setting the prefixes via configure options,
-  dnl overriding any default.
-  dnl
-  if test "x$prefix" = xNONE; then
-    am__usable_prefix=$ac_default_prefix
-  else
-    am__usable_prefix=$prefix
-  fi
-
-  # Allow user to request using sys.* values from Python,
-  # instead of the GNU $prefix values.
-  AC_ARG_WITH([python-sys-prefix],
-  [AS_HELP_STRING([--with-python-sys-prefix],
-                  [use Python's sys.prefix and sys.exec_prefix values])],
-  [am_use_python_sys=:],
-  [am_use_python_sys=false])
-
-  # Allow user to override whatever the default Python prefix is.
-  AC_ARG_WITH([python_prefix],
-  [AS_HELP_STRING([--with-python_prefix],
-                  [override the default PYTHON_PREFIX])],
-  [am_python_prefix_subst=$withval
-   am_cv_python_prefix=$withval
-   AC_MSG_CHECKING([for explicit $am_display_PYTHON prefix])
-   AC_MSG_RESULT([$am_cv_python_prefix])],
-  [
-   if $am_use_python_sys; then
-     # using python sys.prefix value, not GNU
-     AC_CACHE_CHECK([for python default $am_display_PYTHON prefix],
-     [am_cv_python_prefix],
-     [am_cv_python_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.prefix)"`])
-
-     dnl If sys.prefix is a subdir of $prefix, replace the literal value of
-     dnl $prefix with a variable reference so it can be overridden.
-     case $am_cv_python_prefix in
-     $am__usable_prefix*)
-       am__strip_prefix=`echo "$am__usable_prefix" | sed 's|.|.|g'`
-       am_python_prefix_subst=`echo "$am_cv_python_prefix" | sed "s,^$am__strip_prefix,\\${prefix},"`
-       ;;
-     *)
-       am_python_prefix_subst=$am_cv_python_prefix
-       ;;
-     esac
-   else # using GNU prefix value, not python sys.prefix
-     am_python_prefix_subst='${prefix}'
-     am_python_prefix=$am_python_prefix_subst
-     AC_MSG_CHECKING([for GNU default $am_display_PYTHON prefix])
-     AC_MSG_RESULT([$am_python_prefix])
-   fi])
-  # Substituting python_prefix_subst value.
-  AC_SUBST([PYTHON_PREFIX], [$am_python_prefix_subst])
-
-  # emacs-page Now do it all over again for Python exec_prefix, but with yet
-  # another conditional: fall back to regular prefix if that was specified.
-  AC_ARG_WITH([python_exec_prefix],
-  [AS_HELP_STRING([--with-python_exec_prefix],
-                  [override the default PYTHON_EXEC_PREFIX])],
-  [am_python_exec_prefix_subst=$withval
-   am_cv_python_exec_prefix=$withval
-   AC_MSG_CHECKING([for explicit $am_display_PYTHON exec_prefix])
-   AC_MSG_RESULT([$am_cv_python_exec_prefix])],
-  [
-   # no explicit --with-python_exec_prefix, but if
-   # --with-python_prefix was given, use its value for python_exec_prefix too.
-   AS_IF([test -n "$with_python_prefix"],
-   [am_python_exec_prefix_subst=$with_python_prefix
-    am_cv_python_exec_prefix=$with_python_prefix
-    AC_MSG_CHECKING([for python_prefix-given $am_display_PYTHON exec_prefix])
-    AC_MSG_RESULT([$am_cv_python_exec_prefix])],
-   [
-    # Set am__usable_exec_prefix whether using GNU or Python values,
-    # since we use that variable for pyexecdir.
-    if test "x$exec_prefix" = xNONE; then
-      am__usable_exec_prefix=$am__usable_prefix
-    else
-      am__usable_exec_prefix=$exec_prefix
-    fi
-    #
-    if $am_use_python_sys; then # using python sys.exec_prefix, not GNU
-      AC_CACHE_CHECK([for python default $am_display_PYTHON exec_prefix],
-      [am_cv_python_exec_prefix],
-      [am_cv_python_exec_prefix=`$PYTHON -c "import sys; sys.stdout.write(sys.exec_prefix)"`])
-      dnl If sys.exec_prefix is a subdir of $exec_prefix, replace the
-      dnl literal value of $exec_prefix with a variable reference so it can
-      dnl be overridden.
-      case $am_cv_python_exec_prefix in
-      $am__usable_exec_prefix*)
-        am__strip_prefix=`echo "$am__usable_exec_prefix" | sed 's|.|.|g'`
-        am_python_exec_prefix_subst=`echo "$am_cv_python_exec_prefix" | sed "s,^$am__strip_prefix,\\${exec_prefix},"`
-        ;;
-      *)
-        am_python_exec_prefix_subst=$am_cv_python_exec_prefix
-        ;;
-     esac
-   else # using GNU $exec_prefix, not python sys.exec_prefix
-     am_python_exec_prefix_subst='${exec_prefix}'
-     am_python_exec_prefix=$am_python_exec_prefix_subst
-     AC_MSG_CHECKING([for GNU default $am_display_PYTHON exec_prefix])
-     AC_MSG_RESULT([$am_python_exec_prefix])
-   fi])])
-  # Substituting python_exec_prefix_subst.
-  AC_SUBST([PYTHON_EXEC_PREFIX], [$am_python_exec_prefix_subst])
-
-  # Factor out some code duplication into this shell variable.
+  # Just factor out some code duplication.
   am_python_setup_sysconfig="\
 import sys
 # Prefer sysconfig over distutils.sysconfig, for better compatibility
@@ -656,120 +466,98 @@ try:
     if python_implementation() == 'CPython' and sys.version[[:3]] == '2.7':
         can_use_sysconfig = 0
 except ImportError:
-    pass" # end of am_python_setup_sysconfig
+    pass"
 
-  # More repeated code, for figuring out the installation scheme to use.
-  am_python_setup_scheme="if hasattr(sysconfig, 'get_default_scheme'):
-      scheme = sysconfig.get_default_scheme()
-    else:
-      scheme = sysconfig._get_default_scheme()
-    if scheme == 'posix_local':
-      if '$am_py_prefix' == '/usr':
-        scheme = 'deb_system' # should only happen during Debian package builds
-      else:
-        # Debian's default scheme installs to /usr/local/ but we want to
-        # follow the prefix, as we always have.
-        # See bugs#54412, #64837, et al.
-        scheme = 'posix_prefix'" # end of am_python_setup_scheme
+  dnl Set up 4 directories:
 
-  dnl emacs-page Set up 4 directories:
-
-  dnl 1. pythondir: where to install python scripts.  This is the
-  dnl    site-packages directory, not the python standard library
-  dnl    directory as in early automake betas.  This behavior
-  dnl    is more consistent with lispdir.m4 for example.
-  dnl Query sysconfig or distutils (per above) for this directory.
-  dnl
-  AC_CACHE_CHECK([for $am_display_PYTHON script directory (pythondir)],
-  [am_cv_python_pythondir],
-  [if test "x$am_cv_python_prefix" = x; then
-     am_py_prefix=$am__usable_prefix
-   else
-     am_py_prefix=$am_cv_python_prefix
-   fi
-   am_cv_python_pythondir=`$PYTHON -c "
+  dnl pythondir -- where to install python scripts.  This is the
+  dnl   site-packages directory, not the python standard library
+  dnl   directory like in previous automake betas.  This behavior
+  dnl   is more consistent with lispdir.m4 for example.
+  dnl Query distutils for this directory.
+  AC_CACHE_CHECK([for $am_display_PYTHON script directory],
+    [am_cv_python_pythondir],
+    [if test "x$prefix" = xNONE
+     then
+       am_py_prefix=$ac_default_prefix
+     else
+       am_py_prefix=$prefix
+     fi
+     am_cv_python_pythondir=`$PYTHON -c "
 $am_python_setup_sysconfig
 if can_use_sysconfig:
-  try:
-    $am_python_setup_scheme
-    sitedir = sysconfig.get_path('purelib', scheme, vars={'base':'$am_py_prefix'})
-  except:
     sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'})
 else:
-  from distutils import sysconfig
-  sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix')
+    from distutils import sysconfig
+    sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix')
 sys.stdout.write(sitedir)"`
-   #
-   case $am_cv_python_pythondir in
-   $am_py_prefix*)
-     am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'`
-     am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,\\${PYTHON_PREFIX},"`
-     ;;
-   *)
-     case $am_py_prefix in
-       /usr|/System*) ;;
-       *) am_cv_python_pythondir="\${PYTHON_PREFIX}/lib/python$PYTHON_VERSION/site-packages"
-          ;;
+     case $am_cv_python_pythondir in
+     $am_py_prefix*)
+       am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'`
+       am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"`
+       ;;
+     *)
+       case $am_py_prefix in
+         /usr|/System*) ;;
+         *)
+	  am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages
+	  ;;
+       esac
+       ;;
      esac
-     ;;
-   esac
-  ])
+    ])
   AC_SUBST([pythondir], [$am_cv_python_pythondir])
 
-  dnl 2. pkgpythondir: $PACKAGE directory under pythondir.  Was
-  dnl    PYTHON_SITE_PACKAGE in previous betas, but this naming is
-  dnl    more consistent with the rest of automake.
-  dnl
+  dnl pkgpythondir -- $PACKAGE directory under pythondir.  Was
+  dnl   PYTHON_SITE_PACKAGE in previous betas, but this naming is
+  dnl   more consistent with the rest of automake.
+
   AC_SUBST([pkgpythondir], [\${pythondir}/$PACKAGE])
 
-  dnl 3. pyexecdir: directory for installing python extension modules
-  dnl    (shared libraries).
-  dnl Query sysconfig or distutils for this directory.
-  dnl Much of this is the same as for prefix setup above.
-  dnl
-  AC_CACHE_CHECK([for $am_display_PYTHON extension module directory (pyexecdir)],
-  [am_cv_python_pyexecdir],
-  [if test "x$am_cv_python_exec_prefix" = x; then
-     am_py_exec_prefix=$am__usable_exec_prefix
-   else
-     am_py_exec_prefix=$am_cv_python_exec_prefix
-   fi
-   am_cv_python_pyexecdir=`$PYTHON -c "
+  dnl pyexecdir -- directory for installing python extension modules
+  dnl   (shared libraries)
+  dnl Query distutils for this directory.
+  AC_CACHE_CHECK([for $am_display_PYTHON extension module directory],
+    [am_cv_python_pyexecdir],
+    [if test "x$exec_prefix" = xNONE
+     then
+       am_py_exec_prefix=$am_py_prefix
+     else
+       am_py_exec_prefix=$exec_prefix
+     fi
+     am_cv_python_pyexecdir=`$PYTHON -c "
 $am_python_setup_sysconfig
 if can_use_sysconfig:
-  try:
-    $am_python_setup_scheme
-    sitedir = sysconfig.get_path('platlib', scheme, vars={'platbase':'$am_py_exec_prefix'})
-  except:
-    sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_exec_prefix'})
+    sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'})
 else:
-  from distutils import sysconfig
-  sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_exec_prefix')
+    from distutils import sysconfig
+    sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix')
 sys.stdout.write(sitedir)"`
-   #
-   case $am_cv_python_pyexecdir in
-   $am_py_exec_prefix*)
-     am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'`
-     am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,\\${PYTHON_EXEC_PREFIX},"`
-     ;;
-   *)
-     case $am_py_exec_prefix in
-       /usr|/System*) ;;
-       *) am_cv_python_pyexecdir="\${PYTHON_EXEC_PREFIX}/lib/python$PYTHON_VERSION/site-packages"
-          ;;
+     case $am_cv_python_pyexecdir in
+     $am_py_exec_prefix*)
+       am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'`
+       am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"`
+       ;;
+     *)
+       case $am_py_exec_prefix in
+         /usr|/System*) ;;
+         *)
+	   am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages
+	   ;;
+       esac
+       ;;
      esac
-     ;;
-   esac
-  ])
+    ])
   AC_SUBST([pyexecdir], [$am_cv_python_pyexecdir])
 
-  dnl 4. pkgpyexecdir: $(pyexecdir)/$(PACKAGE)
-  dnl
+  dnl pkgpyexecdir -- $(pyexecdir)/$(PACKAGE)
+
   AC_SUBST([pkgpyexecdir], [\${pyexecdir}/$PACKAGE])
 
   dnl Run any user-specified action.
   $2
   fi
+
 ])
 
 
@@ -792,7 +580,7 @@ for i in list(range(0, 4)): minverhex = (minverhex << 8) + minver[[i]]
 sys.exit(sys.hexversion < minverhex)"
   AS_IF([AM_RUN_LOG([$1 -c "$prog"])], [$3], [$4])])
 
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2014 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,

autoconf/install-sh

@@ -1,7 +1,7 @@
-#!/usr/bin/sh
+#!/bin/sh
 # install - install a program, script, or datafile
 
-scriptversion=2020-11-14.01; # UTC
+scriptversion=2006-10-14.15
 
 # This originates from X11R5 (mit/util/scripts/install.sh), which was
 # later released in X11R6 (xc/config/util/install.sh) with the
@@ -35,62 +35,57 @@ scriptversion=2020-11-14.01; # UTC
 # FSF changes to this file are in the public domain.
 #
 # Calling this script install-sh is preferred over install.sh, to prevent
-# 'make' implicit rules from creating a file called install from it
+# `make' implicit rules from creating a file called install from it
 # when there is no Makefile.
 #
 # This script is compatible with the BSD install script, but was written
 # from scratch.
 
-tab='	'
 nl='
 '
-IFS=" $tab$nl"
+IFS=" ""	$nl"
 
-# Set DOITPROG to "echo" to test this script.
+# set DOITPROG to echo to test this script
 
-doit=${DOITPROG-}
-doit_exec=${doit:-exec}
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+if test -z "$doit"; then
+  doit_exec=exec
+else
+  doit_exec=$doit
+fi
 
 # Put in absolute file names if you don't have them in your path;
 # or use environment vars.
 
-chgrpprog=${CHGRPPROG-chgrp}
-chmodprog=${CHMODPROG-chmod}
-chownprog=${CHOWNPROG-chown}
-cmpprog=${CMPPROG-cmp}
-cpprog=${CPPROG-cp}
-mkdirprog=${MKDIRPROG-mkdir}
-mvprog=${MVPROG-mv}
-rmprog=${RMPROG-rm}
-stripprog=${STRIPPROG-strip}
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
 
+posix_glob=
 posix_mkdir=
 
 # Desired mode of installed file.
 mode=0755
 
-# Create dirs (including intermediate dirs) using mode 755.
-# This is like GNU 'install' as of coreutils 8.32 (2020).
-mkdir_umask=22
-
-backupsuffix=
-chgrpcmd=
 chmodcmd=$chmodprog
 chowncmd=
-mvcmd=$mvprog
-rmcmd="$rmprog -f"
+chgrpcmd=
 stripcmd=
-
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
 src=
 dst=
 dir_arg=
-dst_arg=
+dstarg=
+no_target_directory=
 
-copy_on_change=false
-is_target_a_directory=possibly
-
-usage="\
-Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+usage="Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
    or: $0 [OPTION]... SRCFILES... DIRECTORY
    or: $0 [OPTION]... -t DIRECTORY SRCFILES...
    or: $0 [OPTION]... -d DIRECTORIES...
@@ -100,116 +95,91 @@ In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
 In the 4th, create DIRECTORIES.
 
 Options:
-     --help     display this help and exit.
-     --version  display version info and exit.
-
-  -c            (ignored)
-  -C            install only if different (preserve data modification time)
-  -d            create directories instead of installing files.
-  -g GROUP      $chgrpprog installed files to GROUP.
-  -m MODE       $chmodprog installed files to MODE.
-  -o USER       $chownprog installed files to USER.
-  -p            pass -p to $cpprog.
-  -s            $stripprog installed files.
-  -S SUFFIX     attempt to back up existing files, with suffix SUFFIX.
-  -t DIRECTORY  install into DIRECTORY.
-  -T            report an error if DSTFILE is a directory.
+-c         (ignored)
+-d         create directories instead of installing files.
+-g GROUP   $chgrpprog installed files to GROUP.
+-m MODE    $chmodprog installed files to MODE.
+-o USER    $chownprog installed files to USER.
+-s         $stripprog installed files.
+-t DIRECTORY  install into DIRECTORY.
+-T         report an error if DSTFILE is a directory.
+--help     display this help and exit.
+--version  display version info and exit.
 
 Environment variables override the default commands:
-  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
-  RMPROG STRIPPROG
-
-By default, rm is invoked with -f; when overridden with RMPROG,
-it's up to you to specify -f if you want it.
-
-If -S is not specified, no backups are attempted.
-
-Email bug reports to bug-automake@gnu.org.
-Automake home page: https://www.gnu.org/software/automake/
+  CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG
 "
 
 while test $# -ne 0; do
   case $1 in
-    -c) ;;
+    -c) shift
+        continue;;
 
-    -C) copy_on_change=true;;
-
-    -d) dir_arg=true;;
+    -d) dir_arg=true
+        shift
+        continue;;
 
     -g) chgrpcmd="$chgrpprog $2"
-        shift;;
+        shift
+        shift
+        continue;;
 
     --help) echo "$usage"; exit $?;;
 
     -m) mode=$2
-        case $mode in
-          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*)
-            echo "$0: invalid mode: $mode" >&2
-            exit 1;;
-        esac
-        shift;;
+        shift
+        shift
+	case $mode in
+	  *' '* | *'	'* | *'
+'*	  | *'*'* | *'?'* | *'['*)
+	    echo "$0: invalid mode: $mode" >&2
+	    exit 1;;
+	esac
+        continue;;
 
     -o) chowncmd="$chownprog $2"
-        shift;;
+        shift
+        shift
+        continue;;
 
-    -p) cpprog="$cpprog -p";;
+    -s) stripcmd=$stripprog
+        shift
+        continue;;
 
-    -s) stripcmd=$stripprog;;
+    -t) dstarg=$2
+	shift
+	shift
+	continue;;
 
-    -S) backupsuffix="$2"
-        shift;;
-
-    -t)
-        is_target_a_directory=always
-        dst_arg=$2
-        # Protect names problematic for 'test' and other utilities.
-        case $dst_arg in
-          -* | [=\(\)!]) dst_arg=./$dst_arg;;
-        esac
-        shift;;
-
-    -T) is_target_a_directory=never;;
+    -T) no_target_directory=true
+	shift
+	continue;;
 
     --version) echo "$0 $scriptversion"; exit $?;;
 
-    --) shift
-        break;;
+    --)	shift
+	break;;
 
-    -*) echo "$0: invalid option: $1" >&2
-        exit 1;;
+    -*)	echo "$0: invalid option: $1" >&2
+	exit 1;;
 
     *)  break;;
   esac
-  shift
 done
 
-# We allow the use of options -d and -T together, by making -d
-# take the precedence; this is for compatibility with GNU install.
-
-if test -n "$dir_arg"; then
-  if test -n "$dst_arg"; then
-    echo "$0: target directory not allowed when installing a directory." >&2
-    exit 1
-  fi
-fi
-
-if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+if test $# -ne 0 && test -z "$dir_arg$dstarg"; then
   # When -d is used, all remaining arguments are directories to create.
   # When -t is used, the destination is already specified.
   # Otherwise, the last argument is the destination.  Remove it from $@.
   for arg
   do
-    if test -n "$dst_arg"; then
+    if test -n "$dstarg"; then
       # $@ is not empty: it contains at least $arg.
-      set fnord "$@" "$dst_arg"
+      set fnord "$@" "$dstarg"
       shift # fnord
     fi
     shift # arg
-    dst_arg=$arg
-    # Protect names problematic for 'test' and other utilities.
-    case $dst_arg in
-      -* | [=\(\)!]) dst_arg=./$dst_arg;;
-    esac
+    dstarg=$arg
   done
 fi
 
@@ -218,26 +188,13 @@ if test $# -eq 0; then
     echo "$0: no input file specified." >&2
     exit 1
   fi
-  # It's OK to call 'install-sh -d' without argument.
+  # It's OK to call `install-sh -d' without argument.
   # This can happen when creating conditional directories.
   exit 0
 fi
 
 if test -z "$dir_arg"; then
-  if test $# -gt 1 || test "$is_target_a_directory" = always; then
-    if test ! -d "$dst_arg"; then
-      echo "$0: $dst_arg: Is not a directory." >&2
-      exit 1
-    fi
-  fi
-fi
-
-if test -z "$dir_arg"; then
-  do_exit='(exit $ret); exit $ret'
-  trap "ret=129; $do_exit" 1
-  trap "ret=130; $do_exit" 2
-  trap "ret=141; $do_exit" 13
-  trap "ret=143; $do_exit" 15
+  trap '(exit $?); exit' 1 2 13 15
 
   # Set umask so as not to create temps with too-generous modes.
   # However, 'strip' requires both read and write access to temps.
@@ -248,16 +205,16 @@ if test -z "$dir_arg"; then
 
     *[0-7])
       if test -z "$stripcmd"; then
-        u_plus_rw=
+	u_plus_rw=
       else
-        u_plus_rw='% 200'
+	u_plus_rw='% 200'
       fi
       cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
     *)
       if test -z "$stripcmd"; then
-        u_plus_rw=
+	u_plus_rw=
       else
-        u_plus_rw=,u+rw
+	u_plus_rw=,u+rw
       fi
       cp_umask=$mode$u_plus_rw;;
   esac
@@ -265,9 +222,9 @@ fi
 
 for src
 do
-  # Protect names problematic for 'test' and other utilities.
+  # Protect names starting with `-'.
   case $src in
-    -* | [=\(\)!]) src=./$src;;
+    -*) src=./$src ;;
   esac
 
   if test -n "$dir_arg"; then
@@ -275,10 +232,6 @@ do
     dstdir=$dst
     test -d "$dstdir"
     dstdir_status=$?
-    # Don't chown directories that already exist.
-    if test $dstdir_status = 0; then
-      chowncmd=""
-    fi
   else
 
     # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
@@ -289,154 +242,196 @@ do
       exit 1
     fi
 
-    if test -z "$dst_arg"; then
+    if test -z "$dstarg"; then
       echo "$0: no destination specified." >&2
       exit 1
     fi
-    dst=$dst_arg
 
-    # If destination is a directory, append the input filename.
+    dst=$dstarg
+    # Protect names starting with `-'.
+    case $dst in
+      -*) dst=./$dst ;;
+    esac
+
+    # If destination is a directory, append the input filename; won't work
+    # if double slashes aren't ignored.
     if test -d "$dst"; then
-      if test "$is_target_a_directory" = never; then
-        echo "$0: $dst_arg: Is a directory" >&2
-        exit 1
+      if test -n "$no_target_directory"; then
+	echo "$0: $dstarg: Is a directory" >&2
+	exit 1
       fi
       dstdir=$dst
-      dstbase=`basename "$src"`
-      case $dst in
-	*/) dst=$dst$dstbase;;
-	*)  dst=$dst/$dstbase;;
-      esac
+      dst=$dstdir/`basename "$src"`
       dstdir_status=0
     else
-      dstdir=`dirname "$dst"`
+      # Prefer dirname, but fall back on a substitute if dirname fails.
+      dstdir=`
+	(dirname "$dst") 2>/dev/null ||
+	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	     X"$dst" : 'X\(//\)[^/]' \| \
+	     X"$dst" : 'X\(//\)$' \| \
+	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+	echo X"$dst" |
+	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)[^/].*/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\).*/{
+		   s//\1/
+		   q
+		 }
+		 s/.*/./; q'
+      `
+
       test -d "$dstdir"
       dstdir_status=$?
     fi
   fi
 
-  case $dstdir in
-    */) dstdirslash=$dstdir;;
-    *)  dstdirslash=$dstdir/;;
-  esac
-
   obsolete_mkdir_used=false
 
   if test $dstdir_status != 0; then
     case $posix_mkdir in
       '')
-        # With -d, create the new directory with the user-specified mode.
-        # Otherwise, rely on $mkdir_umask.
-        if test -n "$dir_arg"; then
-          mkdir_mode=-m$mode
-        else
-          mkdir_mode=
-        fi
+	# Create intermediate dirs using mode 755 as modified by the umask.
+	# This is like FreeBSD 'install' as of 1997-10-28.
+	umask=`umask`
+	case $stripcmd.$umask in
+	  # Optimize common cases.
+	  *[2367][2367]) mkdir_umask=$umask;;
+	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
 
-        posix_mkdir=false
-	# The $RANDOM variable is not portable (e.g., dash).  Use it
-	# here however when possible just to lower collision chance.
-	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+	  *[0-7])
+	    mkdir_umask=`expr $umask + 22 \
+	      - $umask % 100 % 40 + $umask % 20 \
+	      - $umask % 10 % 4 + $umask % 2
+	    `;;
+	  *) mkdir_umask=$umask,go-w;;
+	esac
 
-	trap '
-	  ret=$?
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null
-	  exit $ret
-	' 0
-
-	# Because "mkdir -p" follows existing symlinks and we likely work
-	# directly in world-writeable /tmp, make sure that the '$tmpdir'
-	# directory is successfully created first before we actually test
-	# 'mkdir -p'.
-	if (umask $mkdir_umask &&
-	    $mkdirprog $mkdir_mode "$tmpdir" &&
-	    exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
-	then
-	  if test -z "$dir_arg" || {
-	       # Check for POSIX incompatibilities with -m.
-	       # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-	       # other-writable bit of parent directory when it shouldn't.
-	       # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-	       test_tmpdir="$tmpdir/a"
-	       ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
-	       case $ls_ld_tmpdir in
-		 d????-?r-*) different_mode=700;;
-		 d????-?--*) different_mode=755;;
-		 *) false;;
-	       esac &&
-	       $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
-		 ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
-		 test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-	       }
-	     }
-	  then posix_mkdir=:
-	  fi
-	  rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
+	# With -d, create the new directory with the user-specified mode.
+	# Otherwise, rely on $mkdir_umask.
+	if test -n "$dir_arg"; then
+	  mkdir_mode=-m$mode
 	else
-	  # Remove any dirs left behind by ancient mkdir implementations.
-	  rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
+	  mkdir_mode=
 	fi
-	trap '' 0;;
+
+	posix_mkdir=false
+	case $umask in
+	  *[123567][0-7][0-7])
+	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
+	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+	    ;;
+	  *)
+	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+	    if (umask $mkdir_umask &&
+		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+	    then
+	      if test -z "$dir_arg" || {
+		   # Check for POSIX incompatibilities with -m.
+		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+		   # other-writeable bit of parent directory when it shouldn't.
+		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
+		   case $ls_ld_tmpdir in
+		     d????-?r-*) different_mode=700;;
+		     d????-?--*) different_mode=755;;
+		     *) false;;
+		   esac &&
+		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+		   }
+		 }
+	      then posix_mkdir=:
+	      fi
+	      rmdir "$tmpdir/d" "$tmpdir"
+	    else
+	      # Remove any dirs left behind by ancient mkdir implementations.
+	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+	    fi
+	    trap '' 0;;
+	esac;;
     esac
 
     if
       $posix_mkdir && (
-        umask $mkdir_umask &&
-        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+	umask $mkdir_umask &&
+	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
       )
     then :
     else
 
-      # mkdir does not conform to POSIX,
+      # The umask is ridiculous, or mkdir does not conform to POSIX,
       # or it failed possibly due to a race condition.  Create the
       # directory the slow way, step by step, checking for races as we go.
 
       case $dstdir in
-        /*) prefix='/';;
-        [-=\(\)!]*) prefix='./';;
-        *)  prefix='';;
+	/*) prefix=/ ;;
+	-*) prefix=./ ;;
+	*)  prefix= ;;
+      esac
+
+      case $posix_glob in
+        '')
+	  if (set -f) 2>/dev/null; then
+	    posix_glob=true
+	  else
+	    posix_glob=false
+	  fi ;;
       esac
 
       oIFS=$IFS
       IFS=/
-      set -f
+      $posix_glob && set -f
       set fnord $dstdir
       shift
-      set +f
+      $posix_glob && set +f
       IFS=$oIFS
 
       prefixes=
 
       for d
       do
-        test X"$d" = X && continue
+	test -z "$d" && continue
 
-        prefix=$prefix$d
-        if test -d "$prefix"; then
-          prefixes=
-        else
-          if $posix_mkdir; then
-            (umask $mkdir_umask &&
-             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-            # Don't fail if two instances are running concurrently.
-            test -d "$prefix" || exit 1
-          else
-            case $prefix in
-              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-              *) qprefix=$prefix;;
-            esac
-            prefixes="$prefixes '$qprefix'"
-          fi
-        fi
-        prefix=$prefix/
+	prefix=$prefix$d
+	if test -d "$prefix"; then
+	  prefixes=
+	else
+	  if $posix_mkdir; then
+	    (umask=$mkdir_umask &&
+	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+	    # Don't fail if two instances are running concurrently.
+	    test -d "$prefix" || exit 1
+	  else
+	    case $prefix in
+	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+	      *) qprefix=$prefix;;
+	    esac
+	    prefixes="$prefixes '$qprefix'"
+	  fi
+	fi
+	prefix=$prefix/
       done
 
       if test -n "$prefixes"; then
-        # Don't fail if two instances are running concurrently.
-        (umask $mkdir_umask &&
-         eval "\$doit_exec \$mkdirprog $prefixes") ||
-          test -d "$dstdir" || exit 1
-        obsolete_mkdir_used=true
+	# Don't fail if two instances are running concurrently.
+	(umask $mkdir_umask &&
+	 eval "\$doit_exec \$mkdirprog $prefixes") ||
+	  test -d "$dstdir" || exit 1
+	obsolete_mkdir_used=true
       fi
     fi
   fi
@@ -449,25 +444,14 @@ do
   else
 
     # Make a couple of temp file names in the proper directory.
-    dsttmp=${dstdirslash}_inst.$$_
-    rmtmp=${dstdirslash}_rm.$$_
+    dsttmp=$dstdir/_inst.$$_
+    rmtmp=$dstdir/_rm.$$_
 
     # Trap to clean up those temp files at exit.
     trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
 
     # Copy the file name to the temp name.
-    (umask $cp_umask &&
-     { test -z "$stripcmd" || {
-	 # Create $dsttmp read-write so that cp doesn't create it read-only,
-	 # which would cause strip to fail.
-	 if test -z "$doit"; then
-	   : >"$dsttmp" # No need to fork-exec 'touch'.
-	 else
-	   $doit touch "$dsttmp"
-	 fi
-       }
-     } &&
-     $doit_exec $cpprog "$src" "$dsttmp") &&
+    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
 
     # and set any options; do chmod last to preserve setuid bits.
     #
@@ -475,67 +459,49 @@ do
     # ignore errors from any of these, just make sure not to ignore
     # errors from the above "$doit $cpprog $src $dsttmp" command.
     #
-    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
-    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
-    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
-    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \
+      && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \
+      && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \
+      && { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
 
-    # If -C, don't bother to copy if it wouldn't change the file.
-    if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
-       set -f &&
-       set X $old && old=:$2:$4:$5:$6 &&
-       set X $new && new=:$2:$4:$5:$6 &&
-       set +f &&
-       test "$old" = "$new" &&
-       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
-    then
-      rm -f "$dsttmp"
-    else
-      # If $backupsuffix is set, and the file being installed
-      # already exists, attempt a backup.  Don't worry if it fails,
-      # e.g., if mv doesn't support -f.
-      if test -n "$backupsuffix" && test -f "$dst"; then
-        $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null
-      fi
+    # Now rename the file to the real destination.
+    { $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null \
+      || {
+	   # The rename failed, perhaps because mv can't rename something else
+	   # to itself, or perhaps because mv is so ancient that it does not
+	   # support -f.
 
-      # Rename the file to the real destination.
-      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+	   # Now remove or move aside any old file at destination location.
+	   # We try this two ways since rm can't unlink itself on some
+	   # systems and the destination file might be busy for other
+	   # reasons.  In this case, the final cleanup might fail but the new
+	   # file should still install successfully.
+	   {
+	     if test -f "$dst"; then
+	       $doit $rmcmd -f "$dst" 2>/dev/null \
+	       || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null \
+		     && { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }; }\
+	       || {
+		 echo "$0: cannot unlink or rename $dst" >&2
+		 (exit 1); exit 1
+	       }
+	     else
+	       :
+	     fi
+	   } &&
 
-      # The rename failed, perhaps because mv can't rename something else
-      # to itself, or perhaps because mv is so ancient that it does not
-      # support -f.
-      {
-        # Now remove or move aside any old file at destination location.
-        # We try this two ways since rm can't unlink itself on some
-        # systems and the destination file might be busy for other
-        # reasons.  In this case, the final cleanup might fail but the new
-        # file should still install successfully.
-        {
-          test ! -f "$dst" ||
-          $doit $rmcmd "$dst" 2>/dev/null ||
-          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-            { $doit $rmcmd "$rmtmp" 2>/dev/null; :; }
-          } ||
-          { echo "$0: cannot unlink or rename $dst" >&2
-            (exit 1); exit 1
-          }
-        } &&
-
-        # Now rename the file to the real destination.
-        $doit $mvcmd "$dsttmp" "$dst"
-      }
-    fi || exit 1
+	   # Now rename the file to the real destination.
+	   $doit $mvcmd "$dsttmp" "$dst"
+	 }
+    } || exit 1
 
     trap '' 0
   fi
 done
 
 # Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'write-file-hooks 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
-# time-stamp-end: "; # UTC"
+# time-stamp-end: "$"
 # End:

autoconf/py-compile

@@ -1,9 +1,9 @@
 #!/bin/sh
 # py-compile - Compile a Python program
 
-scriptversion=2023-03-30.00; # UTC
+scriptversion=2011-06-08.12; # UTC
 
-# Copyright (C) 2000-2023 Free Software Foundation, Inc.
+# Copyright (C) 2000-2014 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@ scriptversion=2023-03-30.00; # UTC
 # GNU General Public License for more details.
 
 # You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -27,7 +27,7 @@ scriptversion=2023-03-30.00; # UTC
 # bugs to <bug-automake@gnu.org> or send patches to
 # <automake-patches@gnu.org>.
 
-if test -z "$PYTHON"; then
+if [ -z "$PYTHON" ]; then
   PYTHON=python
 fi
 
@@ -62,19 +62,13 @@ while test $# -ne 0; do
       ;;
     -h|--help)
       cat <<\EOF
-Usage: py-compile [options] FILES...
+Usage: py-compile [--help] [--version] [--basedir DIR] [--destdir DIR] FILES..."
 
 Byte compile some python scripts FILES.  Use --destdir to specify any
 leading directory path to the FILES that you don't want to include in the
 byte compiled file.  Specify --basedir for any additional path information you
 do want to be shown in the byte compiled file.
 
-Options:
-  --basedir DIR   Prefix all FILES with DIR, and include in error messages.
-  --destdir DIR   Prefix all FILES with DIR before compiling.
-  -v, --version   Display version information.
-  -h, --help      This help screen.
-
 Example:
   py-compile --destdir /tmp/pkg-root --basedir /usr/share/test test.py test2.py
 
@@ -100,143 +94,77 @@ EOF
   shift
 done
 
-if test $# -eq 0; then
-  usage_error "no files given"
+files=$*
+if test -z "$files"; then
+    usage_error "no files given"
 fi
 
 # if basedir was given, then it should be prepended to filenames before
 # byte compilation.
-if test -z "$basedir"; then
-  pathtrans="path = file"
+if [ -z "$basedir" ]; then
+    pathtrans="path = file"
 else
-  pathtrans="path = os.path.join('$basedir', file)"
+    pathtrans="path = os.path.join('$basedir', file)"
 fi
 
 # if destdir was given, then it needs to be prepended to the filename to
 # byte compile but not go into the compiled file.
-if test -z "$destdir"; then
-  filetrans="filepath = path"
+if [ -z "$destdir" ]; then
+    filetrans="filepath = path"
 else
-  filetrans="filepath = os.path.normpath('$destdir' + os.sep + path)"
+    filetrans="filepath = os.path.normpath('$destdir' + os.sep + path)"
 fi
 
-python_major=`$PYTHON -c 'import sys; print(sys.version_info[0])'`
-if test -z "$python_major"; then
-  usage_error "could not determine $PYTHON major version"
-fi
-
-case $python_major in
-[01])
-  usage_error "python version 0.x and 1.x not supported"
-  ;;
-esac
-
-python_minor=`$PYTHON -c 'import sys; print(sys.version_info[1])'`
-
-# NB: When adding support for newer versions, prefer copying & adding new cases
-# rather than try to keep things merged with shell variables.
-
-# First byte compile (no optimization) all the modules.
-# This works for all currently known Python versions.
 $PYTHON -c "
-import sys, os, py_compile
+import sys, os, py_compile, imp
 
-try:
-    import importlib
-except ImportError:
-    importlib = None
-
-# importlib.util.cache_from_source was added in 3.4
-if (
-        hasattr(importlib, 'util')
-        and hasattr(importlib.util, 'cache_from_source')
-):
-    destpath = importlib.util.cache_from_source
-else:
-    destpath = lambda filepath: filepath + 'c'
+files = '''$files'''
 
 sys.stdout.write('Byte-compiling python modules...\n')
-for file in sys.argv[1:]:
+for file in files.split():
     $pathtrans
     $filetrans
-    if (
-            not os.path.exists(filepath)
-            or not (len(filepath) >= 3 and filepath[-3:] == '.py')
-     ):
-        continue
-    sys.stdout.write(file + ' ')
+    if not os.path.exists(filepath) or not (len(filepath) >= 3
+                                            and filepath[-3:] == '.py'):
+	    continue
+    sys.stdout.write(file)
     sys.stdout.flush()
-    py_compile.compile(filepath, destpath(filepath), path)
-sys.stdout.write('\n')" "$@" || exit $?
+    if hasattr(imp, 'get_tag'):
+        py_compile.compile(filepath, imp.cache_from_source(filepath), path)
+    else:
+        py_compile.compile(filepath, filepath + 'c', path)
+sys.stdout.write('\n')" || exit $?
 
-# Then byte compile w/optimization all the modules.
+# this will fail for python < 1.5, but that doesn't matter ...
 $PYTHON -O -c "
-import sys, os, py_compile
+import sys, os, py_compile, imp
 
-try:
-    import importlib
-except ImportError:
-    importlib = None
-
-# importlib.util.cache_from_source was added in 3.4
-if (
-        hasattr(importlib, 'util')
-        and hasattr(importlib.util, 'cache_from_source')
-):
-    destpath = importlib.util.cache_from_source
-else:
-    destpath = lambda filepath: filepath + 'o'
-
-# pypy2 does not use .pyo optimization
-if sys.version_info.major <= 2 and hasattr(sys, 'pypy_translation_info'):
+# pypy does not use .pyo optimization
+if hasattr(sys, 'pypy_translation_info'):
     sys.exit(0)
 
+files = '''$files'''
 sys.stdout.write('Byte-compiling python modules (optimized versions) ...\n')
-for file in sys.argv[1:]:
+for file in files.split():
     $pathtrans
     $filetrans
-    if (
-            not os.path.exists(filepath)
-            or not (len(filepath) >= 3 and filepath[-3:] == '.py')
-    ):
-        continue
-    sys.stdout.write(file + ' ')
+    if not os.path.exists(filepath) or not (len(filepath) >= 3
+                                            and filepath[-3:] == '.py'):
+	    continue
+    sys.stdout.write(file)
     sys.stdout.flush()
-    py_compile.compile(filepath, destpath(filepath), path)
-sys.stdout.write('\n')" "$@" 2>/dev/null || exit $?
-
-# Then byte compile w/more optimization.
-# Only do this for Python 3.5+, see https://bugs.gnu.org/38043 for background.
-case $python_major.$python_minor in
-2.*|3.[0-4])
-  ;;
-*)
-  $PYTHON -OO -c "
-import sys, os, py_compile, importlib
-
-sys.stdout.write('Byte-compiling python modules (more optimized versions)'
-                 ' ...\n')
-for file in sys.argv[1:]:
-    $pathtrans
-    $filetrans
-    if (
-            not os.path.exists(filepath)
-            or not (len(filepath) >= 3 and filepath[-3:] == '.py')
-    ):
-        continue
-    sys.stdout.write(file + ' ')
-    sys.stdout.flush()
-    py_compile.compile(filepath, importlib.util.cache_from_source(filepath), path)
-sys.stdout.write('\n')" "$@" 2>/dev/null || exit $?
-  ;;
-esac
+    if hasattr(imp, 'get_tag'):
+        py_compile.compile(filepath, imp.cache_from_source(filepath, False), path)
+    else:
+        py_compile.compile(filepath, filepath + 'o', path)
+sys.stdout.write('\n')" 2>/dev/null || :
 
 # Local Variables:
 # mode: shell-script
 # sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'write-file-hooks 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC0"
+# time-stamp-time-zone: "UTC"
 # time-stamp-end: "; # UTC"
 # End:

base/Makefile

@@ -17,9 +17,12 @@
 # NOTE: this Makefile only works as 'include' for toplevel Makefile
 #       which defined all top_* variables
 
+#BASE_SOURCE=\
+#	base/data-struct/hash.c \
+#	base/data-struct/list.c \
+#	base/data-struct/radix-tree.c
+
 BASE_SOURCE=\
-	base/data-struct/hash.c \
-	base/data-struct/list.c \
 	base/data-struct/radix-tree.c
 
 BASE_TARGET = base/libbase.a
@@ -31,10 +34,10 @@ CLEAN_TARGETS += $(BASE_DEPENDS) $(BASE_OBJECTS) \
 	$(BASE_TARGET)
 
 $(BASE_TARGET): $(BASE_OBJECTS)
-	$(SHOW) "    [AR] $@"
+	@echo "    [AR] $@"
 	$(Q) $(RM) $@
 	$(Q) $(AR) rsv $@ $(BASE_OBJECTS) > /dev/null
 
-ifeq ("$(USE_TRACKING)","yes")
+ifeq ("$(DEPENDS)","yes")
 -include $(BASE_DEPENDS)
 endif

base/data-struct/hash.c

@@ -1,477 +0,0 @@
-/*
- * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2011 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
- */
-
-#include "device_mapper/misc/dmlib.h"
-#include "base/memory/zalloc.h"
-#include "hash.h"
-
-struct dm_hash_node {
-	struct dm_hash_node *next;
-	void *data;
-	unsigned data_len;
-	unsigned keylen;
-	unsigned hash;
-	char key[0];
-};
-
-struct dm_hash_table {
-	unsigned num_nodes;
-	unsigned num_hint;
-	unsigned mask_slots;    /* (slots - 1) -> used as hash mask */
-	unsigned collisions;    /* Collisions of hash keys */
-	unsigned search;        /* How many keys were searched */
-	unsigned found;         /* How many nodes were found */
-	unsigned same_hash;     /* Was there a collision with same masked hash and len ? */
-	struct dm_hash_node **slots;
-};
-
-#if 0 /* TO BE REMOVED */
-static unsigned _hash(const void *key, unsigned len)
-{
-	/* Permutation of the Integers 0 through 255 */
-	static const unsigned char _nums[] = {
-	1, 14, 110, 25, 97, 174, 132, 119, 138, 170, 125, 118, 27, 233, 140, 51,
-	87, 197, 177, 107, 234, 169, 56, 68, 30, 7, 173, 73, 188, 40, 36, 65,
-	49, 213, 104, 190, 57, 211, 148, 223, 48, 115, 15, 2, 67, 186, 210, 28,
-	12, 181, 103, 70, 22, 58, 75, 78, 183, 167, 238, 157, 124, 147, 172,
-	144,
-	176, 161, 141, 86, 60, 66, 128, 83, 156, 241, 79, 46, 168, 198, 41, 254,
-	178, 85, 253, 237, 250, 154, 133, 88, 35, 206, 95, 116, 252, 192, 54,
-	221,
-	102, 218, 255, 240, 82, 106, 158, 201, 61, 3, 89, 9, 42, 155, 159, 93,
-	166, 80, 50, 34, 175, 195, 100, 99, 26, 150, 16, 145, 4, 33, 8, 189,
-	121, 64, 77, 72, 208, 245, 130, 122, 143, 55, 105, 134, 29, 164, 185,
-	194,
-	193, 239, 101, 242, 5, 171, 126, 11, 74, 59, 137, 228, 108, 191, 232,
-	139,
-	6, 24, 81, 20, 127, 17, 91, 92, 251, 151, 225, 207, 21, 98, 113, 112,
-	84, 226, 18, 214, 199, 187, 13, 32, 94, 220, 224, 212, 247, 204, 196,
-	43,
-	249, 236, 45, 244, 111, 182, 153, 136, 129, 90, 217, 202, 19, 165, 231,
-	71,
-	230, 142, 96, 227, 62, 179, 246, 114, 162, 53, 160, 215, 205, 180, 47,
-	109,
-	44, 38, 31, 149, 135, 0, 216, 52, 63, 23, 37, 69, 39, 117, 146, 184,
-	163, 200, 222, 235, 248, 243, 219, 10, 152, 131, 123, 229, 203, 76, 120,
-	209
-	};
-
-	const uint8_t *str = key;
-	unsigned h = 0, g;
-	unsigned i;
-
-	for (i = 0; i < len; i++) {
-		h <<= 4;
-		h += _nums[*str++];
-		g = h & ((unsigned) 0xf << 16u);
-		if (g) {
-			h ^= g >> 16u;
-			h ^= g >> 5u;
-		}
-	}
-
-	return h;
-}
-
-/* In-kernel DM hashing, still lots of collisions */
-static unsigned _hash_in_kernel(const char *key, unsigned len)
-{
-	const unsigned char *str = (unsigned char *)key;
-	const unsigned hash_mult = 2654435387U;
-	unsigned hash = 0, i;
-
-	for (i = 0; i < len; ++i)
-		hash = (hash + str[i]) * hash_mult;
-
-	return hash;
-}
-#endif
-
-#undef get16bits
-#if (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)))
-#define get16bits(d) (*((const uint16_t *) (d)))
-#endif
-
-#if !defined (get16bits)
-#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
-                       +(uint32_t)(((const uint8_t *)(d))[0]) )
-#endif
-
-/*
- * Adapted Bob Jenkins hash to read by 2 bytes if possible.
- * https://secure.wikimedia.org/wikipedia/en/wiki/Jenkins_hash_function
- *
- * Reduces amount of hash collisions
- */
-static unsigned _hash(const void *key, unsigned len)
-{
-	const uint8_t *str = (uint8_t*) key;
-	unsigned hash = 0, i;
-	unsigned sz = len / 2;
-
-	for(i = 0; i < sz; ++i) {
-		hash += get16bits(str + 2 * i);
-		hash += (hash << 10);
-		hash ^= (hash >> 6);
-	}
-
-	if (len & 1) {
-		hash += str[len - 1];
-		hash += (hash << 10);
-		hash ^= (hash >> 6);
-	}
-
-	hash += (hash << 3);
-	hash ^= (hash >> 11);
-	hash += (hash << 15);
-
-	return hash;
-}
-
-static struct dm_hash_node *_create_node(const void *key, unsigned len)
-{
-	struct dm_hash_node *n = malloc(sizeof(*n) + len);
-
-	if (n) {
-		memcpy(n->key, key, len);
-		n->keylen = len;
-	}
-
-	return n;
-}
-
-struct dm_hash_table *dm_hash_create(unsigned size_hint)
-{
-	size_t len;
-	unsigned new_size = 16u;
-	struct dm_hash_table *hc = zalloc(sizeof(*hc));
-
-	if (!hc) {
-		log_error("Failed to allocate memory for hash.");
-		return 0;
-	}
-
-	hc->num_hint = size_hint;
-
-	/* round size hint up to a power of two */
-	while (new_size < size_hint)
-		new_size = new_size << 1;
-
-	hc->mask_slots = new_size - 1;
-	len = sizeof(*(hc->slots)) * new_size;
-	if (!(hc->slots = zalloc(len))) {
-		free(hc);
-		log_error("Failed to allocate slots for hash.");
-		return 0;
-	}
-
-	return hc;
-}
-
-static void _free_nodes(struct dm_hash_table *t)
-{
-	struct dm_hash_node *c, *n;
-	unsigned i;
-
-#ifdef DEBUG
-	log_debug("Free hash hint:%d slots:%d nodes:%d (s:%d f:%d c:%d h:%d)",
-		  t->num_hint, t->mask_slots + 1, t->num_nodes,
-		  t->search, t->found, t->collisions, t->same_hash);
-#endif
-
-	if (!t->num_nodes)
-		return;
-
-	for (i = 0; i <= t->mask_slots; i++)
-		for (c = t->slots[i]; c; c = n) {
-			n = c->next;
-			free(c);
-		}
-}
-
-void dm_hash_destroy(struct dm_hash_table *t)
-{
-	_free_nodes(t);
-	free(t->slots);
-	free(t);
-}
-
-static struct dm_hash_node **_findh(struct dm_hash_table *t, const void *key,
-				    uint32_t len, unsigned hash)
-{
-	struct dm_hash_node **c;
-
-	++t->search;
-	for (c = &t->slots[hash & t->mask_slots]; *c; c = &((*c)->next)) {
-		if ((*c)->keylen == len && (*c)->hash == hash) {
-			if (!memcmp(key, (*c)->key, len)) {
-				++t->found;
-				break;
-			}
-			++t->same_hash;
-		}
-		++t->collisions;
-	}
-
-	return c;
-}
-
-static struct dm_hash_node **_find(struct dm_hash_table *t, const void *key,
-				   uint32_t len)
-{
-	return _findh(t, key, len, _hash(key, len));
-}
-
-void *dm_hash_lookup_binary(struct dm_hash_table *t, const void *key,
-			    uint32_t len)
-{
-	struct dm_hash_node **c = _find(t, key, len);
-
-	return *c ? (*c)->data : 0;
-}
-
-int dm_hash_insert_binary(struct dm_hash_table *t, const void *key,
-			  uint32_t len, void *data)
-{
-	unsigned hash = _hash(key, len);
-	struct dm_hash_node **c = _findh(t, key, len, hash);
-
-	if (*c)
-		(*c)->data = data;
-	else {
-		struct dm_hash_node *n = _create_node(key, len);
-
-		if (!n)
-			return 0;
-
-		n->data = data;
-		n->hash = hash;
-		n->next = 0;
-		*c = n;
-		t->num_nodes++;
-	}
-
-	return 1;
-}
-
-void dm_hash_remove_binary(struct dm_hash_table *t, const void *key,
-			uint32_t len)
-{
-	struct dm_hash_node **c = _find(t, key, len);
-
-	if (*c) {
-		struct dm_hash_node *old = *c;
-		*c = (*c)->next;
-		free(old);
-		t->num_nodes--;
-	}
-}
-
-void *dm_hash_lookup(struct dm_hash_table *t, const char *key)
-{
-	return dm_hash_lookup_binary(t, key, strlen(key) + 1);
-}
-
-int dm_hash_insert(struct dm_hash_table *t, const char *key, void *data)
-{
-	return dm_hash_insert_binary(t, key, strlen(key) + 1, data);
-}
-
-void dm_hash_remove(struct dm_hash_table *t, const char *key)
-{
-	dm_hash_remove_binary(t, key, strlen(key) + 1);
-}
-
-static struct dm_hash_node **_find_str_with_val(struct dm_hash_table *t,
-					        const void *key, const void *val,
-					        uint32_t len, uint32_t val_len)
-{
-	struct dm_hash_node **c;
-	unsigned h;
-       
-	h = _hash(key, len) & t->mask_slots;
-
-	for (c = &t->slots[h]; *c; c = &((*c)->next)) {
-		if ((*c)->keylen != len)
-			continue;
-
-		if (!memcmp(key, (*c)->key, len) && (*c)->data) {
-			if (((*c)->data_len == val_len) &&
-			    !memcmp(val, (*c)->data, val_len))
-				return c;
-		}
-	}
-
-	return NULL;
-}
-
-int dm_hash_insert_allow_multiple(struct dm_hash_table *t, const char *key,
-				  const void *val, uint32_t val_len)
-{
-	struct dm_hash_node *n;
-	struct dm_hash_node *first;
-	int len = strlen(key) + 1;
-	unsigned h;
-
-	n = _create_node(key, len);
-	if (!n)
-		return 0;
-
-	n->data = (void *)val;
-	n->data_len = val_len;
-
-	h = _hash(key, len) & t->mask_slots;
-
-	first = t->slots[h];
-
-	if (first)
-		n->next = first;
-	else
-		n->next = 0;
-	t->slots[h] = n;
-
-	t->num_nodes++;
-	return 1;
-}
-
-/*
- * Look through multiple entries with the same key for one that has a
- * matching val and return that.  If none have matching val, return NULL.
- */
-void *dm_hash_lookup_with_val(struct dm_hash_table *t, const char *key,
-			      const void *val, uint32_t val_len)
-{
-	struct dm_hash_node **c;
-
-	c = _find_str_with_val(t, key, val, strlen(key) + 1, val_len);
-
-	return (c && *c) ? (*c)->data : 0;
-}
-
-/*
- * Look through multiple entries with the same key for one that has a
- * matching val and remove that.
- */
-void dm_hash_remove_with_val(struct dm_hash_table *t, const char *key,
-			     const void *val, uint32_t val_len)
-{
-	struct dm_hash_node **c;
-
-	c = _find_str_with_val(t, key, val, strlen(key) + 1, val_len);
-
-	if (c && *c) {
-		struct dm_hash_node *old = *c;
-		*c = (*c)->next;
-		free(old);
-		t->num_nodes--;
-	}
-}
-
-/*
- * Look up the value for a key and count how many
- * entries have the same key.
- *
- * If no entries have key, return NULL and set count to 0.
- *
- * If one entry has the key, the function returns the val,
- * and sets count to 1.
- *
- * If N entries have the key, the function returns the val
- * from the first entry, and sets count to N.
- */
-void *dm_hash_lookup_with_count(struct dm_hash_table *t, const char *key, int *count)
-{
-	struct dm_hash_node **c;
-	struct dm_hash_node **c1 = NULL;
-	uint32_t len = strlen(key) + 1;
-	unsigned h;
-
-	*count = 0;
-
-	h = _hash(key, len) & t->mask_slots;
-
-	for (c = &t->slots[h]; *c; c = &((*c)->next)) {
-		if ((*c)->keylen != len)
-			continue;
-
-		if (!memcmp(key, (*c)->key, len)) {
-			(*count)++;
-			if (!c1)
-				c1 = c;
-		}
-	}
-
-	if (!c1)
-		return NULL;
-	else
-		return *c1 ? (*c1)->data : 0;
-}
-
-unsigned dm_hash_get_num_entries(struct dm_hash_table *t)
-{
-	return t->num_nodes;
-}
-
-void dm_hash_iter(struct dm_hash_table *t, dm_hash_iterate_fn f)
-{
-	struct dm_hash_node *c, *n;
-	unsigned i;
-
-	for (i = 0; i <= t->mask_slots; i++)
-		for (c = t->slots[i]; c; c = n) {
-			n = c->next;
-			f(c->data);
-		}
-}
-
-void dm_hash_wipe(struct dm_hash_table *t)
-{
-	_free_nodes(t);
-	memset(t->slots, 0, sizeof(struct dm_hash_node *) * (t->mask_slots + 1));
-	t->num_nodes = t->collisions = t->search = t->same_hash = 0u;
-}
-
-char *dm_hash_get_key(struct dm_hash_table *t __attribute__((unused)),
-		      struct dm_hash_node *n)
-{
-	return n->key;
-}
-
-void *dm_hash_get_data(struct dm_hash_table *t __attribute__((unused)),
-		       struct dm_hash_node *n)
-{
-	return n->data;
-}
-
-static struct dm_hash_node *_next_slot(struct dm_hash_table *t, unsigned s)
-{
-	struct dm_hash_node *c = NULL;
-	unsigned i;
-
-	for (i = s; i <= t->mask_slots && !c; i++)
-		c = t->slots[i];
-
-	return c;
-}
-
-struct dm_hash_node *dm_hash_get_first(struct dm_hash_table *t)
-{
-	return _next_slot(t, 0);
-}
-
-struct dm_hash_node *dm_hash_get_next(struct dm_hash_table *t, struct dm_hash_node *n)
-{
-	return n->next ? n->next : _next_slot(t, (n->hash & t->mask_slots) + 1);
-}

base/data-struct/hash.h

@@ -1,94 +0,0 @@
-#ifndef BASE_DATA_STRUCT_HASH_H
-#define BASE_DATA_STRUCT_HASH_H
-
-#include <stdint.h>
-
-//----------------------------------------------------------------
-
-struct dm_hash_table;
-struct dm_hash_node;
-
-typedef void (*dm_hash_iterate_fn) (void *data);
-
-struct dm_hash_table *dm_hash_create(unsigned size_hint)
-	__attribute__((__warn_unused_result__));
-void dm_hash_destroy(struct dm_hash_table *t);
-void dm_hash_wipe(struct dm_hash_table *t);
-
-void *dm_hash_lookup(struct dm_hash_table *t, const char *key);
-int dm_hash_insert(struct dm_hash_table *t, const char *key, void *data);
-void dm_hash_remove(struct dm_hash_table *t, const char *key);
-
-void *dm_hash_lookup_binary(struct dm_hash_table *t, const void *key, uint32_t len);
-int dm_hash_insert_binary(struct dm_hash_table *t, const void *key, uint32_t len,
-			  void *data);
-void dm_hash_remove_binary(struct dm_hash_table *t, const void *key, uint32_t len);
-
-unsigned dm_hash_get_num_entries(struct dm_hash_table *t);
-void dm_hash_iter(struct dm_hash_table *t, dm_hash_iterate_fn f);
-
-char *dm_hash_get_key(struct dm_hash_table *t, struct dm_hash_node *n);
-void *dm_hash_get_data(struct dm_hash_table *t, struct dm_hash_node *n);
-struct dm_hash_node *dm_hash_get_first(struct dm_hash_table *t);
-struct dm_hash_node *dm_hash_get_next(struct dm_hash_table *t, struct dm_hash_node *n);
-
-/*
- * dm_hash_insert() replaces the value of an existing
- * entry with a matching key if one exists.  Otherwise
- * it adds a new entry.
- *
- * dm_hash_insert_with_val() inserts a new entry if
- * another entry with the same key already exists.
- * val_len is the size of the data being inserted.
- *
- * If two entries with the same key exist,
- * (added using dm_hash_insert_allow_multiple), then:
- * . dm_hash_lookup() returns the first one it finds, and
- *   dm_hash_lookup_with_val() returns the one with a matching
- *   val_len/val.
- * . dm_hash_remove() removes the first one it finds, and
- *   dm_hash_remove_with_val() removes the one with a matching
- *   val_len/val.
- *
- * If a single entry with a given key exists, and it has
- * zero val_len, then:
- * . dm_hash_lookup() returns it
- * . dm_hash_lookup_with_val(val_len=0) returns it
- * . dm_hash_remove() removes it
- * . dm_hash_remove_with_val(val_len=0) removes it
- *
- * dm_hash_lookup_with_count() is a single call that will
- * both lookup a key's value and check if there is more
- * than one entry with the given key.
- *
- * (It is not meant to retrieve all the entries with the
- * given key.  In the common case where a single entry exists
- * for the key, it is useful to have a single call that will
- * both look up the value and indicate if multiple values
- * exist for the key.)
- *
- * dm_hash_lookup_with_count:
- * . If no entries exist, the function returns NULL, and
- *   the count is set to 0.
- * . If only one entry exists, the value of that entry is
- *   returned and count is set to 1.
- * . If N entries exists, the value of the first entry is
- *   returned and count is set to N.
- */
-
-void *dm_hash_lookup_with_val(struct dm_hash_table *t, const char *key,
-                              const void *val, uint32_t val_len);
-void dm_hash_remove_with_val(struct dm_hash_table *t, const char *key,
-                             const void *val, uint32_t val_len);
-int dm_hash_insert_allow_multiple(struct dm_hash_table *t, const char *key,
-                                  const void *val, uint32_t val_len);
-void *dm_hash_lookup_with_count(struct dm_hash_table *t, const char *key, int *count);
-
-
-#define dm_hash_iterate(v, h) \
-	for (v = dm_hash_get_first((h)); v; \
-	     v = dm_hash_get_next((h), v))
-
-//----------------------------------------------------------------
-
-#endif

base/data-struct/list.c

@@ -1,170 +0,0 @@
-/*
- * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2010 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 "list.h"
-
-#include <assert.h>
-#include <stdlib.h>
-
-/*
- * Initialise a list before use.
- * The list head's next and previous pointers point back to itself.
- */
-void dm_list_init(struct dm_list *head)
-{
-	head->n = head->p = head;
-}
-
-/*
- * Insert an element before 'head'.
- * If 'head' is the list head, this adds an element to the end of the list.
- */
-void dm_list_add(struct dm_list *head, struct dm_list *elem)
-{
-	assert(head->n);
-
-	elem->n = head;
-	elem->p = head->p;
-
-	head->p->n = elem;
-	head->p = elem;
-}
-
-/*
- * Insert an element after 'head'.
- * If 'head' is the list head, this adds an element to the front of the list.
- */
-void dm_list_add_h(struct dm_list *head, struct dm_list *elem)
-{
-	assert(head->n);
-
-	elem->n = head->n;
-	elem->p = head;
-
-	head->n->p = elem;
-	head->n = elem;
-}
-
-/*
- * Delete an element from its list.
- * Note that this doesn't change the element itself - it may still be safe
- * to follow its pointers.
- */
-void dm_list_del(struct dm_list *elem)
-{
-	elem->n->p = elem->p;
-	elem->p->n = elem->n;
-}
-
-/*
- * Remove an element from existing list and insert before 'head'.
- */
-void dm_list_move(struct dm_list *head, struct dm_list *elem)
-{
-        dm_list_del(elem);
-        dm_list_add(head, elem);
-}
-
-/*
- * Is the list empty?
- */
-int dm_list_empty(const struct dm_list *head)
-{
-	return head->n == head;
-}
-
-/*
- * Is this the first element of the list?
- */
-int dm_list_start(const struct dm_list *head, const struct dm_list *elem)
-{
-	return elem->p == head;
-}
-
-/*
- * Is this the last element of the list?
- */
-int dm_list_end(const struct dm_list *head, const struct dm_list *elem)
-{
-	return elem->n == head;
-}
-
-/*
- * Return first element of the list or NULL if empty
- */
-struct dm_list *dm_list_first(const struct dm_list *head)
-{
-	return (dm_list_empty(head) ? NULL : head->n);
-}
-
-/*
- * Return last element of the list or NULL if empty
- */
-struct dm_list *dm_list_last(const struct dm_list *head)
-{
-	return (dm_list_empty(head) ? NULL : head->p);
-}
-
-/*
- * Return the previous element of the list, or NULL if we've reached the start.
- */
-struct dm_list *dm_list_prev(const struct dm_list *head, const struct dm_list *elem)
-{
-	return (dm_list_start(head, elem) ? NULL : elem->p);
-}
-
-/*
- * Return the next element of the list, or NULL if we've reached the end.
- */
-struct dm_list *dm_list_next(const struct dm_list *head, const struct dm_list *elem)
-{
-	return (dm_list_end(head, elem) ? NULL : elem->n);
-}
-
-/*
- * Return the number of elements in a list by walking it.
- */
-unsigned int dm_list_size(const struct dm_list *head)
-{
-	unsigned int s = 0;
-	const struct dm_list *v;
-
-	dm_list_iterate(v, head)
-	    s++;
-
-	return s;
-}
-
-/*
- * Join two lists together.
- * This moves all the elements of the list 'head1' to the end of the list
- * 'head', leaving 'head1' empty.
- */
-void dm_list_splice(struct dm_list *head, struct dm_list *head1)
-{
-	assert(head->n);
-	assert(head1->n);
-
-	if (dm_list_empty(head1))
-	    return;
-
-	head1->p->n = head;
-	head1->n->p = head->p;
-
-	head->p->n = head1->n;
-	head->p = head1->p;
-
-	dm_list_init(head1);
-}

base/data-struct/list.h

@@ -1,211 +0,0 @@
-#ifndef BASE_DATA_STRUCT_LIST_H
-#define BASE_DATA_STRUCT_LIST_H
-
-#include "base/memory/container_of.h"
-
-//----------------------------------------------------------------
-
-/*
- * A list consists of a list head plus elements.
- * Each element has 'next' and 'previous' pointers.
- * The list head's pointers point to the first and the last element.
- */
-
-struct dm_list {
-	struct dm_list *n, *p;
-};
-
-/*
- * String list.
- */
-struct dm_str_list {
-	struct dm_list list;
-	const char *str;
-};
-
-/*
- * Initialise a list before use.
- * The list head's next and previous pointers point back to itself.
- */
-#define DM_LIST_HEAD_INIT(name)	 { &(name), &(name) }
-#define DM_LIST_INIT(name)	struct dm_list name = DM_LIST_HEAD_INIT(name)
-void dm_list_init(struct dm_list *head);
-
-/*
- * Insert an element before 'head'.
- * If 'head' is the list head, this adds an element to the end of the list.
- */
-void dm_list_add(struct dm_list *head, struct dm_list *elem);
-
-/*
- * Insert an element after 'head'.
- * If 'head' is the list head, this adds an element to the front of the list.
- */
-void dm_list_add_h(struct dm_list *head, struct dm_list *elem);
-
-/*
- * Delete an element from its list.
- * Note that this doesn't change the element itself - it may still be safe
- * to follow its pointers.
- */
-void dm_list_del(struct dm_list *elem);
-
-/*
- * Remove an element from existing list and insert before 'head'.
- */
-void dm_list_move(struct dm_list *head, struct dm_list *elem);
-
-/*
- * Join 'head1' to the end of 'head'.
- */
-void dm_list_splice(struct dm_list *head, struct dm_list *head1);
-
-/*
- * Is the list empty?
- */
-int dm_list_empty(const struct dm_list *head);
-
-/*
- * Is this the first element of the list?
- */
-int dm_list_start(const struct dm_list *head, const struct dm_list *elem);
-
-/*
- * Is this the last element of the list?
- */
-int dm_list_end(const struct dm_list *head, const struct dm_list *elem);
-
-/*
- * Return first element of the list or NULL if empty
- */
-struct dm_list *dm_list_first(const struct dm_list *head);
-
-/*
- * Return last element of the list or NULL if empty
- */
-struct dm_list *dm_list_last(const struct dm_list *head);
-
-/*
- * Return the previous element of the list, or NULL if we've reached the start.
- */
-struct dm_list *dm_list_prev(const struct dm_list *head, const struct dm_list *elem);
-
-/*
- * Return the next element of the list, or NULL if we've reached the end.
- */
-struct dm_list *dm_list_next(const struct dm_list *head, const struct dm_list *elem);
-
-/*
- * Given the address v of an instance of 'struct dm_list' called 'head'
- * contained in a structure of type t, return the containing structure.
- */
-#define dm_list_struct_base(v, t, head) \
-    container_of(v, t, head)
-
-/*
- * Given the address v of an instance of 'struct dm_list list' contained in
- * a structure of type t, return the containing structure.
- */
-#define dm_list_item(v, t) dm_list_struct_base((v), t, list)
-
-/*
- * Given the address v of one known element e in a known structure of type t,
- * return another element f.
- */
-#define dm_struct_field(v, t, e, f) \
-    (((t *)((uintptr_t)(v) - offsetof(t, e)))->f)
-
-/*
- * Given the address v of a known element e in a known structure of type t,
- * return the list head 'list'
- */
-#define dm_list_head(v, t, e) dm_struct_field(v, t, e, list)
-
-/*
- * Set v to each element of a list in turn.
- */
-#define dm_list_iterate(v, head) \
-	for (v = (head)->n; v != head; v = v->n)
-
-/*
- * Set v to each element in a list in turn, starting from the element
- * in front of 'start'.
- * You can use this to 'unwind' a list_iterate and back out actions on
- * already-processed elements.
- * If 'start' is 'head' it walks the list backwards.
- */
-#define dm_list_uniterate(v, head, start) \
-	for (v = (start)->p; v != head; v = v->p)
-
-/*
- * A safe way to walk a list and delete and free some elements along
- * the way.
- * t must be defined as a temporary variable of the same type as v.
- */
-#define dm_list_iterate_safe(v, t, head) \
-	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)
-
-/*
- * Walk a list, setting 'v' in turn to the containing structure of each item.
- * The containing structure should be the same type as 'v'.
- * The 'struct dm_list' variable within the containing structure is 'field'.
- */
-#define dm_list_iterate_items_gen(v, head, field) \
-	for (v = dm_list_struct_base((head)->n, __typeof__(*v), field); \
-	     &v->field != (head); \
-	     v = dm_list_struct_base(v->field.n, __typeof__(*v), field))
-
-/*
- * Walk a list, setting 'v' in turn to the containing structure of each item.
- * The containing structure should be the same type as 'v'.
- * The list should be 'struct dm_list list' within the containing structure.
- */
-#define dm_list_iterate_items(v, head) dm_list_iterate_items_gen(v, (head), list)
-
-/*
- * Walk a list, setting 'v' in turn to the containing structure of each item.
- * The containing structure should be the same type as 'v'.
- * The 'struct dm_list' variable within the containing structure is 'field'.
- * t must be defined as a temporary variable of the same type as v.
- */
-#define dm_list_iterate_items_gen_safe(v, t, head, field) \
-	for (v = dm_list_struct_base((head)->n, __typeof__(*v), field), \
-	     t = dm_list_struct_base(v->field.n, __typeof__(*v), field); \
-	     &v->field != (head); \
-	     v = t, t = dm_list_struct_base(v->field.n, __typeof__(*v), field))
-/*
- * Walk a list, setting 'v' in turn to the containing structure of each item.
- * The containing structure should be the same type as 'v'.
- * The list should be 'struct dm_list list' within the containing structure.
- * t must be defined as a temporary variable of the same type as v.
- */
-#define dm_list_iterate_items_safe(v, t, head) \
-	dm_list_iterate_items_gen_safe(v, t, (head), list)
-
-/*
- * Walk a list backwards, setting 'v' in turn to the containing structure
- * of each item.
- * The containing structure should be the same type as 'v'.
- * The 'struct dm_list' variable within the containing structure is 'field'.
- */
-#define dm_list_iterate_back_items_gen(v, head, field) \
-	for (v = dm_list_struct_base((head)->p, __typeof__(*v), field); \
-	     &v->field != (head); \
-	     v = dm_list_struct_base(v->field.p, __typeof__(*v), field))
-
-/*
- * Walk a list backwards, setting 'v' in turn to the containing structure
- * of each item.
- * The containing structure should be the same type as 'v'.
- * The list should be 'struct dm_list list' within the containing structure.
- */
-#define dm_list_iterate_back_items(v, head) dm_list_iterate_back_items_gen(v, (head), list)
-
-/*
- * Return the number of elements in a list by walking it.
- */
-unsigned int dm_list_size(const struct dm_list *head);
-
-//----------------------------------------------------------------
-
-#endif

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

@@ -19,7 +19,6 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <ctype.h>
 
 //----------------------------------------------------------------
 
@@ -48,7 +47,7 @@ struct value_chain {
 struct prefix_chain {
 	struct value child;
 	unsigned len;
-	uint8_t prefix[];
+	uint8_t prefix[0];
 };
 
 struct node4 {
@@ -70,7 +69,7 @@ struct node48 {
 };
 
 struct node256 {
-	uint32_t nr_entries;
+        uint32_t nr_entries;
 	struct value values[256];
 };
 
@@ -100,7 +99,7 @@ struct radix_tree *radix_tree_create(radix_value_dtr dtr, void *dtr_context)
 static inline void _dtr(struct radix_tree *rt, union radix_value v)
 {
 	if (rt->dtr)
-		rt->dtr(rt->dtr_context, v);
+        	rt->dtr(rt->dtr_context, v);
 }
 
 // Returns the number of values removed
@@ -119,8 +118,8 @@ static unsigned _free_node(struct radix_tree *rt, struct value v)
 		break;
 
 	case VALUE:
-		_dtr(rt, v.value);
-		nr = 1;
+        	_dtr(rt, v.value);
+        	nr = 1;
 		break;
 
 	case VALUE_CHAIN:
@@ -179,9 +178,9 @@ unsigned radix_tree_size(struct radix_tree *rt)
 	return rt->nr_entries;
 }
 
-static bool _insert(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv);
+static bool _insert(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv);
 
-static bool _insert_unset(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_unset(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	unsigned len = ke - kb;
 
@@ -208,7 +207,7 @@ static bool _insert_unset(struct radix_tree *rt, struct value *v, const uint8_t
 	return true;
 }
 
-static bool _insert_value(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_value(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	unsigned len = ke - kb;
 
@@ -235,7 +234,7 @@ static bool _insert_value(struct radix_tree *rt, struct value *v, const uint8_t
 	return true;
 }
 
-static bool _insert_value_chain(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_value_chain(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	struct value_chain *vc = v->value.ptr;
 	return _insert(rt, &vc->child, kb, ke, rv);
@@ -249,7 +248,7 @@ static unsigned min(unsigned lhs, unsigned rhs)
 		return rhs;
 }
 
-static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	struct prefix_chain *pc = v->value.ptr;
 
@@ -279,7 +278,7 @@ static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, const u
 		pc->len = i;
 
 		if (!_insert(rt, &pc->child, kb + i, ke, rv)) {
-			free(pc->child.value.ptr);
+			free(pc2);
 			return false;
 		}
 
@@ -293,7 +292,6 @@ static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, const u
 		if (pc->len == 1) {
 			n4->values[0] = pc->child;
 			free(pc);
-			v->value.ptr = NULL;
 		} else {
 			memmove(pc->prefix, pc->prefix + 1, pc->len - 1);
 			pc->len--;
@@ -315,7 +313,7 @@ static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, const u
 	return true;
 }
 
-static bool _insert_node4(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_node4(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	struct node4 *n4 = v->value.ptr;
 	if (n4->nr_entries == 4) {
@@ -345,7 +343,7 @@ static bool _insert_node4(struct radix_tree *rt, struct value *v, const uint8_t
 	return true;
 }
 
-static bool _insert_node16(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_node16(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	struct node16 *n16 = v->value.ptr;
 
@@ -384,7 +382,7 @@ static bool _insert_node16(struct radix_tree *rt, struct value *v, const uint8_t
 	return true;
 }
 
-static bool _insert_node48(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_node48(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	struct node48 *n48 = v->value.ptr;
 	if (n48->nr_entries == 48) {
@@ -419,20 +417,20 @@ static bool _insert_node48(struct radix_tree *rt, struct value *v, const uint8_t
 	return true;
 }
 
-static bool _insert_node256(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert_node256(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	struct node256 *n256 = v->value.ptr;
 	bool r, was_unset = n256->values[*kb].type == UNSET;
 
 	r = _insert(rt, n256->values + *kb, kb + 1, ke, rv);
 	if (r && was_unset)
-		n256->nr_entries++;
+        	n256->nr_entries++;
 
 	return r;
 }
 
 // FIXME: the tree should not be touched if insert fails (eg, OOM)
-static bool _insert(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
+static bool _insert(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
 	if (kb == ke) {
 		if (v->type == UNSET) {
@@ -489,10 +487,10 @@ static bool _insert(struct radix_tree *rt, struct value *v, const uint8_t *kb, c
 
 struct lookup_result {
 	struct value *v;
-	const uint8_t *kb;
+	uint8_t *kb;
 };
 
-static struct lookup_result _lookup_prefix(struct value *v, const uint8_t *kb, const uint8_t *ke)
+static struct lookup_result _lookup_prefix(struct value *v, uint8_t *kb, uint8_t *ke)
 {
 	unsigned i;
 	struct value_chain *vc;
@@ -502,7 +500,7 @@ static struct lookup_result _lookup_prefix(struct value *v, const uint8_t *kb, c
 	struct node48 *n48;
 	struct node256 *n256;
 
-	if (kb == ke || !kb) /* extra check for !kb for coverity */
+	if (kb == ke)
 		return (struct lookup_result) {.v = v, .kb = kb};
 
 	switch (v->type) {
@@ -557,32 +555,23 @@ static struct lookup_result _lookup_prefix(struct value *v, const uint8_t *kb, c
 	return (struct lookup_result) {.v = v, .kb = kb};
 }
 
-bool radix_tree_insert(struct radix_tree *rt, const void *key, size_t keylen, union radix_value rv)
+bool radix_tree_insert(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value rv)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
 	struct lookup_result lr = _lookup_prefix(&rt->root, kb, ke);
 	return _insert(rt, lr.v, lr.kb, ke, rv);
 }
 
-int radix_tree_uniq_insert(struct radix_tree *rt, const void *key, size_t keylen, union radix_value rv)
-{
-	unsigned entries = rt->nr_entries;
-	return radix_tree_insert(rt, key, keylen, rv) ?
-		((entries != rt->nr_entries) ? 1 : -1) : 0;
-}
-
 // Note the degrade functions also free the original node.
 static void _degrade_to_n4(struct node16 *n16, struct value *result)
 {
-	struct node4 *n4 = zalloc(sizeof(*n4));
+        struct node4 *n4 = zalloc(sizeof(*n4));
 
 	assert(n4 != NULL);
 
-	n4->nr_entries = n16->nr_entries;
-	memcpy(n4->keys, n16->keys, n16->nr_entries * sizeof(*n4->keys));
-	memcpy(n4->values, n16->values, n16->nr_entries * sizeof(*n4->values));
-	free(n16);
+        n4->nr_entries = n16->nr_entries;
+        memcpy(n4->keys, n16->keys, n16->nr_entries * sizeof(*n4->keys));
+        memcpy(n4->values, n16->values, n16->nr_entries * sizeof(*n4->values));
+        free(n16);
 
 	result->type = NODE4;
 	result->value.ptr = n4;
@@ -591,20 +580,20 @@ static void _degrade_to_n4(struct node16 *n16, struct value *result)
 static void _degrade_to_n16(struct node48 *n48, struct value *result)
 {
 	unsigned i, count = 0;
-	struct node16 *n16 = zalloc(sizeof(*n16));
+        struct node16 *n16 = zalloc(sizeof(*n16));
 
 	assert(n16 != NULL);
 
-	n16->nr_entries = n48->nr_entries;
-	for (i = 0; i < 256; i++) {
-		if (n48->keys[i] < 48) {
-			n16->keys[count] = i;
-			n16->values[count] = n48->values[n48->keys[i]];
-			count++;
-		}
-	}
+        n16->nr_entries = n48->nr_entries;
+        for (i = 0; i < 256; i++) {
+	        if (n48->keys[i] < 48) {
+		        n16->keys[count] = i;
+		        n16->values[count] = n48->values[n48->keys[i]];
+		        count++;
+	        }
+        }
 
-	free(n48);
+        free(n48);
 
 	result->type = NODE16;
 	result->value.ptr = n16;
@@ -612,13 +601,13 @@ static void _degrade_to_n16(struct node48 *n48, struct value *result)
 
 static void _degrade_to_n48(struct node256 *n256, struct value *result)
 {
-	unsigned i, count = 0;
-	struct node48 *n48 = zalloc(sizeof(*n48));
+        unsigned i, count = 0;
+        struct node48 *n48 = zalloc(sizeof(*n48));
 
 	assert(n48 != NULL);
 
-	n48->nr_entries = n256->nr_entries;
-	for (i = 0; i < 256; i++) {
+        n48->nr_entries = n256->nr_entries;
+        for (i = 0; i < 256; i++) {
 		if (n256->values[i].type == UNSET)
 			n48->keys[i] = 48;
 
@@ -627,9 +616,9 @@ static void _degrade_to_n48(struct node256 *n256, struct value *result)
 			n48->values[count] = n256->values[i];
 			count++;
 		}
-	}
+        }
 
-	free(n256);
+        free(n256);
 
 	result->type = NODE48;
 	result->value.ptr = n48;
@@ -643,14 +632,14 @@ static void _erase_elt(void *array, size_t obj_size, unsigned count, unsigned id
 		return;
 
 	memmove(((uint8_t *) array) + (obj_size * idx),
-		((uint8_t *) array) + (obj_size * (idx + 1)),
-		obj_size * (count - idx - 1));
+                ((uint8_t *) array) + (obj_size * (idx + 1)),
+                obj_size * (count - idx - 1));
 
 	// Zero the now unused last elt (set's v.type to UNSET)
 	memset(((uint8_t *) array) + (count - 1) * obj_size, 0, obj_size);
 }
 
-static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb, const uint8_t *ke)
+static bool _remove(struct radix_tree *rt, struct value *root, uint8_t *kb, uint8_t *ke)
 {
 	bool r;
 	unsigned i, j;
@@ -662,27 +651,27 @@ static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb
 	struct node256 *n256;
 
 	if (kb == ke) {
-		if (root->type == VALUE) {
-			root->type = UNSET;
-			_dtr(rt, root->value);
-			return true;
+        	if (root->type == VALUE) {
+                	root->type = UNSET;
+                	_dtr(rt, root->value);
+                	return true;
 
-		} else if (root->type == VALUE_CHAIN) {
+                } else if (root->type == VALUE_CHAIN) {
 			vc = root->value.ptr;
 			_dtr(rt, vc->value);
 			memcpy(root, &vc->child, sizeof(*root));
 			free(vc);
 			return true;
 
-		} else
+                } else
 			return false;
 	}
 
 	switch (root->type) {
 	case UNSET:
 	case VALUE:
-		// this is a value for a prefix of the key
-		return false;
+        	// this is a value for a prefix of the key
+        	return false;
 
 	case VALUE_CHAIN:
 		vc = root->value.ptr;
@@ -697,11 +686,11 @@ static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb
 	case PREFIX_CHAIN:
 		pc = root->value.ptr;
 		if (ke - kb < pc->len)
-			return false;
+        		return false;
 
 		for (i = 0; i < pc->len; i++)
 			if (kb[i] != pc->prefix[i])
-				return false;
+        			return false;
 
 		r = _remove(rt, &pc->child, kb + pc->len, ke);
 		if (r && pc->child.type == UNSET) {
@@ -716,12 +705,12 @@ static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb
 			if (n4->keys[i] == *kb) {
 				r = _remove(rt, n4->values + i, kb + 1, ke);
 				if (r && n4->values[i].type == UNSET) {
-					if (i < n4->nr_entries) {
-						_erase_elt(n4->keys, sizeof(*n4->keys), n4->nr_entries, i);
-						_erase_elt(n4->values, sizeof(*n4->values), n4->nr_entries, i);
-					}
+        				if (i < n4->nr_entries) {
+	        				_erase_elt(n4->keys, sizeof(*n4->keys), n4->nr_entries, i);
+	        				_erase_elt(n4->values, sizeof(*n4->values), n4->nr_entries, i);
+        				}
 
-					n4->nr_entries--;
+        				n4->nr_entries--;
 					if (!n4->nr_entries) {
 						free(n4);
 						root->type = UNSET;
@@ -733,19 +722,19 @@ static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb
 		return false;
 
 	case NODE16:
-		n16 = root->value.ptr;
+        	n16 = root->value.ptr;
 		for (i = 0; i < n16->nr_entries; i++) {
 			if (n16->keys[i] == *kb) {
 				r = _remove(rt, n16->values + i, kb + 1, ke);
 				if (r && n16->values[i].type == UNSET) {
-					if (i < n16->nr_entries) {
-						_erase_elt(n16->keys, sizeof(*n16->keys), n16->nr_entries, i);
-						_erase_elt(n16->values, sizeof(*n16->values), n16->nr_entries, i);
-					}
+        				if (i < n16->nr_entries) {
+	        				_erase_elt(n16->keys, sizeof(*n16->keys), n16->nr_entries, i);
+	        				_erase_elt(n16->values, sizeof(*n16->values), n16->nr_entries, i);
+        				}
 
-					n16->nr_entries--;
+        				n16->nr_entries--;
 					if (n16->nr_entries <= 4) {
-						_degrade_to_n4(n16, root);
+        					_degrade_to_n4(n16, root);
 					}
 				}
 				return r;
@@ -757,18 +746,18 @@ static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb
 		n48 = root->value.ptr;
 		i = n48->keys[*kb];
 		if (i < 48) {
-			r = _remove(rt, n48->values + i, kb + 1, ke);
-			if (r && n48->values[i].type == UNSET) {
-				n48->keys[*kb] = 48;
-				for (j = 0; j < 256; j++)
-					if (n48->keys[j] < 48 && n48->keys[j] > i)
-						n48->keys[j]--;
+        		r = _remove(rt, n48->values + i, kb + 1, ke);
+        		if (r && n48->values[i].type == UNSET) {
+                		n48->keys[*kb] = 48;
+                		for (j = 0; j < 256; j++)
+	                		if (n48->keys[j] < 48 && n48->keys[j] > i)
+		                		n48->keys[j]--;
 				_erase_elt(n48->values, sizeof(*n48->values), n48->nr_entries, i);
 				n48->nr_entries--;
 				if (n48->nr_entries <= 16)
-					_degrade_to_n16(n48, root);
-			}
-			return r;
+        				_degrade_to_n16(n48, root);
+        		}
+        		return r;
 		}
 		return false;
 
@@ -778,7 +767,7 @@ static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb
 		if (r && n256->values[*kb].type == UNSET) {
 			n256->nr_entries--;
 			if (n256->nr_entries <= 48)
-				_degrade_to_n48(n256, root);
+        			_degrade_to_n48(n256, root);
 		}
 		return r;
 	}
@@ -786,14 +775,11 @@ static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb
 	return false;
 }
 
-bool radix_tree_remove(struct radix_tree *rt, const void *key, size_t keylen)
+bool radix_tree_remove(struct radix_tree *rt, uint8_t *key_begin, uint8_t *key_end)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
-
-	if (_remove(rt, &rt->root, kb, ke)) {
-		rt->nr_entries--;
-		return true;
+	if (_remove(rt, &rt->root, key_begin, key_end)) {
+        	rt->nr_entries--;
+        	return true;
 	}
 
 	return false;
@@ -801,25 +787,25 @@ bool radix_tree_remove(struct radix_tree *rt, const void *key, size_t keylen)
 
 //----------------------------------------------------------------
 
-static bool _prefix_chain_matches(const struct lookup_result *lr, const uint8_t *ke)
+static bool _prefix_chain_matches(struct lookup_result *lr, uint8_t *ke)
 {
-	// It's possible the top node is a prefix chain, and
-	// the remaining key matches part of it.
-	if (lr->v->type == PREFIX_CHAIN) {
-		unsigned i, rlen = ke - lr->kb;
-		const struct prefix_chain *pc = lr->v->value.ptr;
-		if (rlen < pc->len) {
-			for (i = 0; i < rlen; i++)
-				if (pc->prefix[i] != lr->kb[i])
-					return false;
-			return true;
+        // It's possible the top node is a prefix chain, and
+        // the remaining key matches part of it.
+        if (lr->v->type == PREFIX_CHAIN) {
+                unsigned i, rlen = ke - lr->kb;
+                struct prefix_chain *pc = lr->v->value.ptr;
+                if (rlen < pc->len) {
+                        for (i = 0; i < rlen; i++)
+                                if (pc->prefix[i] != lr->kb[i])
+                                        return false;
+                        return true;
 		}
-	}
+        }
 
-	return false;
+        return false;
 }
 
-static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uint8_t *kb, const uint8_t *ke, unsigned *count)
+static bool _remove_subtree(struct radix_tree *rt, struct value *root, uint8_t *kb, uint8_t *ke, unsigned *count)
 {
 	bool r;
 	unsigned i, j, len;
@@ -840,7 +826,7 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uin
 	case UNSET:
 	case VALUE:
 		// No entries with the given prefix
-		return true;
+        	return true;
 
 	case VALUE_CHAIN:
 		vc = root->value.ptr;
@@ -857,7 +843,7 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uin
 		len = min(pc->len, ke - kb);
 		for (i = 0; i < len; i++)
 			if (kb[i] != pc->prefix[i])
-				return true;
+        			return true;
 
 		r = _remove_subtree(rt, &pc->child, len < pc->len ? ke : (kb + pc->len), ke, count);
 		if (r && pc->child.type == UNSET) {
@@ -872,12 +858,12 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uin
 			if (n4->keys[i] == *kb) {
 				r = _remove_subtree(rt, n4->values + i, kb + 1, ke, count);
 				if (r && n4->values[i].type == UNSET) {
-					if (i < n4->nr_entries) {
-						_erase_elt(n4->keys, sizeof(*n4->keys), n4->nr_entries, i);
-						_erase_elt(n4->values, sizeof(*n4->values), n4->nr_entries, i);
-					}
+        				if (i < n4->nr_entries) {
+	        				_erase_elt(n4->keys, sizeof(*n4->keys), n4->nr_entries, i);
+	        				_erase_elt(n4->values, sizeof(*n4->values), n4->nr_entries, i);
+        				}
 
-					n4->nr_entries--;
+        				n4->nr_entries--;
 					if (!n4->nr_entries) {
 						free(n4);
 						root->type = UNSET;
@@ -889,19 +875,19 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uin
 		return true;
 
 	case NODE16:
-		n16 = root->value.ptr;
+        	n16 = root->value.ptr;
 		for (i = 0; i < n16->nr_entries; i++) {
 			if (n16->keys[i] == *kb) {
 				r = _remove_subtree(rt, n16->values + i, kb + 1, ke, count);
 				if (r && n16->values[i].type == UNSET) {
-					if (i < n16->nr_entries) {
-						_erase_elt(n16->keys, sizeof(*n16->keys), n16->nr_entries, i);
-						_erase_elt(n16->values, sizeof(*n16->values), n16->nr_entries, i);
-					}
+        				if (i < n16->nr_entries) {
+	        				_erase_elt(n16->keys, sizeof(*n16->keys), n16->nr_entries, i);
+	        				_erase_elt(n16->values, sizeof(*n16->values), n16->nr_entries, i);
+        				}
 
-					n16->nr_entries--;
+        				n16->nr_entries--;
 					if (n16->nr_entries <= 4)
-						_degrade_to_n4(n16, root);
+        					_degrade_to_n4(n16, root);
 				}
 				return r;
 			}
@@ -912,18 +898,18 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uin
 		n48 = root->value.ptr;
 		i = n48->keys[*kb];
 		if (i < 48) {
-			r = _remove_subtree(rt, n48->values + i, kb + 1, ke, count);
-			if (r && n48->values[i].type == UNSET) {
-				n48->keys[*kb] = 48;
-				for (j = 0; j < 256; j++)
-					if (n48->keys[j] < 48 && n48->keys[j] > i)
-						n48->keys[j]--;
+        		r = _remove_subtree(rt, n48->values + i, kb + 1, ke, count);
+        		if (r && n48->values[i].type == UNSET) {
+                		n48->keys[*kb] = 48;
+                		for (j = 0; j < 256; j++)
+	                		if (n48->keys[j] < 48 && n48->keys[j] > i)
+		                		n48->keys[j]--;
 				_erase_elt(n48->values, sizeof(*n48->values), n48->nr_entries, i);
 				n48->nr_entries--;
 				if (n48->nr_entries <= 16)
-					_degrade_to_n16(n48, root);
-			}
-			return r;
+        				_degrade_to_n16(n48, root);
+        		}
+        		return r;
 		}
 		return true;
 
@@ -936,7 +922,7 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uin
 		if (r && n256->values[*kb].type == UNSET) {
 			n256->nr_entries--;
 			if (n256->nr_entries <= 48)
-				_degrade_to_n48(n256, root);
+        			_degrade_to_n48(n256, root);
 		}
 		return r;
 	}
@@ -945,13 +931,11 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uin
 	return false;
 }
 
-unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *prefix, size_t prefix_len)
+unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
 {
-	const uint8_t *kb = prefix;
-	const uint8_t *ke = kb + prefix_len;
-	unsigned count = 0;
+        unsigned count = 0;
 
-	if (_remove_subtree(rt, &rt->root, kb, ke, &count))
+        if (_remove_subtree(rt, &rt->root, kb, ke, &count))
 		rt->nr_entries -= count;
 
 	return count;
@@ -959,11 +943,9 @@ unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *prefix, siz
 
 //----------------------------------------------------------------
 
-bool radix_tree_lookup(struct radix_tree *rt, const void *key, size_t keylen,
-		       union radix_value *result)
+bool radix_tree_lookup(struct radix_tree *rt,
+		       uint8_t *kb, uint8_t *ke, union radix_value *result)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
 	struct value_chain *vc;
 	struct lookup_result lr = _lookup_prefix(&rt->root, kb, ke);
 	if (lr.kb == ke) {
@@ -986,58 +968,58 @@ bool radix_tree_lookup(struct radix_tree *rt, const void *key, size_t keylen,
 }
 
 // FIXME: build up the keys too
-static bool _iterate(struct radix_tree_iterator *it, const struct value *v)
+static bool _iterate(struct value *v, struct radix_tree_iterator *it)
 {
 	unsigned i;
-	const struct value_chain *vc;
-	const struct prefix_chain *pc;
-	const struct node4 *n4;
-	const struct node16 *n16;
-	const struct node48 *n48;
-	const struct node256 *n256;
+	struct value_chain *vc;
+	struct prefix_chain *pc;
+	struct node4 *n4;
+	struct node16 *n16;
+	struct node48 *n48;
+	struct node256 *n256;
 
 	switch (v->type) {
 	case UNSET:
-		// can't happen
+        	// can't happen
 		break;
 
 	case VALUE:
-		return it->visit(it, NULL, 0, v->value);
+        	return it->visit(it, NULL, NULL, v->value);
 
 	case VALUE_CHAIN:
 		vc = v->value.ptr;
-		return it->visit(it, NULL, 0, vc->value) && _iterate(it, &vc->child);
+		return it->visit(it, NULL, NULL, vc->value) && _iterate(&vc->child, it);
 
 	case PREFIX_CHAIN:
 		pc = v->value.ptr;
-		return _iterate(it, &pc->child);
+		return _iterate(&pc->child, it);
 
 	case NODE4:
-		n4 = (const struct node4 *) v->value.ptr;
+		n4 = (struct node4 *) v->value.ptr;
 		for (i = 0; i < n4->nr_entries; i++)
-			if (!_iterate(it, n4->values + i))
-				return false;
-		return true;
+			if (!_iterate(n4->values + i, it))
+        			return false;
+        	return true;
 
 	case NODE16:
-		n16 = (const struct node16 *) v->value.ptr;
+		n16 = (struct node16 *) v->value.ptr;
 		for (i = 0; i < n16->nr_entries; i++)
-			if (!_iterate(it, n16->values + i))
-				return false;
+        		if (!_iterate(n16->values + i, it))
+        			return false;
 		return true;
 
 	case NODE48:
-		n48 = (const struct node48 *) v->value.ptr;
+		n48 = (struct node48 *) v->value.ptr;
 		for (i = 0; i < n48->nr_entries; i++)
-			if (!_iterate(it, n48->values + i))
-				return false;
+        		if (!_iterate(n48->values + i, it))
+        			return false;
 		return true;
 
 	case NODE256:
-		n256 = (const struct node256 *) v->value.ptr;
+		n256 = (struct node256 *) v->value.ptr;
 		for (i = 0; i < 256; i++)
-			if (n256->values[i].type != UNSET && !_iterate(it, n256->values + i))
-				return false;
+        		if (n256->values[i].type != UNSET && !_iterate(n256->values + i, it))
+        			return false;
 		return true;
 	}
 
@@ -1045,14 +1027,12 @@ static bool _iterate(struct radix_tree_iterator *it, const struct value *v)
 	return false;
 }
 
-void radix_tree_iterate(struct radix_tree *rt, const void *key, size_t keylen,
-			struct radix_tree_iterator *it)
+void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+                        struct radix_tree_iterator *it)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
 	struct lookup_result lr = _lookup_prefix(&rt->root, kb, ke);
 	if (lr.kb == ke || _prefix_chain_matches(&lr, ke))
-		(void) _iterate(it, lr.v);
+        	_iterate(lr.v, it);
 }
 
 //----------------------------------------------------------------
@@ -1150,7 +1130,7 @@ static bool _check_nodes(struct value *v, unsigned *count)
 
 		if (ncount != n48->nr_entries) {
 			fprintf(stderr, "incorrect number of entries in n48, n48->nr_entries = %u, actual = %u\n",
-				n48->nr_entries, ncount);
+                                n48->nr_entries, ncount);
 			return false;
 		}
 
@@ -1186,7 +1166,7 @@ static bool _check_nodes(struct value *v, unsigned *count)
 
 		if (ncount != n256->nr_entries) {
 			fprintf(stderr, "incorrect number of entries in n256, n256->nr_entries = %u, actual = %u\n",
-				n256->nr_entries, ncount);
+                                n256->nr_entries, ncount);
 			return false;
 		}
 
@@ -1209,7 +1189,7 @@ bool radix_tree_is_well_formed(struct radix_tree *rt)
 
 	if (rt->nr_entries != count) {
 		fprintf(stderr, "incorrect entry count: rt->nr_entries = %u, actual = %u\n",
-			rt->nr_entries, count);
+                        rt->nr_entries, count);
 		return false;
 	}
 
@@ -1227,7 +1207,6 @@ static void _dump(FILE *out, struct value v, unsigned indent)
 	struct node16 *n16;
 	struct node48 *n48;
 	struct node256 *n256;
-	unsigned printable;
 
 	if (v.type == UNSET)
 		return;
@@ -1252,22 +1231,9 @@ static void _dump(FILE *out, struct value v, unsigned indent)
 
 	case PREFIX_CHAIN:
 		pc = v.value.ptr;
-		fprintf(out, "<prefix(%u): ", pc->len);
-		printable = 1;
+		fprintf(out, "<prefix: ");
 		for (i = 0; i < pc->len; i++)
-			if (!isprint(pc->prefix[i])) {
-				printable = 0;
-				break;
-			}
-		if (printable)
-			fputc('"', out);
-		for (i = 0; i < pc->len; i++)
-			if (printable)
-				fprintf(out, "%c", pc->prefix[i]);
-			else
-				fprintf(out, "%02x.", (unsigned) *(pc->prefix + i));
-		if (printable)
-			fputc('"', out);
+			fprintf(out, "%x.", (unsigned) *(pc->prefix + i));
 		fprintf(out, ">\n");
 		_dump(out, pc->child, indent + 1);
 		break;
@@ -1276,7 +1242,7 @@ static void _dump(FILE *out, struct value v, unsigned indent)
 		n4 = v.value.ptr;
 		fprintf(out, "<n4: ");
 		for (i = 0; i < n4->nr_entries; i++)
-			fprintf(out, "%02x ", (unsigned) n4->keys[i]);
+			fprintf(out, "%x ", (unsigned) n4->keys[i]);
 		fprintf(out, ">\n");
 
 		for (i = 0; i < n4->nr_entries; i++)
@@ -1287,7 +1253,7 @@ static void _dump(FILE *out, struct value v, unsigned indent)
 		n16 = v.value.ptr;
 		fprintf(out, "<n16: ");
 		for (i = 0; i < n16->nr_entries; i++)
-			fprintf(out, "%02x ", (unsigned) n16->keys[i]);
+			fprintf(out, "%x ", (unsigned) n16->keys[i]);
 		fprintf(out, ">\n");
 
 		for (i = 0; i < n16->nr_entries; i++)
@@ -1299,7 +1265,7 @@ static void _dump(FILE *out, struct value v, unsigned indent)
 		fprintf(out, "<n48: ");
 		for (i = 0; i < 256; i++)
 			if (n48->keys[i] < 48)
-				fprintf(out, "%02x ", i);
+				fprintf(out, "%x ", i);
 		fprintf(out, ">\n");
 
 		for (i = 0; i < n48->nr_entries; i++) {
@@ -1313,7 +1279,7 @@ static void _dump(FILE *out, struct value v, unsigned indent)
 		fprintf(out, "<n256: ");
 		for (i = 0; i < 256; i++)
 			if (n256->values[i].type != UNSET)
-				fprintf(out, "%02x ", i);
+				fprintf(out, "%x ", i);
 		fprintf(out, ">\n");
 
 		for (i = 0; i < 256; i++)

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

@@ -1,5 +1,5 @@
 // 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,
@@ -18,7 +18,6 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <ctype.h>
 
 //----------------------------------------------------------------
 // This implementation is based around nested binary trees.  Very
@@ -38,12 +37,12 @@ struct node {
 struct radix_tree {
 	radix_value_dtr dtr;
 	void *dtr_context;
-	unsigned nr_entries;
 
 	struct node *root;
 };
 
-struct radix_tree *radix_tree_create(radix_value_dtr dtr, void *dtr_context)
+struct radix_tree *
+radix_tree_create(radix_value_dtr dtr, void *dtr_context)
 {
 	struct radix_tree *rt = zalloc(sizeof(*rt));
 
@@ -106,7 +105,7 @@ unsigned radix_tree_size(struct radix_tree *rt)
 	return _count(rt->root);
 }
 
-static struct node **_lookup(struct node **pn, const uint8_t *kb, const uint8_t *ke)
+static struct node **_lookup(struct node **pn, uint8_t *kb, uint8_t *ke)
 {
 	struct node *n = *pn;
 
@@ -123,7 +122,7 @@ static struct node **_lookup(struct node **pn, const uint8_t *kb, const uint8_t
 		return _lookup(&n->center, kb + 1, ke);
 }
 
-static bool _insert(struct node **pn, const uint8_t *kb, const uint8_t *ke, union radix_value v)
+static bool _insert(struct node **pn, uint8_t *kb, uint8_t *ke, union radix_value v)
 {
 	struct node *n = *pn;
 
@@ -152,53 +151,41 @@ static bool _insert(struct node **pn, const uint8_t *kb, const uint8_t *ke, unio
 		return _insert(&n->center, kb + 1, ke, v);
 }
 
-bool radix_tree_insert(struct radix_tree *rt, const void *key, size_t keylen,
-		       union radix_value v)
+bool radix_tree_insert(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value v)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
-
-	if (!_insert(&rt->root, kb, ke, v))
-		return false;
-
-	rt->nr_entries++;
-	return true;
+	return _insert(&rt->root, kb, ke, v);
 }
 
-bool radix_tree_remove(struct radix_tree *rt, const void *key, size_t keylen)
+bool radix_tree_remove(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
 	struct node **pn = _lookup(&rt->root, kb, ke);
 	struct node *n = *pn;
 
 	if (!n || !n->has_value)
 		return false;
 
-	rt->nr_entries--;
+	else {
+		if (rt->dtr)
+			rt->dtr(rt->dtr_context, n->value);
 
-	if (rt->dtr)
-	    rt->dtr(rt->dtr_context, n->value);
+		if (n->left || n->center || n->right) {
+			n->has_value = false;
+			return true;
 
-	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;
 	}
-
-	// FIXME: delete parent if this was the last entry
-	free(n);
-	*pn = NULL;
-
-	return true;
 }
 
-unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *prefix, size_t prefix_len)
+unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
 {
-	const uint8_t *kb = prefix;
-	const uint8_t *ke = kb + prefix_len;
 	struct node **pn;
-	unsigned count = 0;
+	unsigned count;
 
 	pn = _lookup(&rt->root, kb, ke);
 
@@ -210,20 +197,17 @@ unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *prefix, siz
 	return count;
 }
 
-bool radix_tree_lookup(struct radix_tree *rt, const void *key, size_t keylen,
-		       union radix_value *result)
+bool
+radix_tree_lookup(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value *result)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
 	struct node **pn = _lookup(&rt->root, kb, ke);
 	struct node *n = *pn;
 
 	if (n && n->has_value) {
 		*result = n->value;
 		return true;
-	}
-
-	return false;
+	} else
+		return false;
 }
 
 static void _iterate(struct node *n, struct radix_tree_iterator *it)
@@ -235,18 +219,15 @@ static void _iterate(struct node *n, struct radix_tree_iterator *it)
 
 	if (n->has_value)
 		// FIXME: fill out the key
-		it->visit(it, NULL, 0, n->value);
+		it->visit(it, NULL, NULL, n->value);
 
 	_iterate(n->center, it);
 	_iterate(n->right, it);
 }
 
-void radix_tree_iterate(struct radix_tree *rt, const void *key, size_t keylen,
+void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
                         struct radix_tree_iterator *it)
 {
-	const uint8_t *kb = key;
-	const uint8_t *ke = kb + keylen;
-
 	if (kb == ke)
 		_iterate(rt->root, it);
 
@@ -256,7 +237,7 @@ void radix_tree_iterate(struct radix_tree *rt, const void *key, size_t keylen,
 
 		if (n) {
 			if (n->has_value)
-				it->visit(it, NULL, 0, n->value);
+				it->visit(it, NULL, NULL, n->value);
 			_iterate(n->center, it);
 		}
 	}
@@ -267,32 +248,8 @@ bool radix_tree_is_well_formed(struct radix_tree *rt)
 	return true;
 }
 
-static void _dump(FILE *out, struct node *n, unsigned indent)
-{
-	unsigned i;
-
-	if (!n)
-		return;
-
-	_dump(out, n->left, indent + 1);
-
-	for (i = 0; i < 2 * indent; i++)
-		fprintf(out, " ");
-
-	if (n->has_value) {
-		fprintf(out, "value: %lu\n", (unsigned long) n->value.n);
-	} else {
-		fprintf(out, "key: '%c' [0x%02x] %u\n",
-			isprint(n->key) ? n->key : ' ', n->key, indent);
-	}
-
-	_dump(out, n->center, indent + 1);
-	_dump(out, n->right, indent + 1);
-}
-
 void radix_tree_dump(struct radix_tree *rt, FILE *out)
 {
-	_dump(out, rt->root, 0);
 }
 
 //----------------------------------------------------------------

base/data-struct/radix-tree.c

@@ -19,45 +19,3 @@
 #endif
 
 //----------------------------------------------------------------
-
-struct visitor {
-	struct radix_tree_iterator it;
-	unsigned pos, nr_entries;
-	union radix_value *values;
-};
-
-static bool _visitor(struct radix_tree_iterator *it,
-		     const void *key, size_t keylen,
-		     union radix_value v)
-{
-	struct visitor *vt = container_of(it, struct visitor, it);
-
-	if (vt->pos >= vt->nr_entries)
-		return false;
-
-	vt->values[vt->pos++] = v;
-
-	return true;
-}
-
-bool radix_tree_values(struct radix_tree *rt, const void *key, size_t keylen,
-		       union radix_value **values, unsigned *nr_values)
-{
-	struct visitor vt = {
-		.it.visit = _visitor,
-		.nr_entries = rt->nr_entries,
-		.values = calloc(rt->nr_entries + 1, sizeof(union radix_value)),
-	};
-
-	if (vt.values) {
-		// build set of all values in current radix tree
-		radix_tree_iterate(rt, key, keylen, &vt.it);
-		*nr_values = vt.pos;
-		*values = vt.values;
-		return true;
-	}
-
-	return false;
-}
-
-//----------------------------------------------------------------

base/data-struct/radix-tree.h

@@ -33,61 +33,32 @@ struct radix_tree *radix_tree_create(radix_value_dtr dtr, void *dtr_context);
 void radix_tree_destroy(struct radix_tree *rt);
 
 unsigned radix_tree_size(struct radix_tree *rt);
-bool radix_tree_insert(struct radix_tree *rt, const void *key, size_t keylen, union radix_value v);
-bool radix_tree_remove(struct radix_tree *rt, const void *key, size_t keylen);
-// Returns: 1 success
-//	    0 failure during insert
-//	   -1 key had already existing value (that was updated)
-int radix_tree_uniq_insert(struct radix_tree *rt, const void *key, size_t keylen, union radix_value v);
+bool radix_tree_insert(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value v);
+bool radix_tree_remove(struct radix_tree *rt, uint8_t *kb, uint8_t *ke);
 
 // Returns the number of values removed
-unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *prefix, size_t prefix_len);
+unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *prefix_b, uint8_t *prefix_e);
 
-bool radix_tree_lookup(struct radix_tree *rt, const void *key, size_t keylen,
-		       union radix_value *result);
+bool radix_tree_lookup(struct radix_tree *rt,
+		       uint8_t *kb, uint8_t *ke, union radix_value *result);
 
 // The radix tree stores entries in lexicographical order.  Which means
 // we can iterate entries, in order.  Or iterate entries with a particular
 // prefix.
 struct radix_tree_iterator {
-	// Returns false if the iteration should end.
+        // Returns false if the iteration should end.
 	bool (*visit)(struct radix_tree_iterator *it,
-		      const void *key, size_t keylen, union radix_value v);
+                      uint8_t *kb, uint8_t *ke, union radix_value v);
 };
 
-void radix_tree_iterate(struct radix_tree *rt, const void *key, size_t keylen,
-			struct radix_tree_iterator *it);
-
-// Alternative traversing radix_tree.
-// Builds whole set all radix_tree  nr_values values.
-// After use, free(values).
-bool radix_tree_values(struct radix_tree *rt, const void *key, size_t keylen,
-		       union radix_value **values, unsigned *nr_values);
+void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+                        struct radix_tree_iterator *it);
 
 // Checks that some constraints on the shape of the tree are
 // being held.  For debug only.
 bool radix_tree_is_well_formed(struct radix_tree *rt);
 void radix_tree_dump(struct radix_tree *rt, FILE *out);
 
-// Shortcut for ptr value return
-// Note: if value would be NULL, it's same result for not/found case.
-static inline void *radix_tree_lookup_ptr(struct radix_tree *rt, const void *key, size_t keylen)
-{
-	union radix_value v;
-	return radix_tree_lookup(rt, key, keylen, &v) ? v.ptr : NULL;
-}
-
-static inline bool radix_tree_insert_ptr(struct radix_tree *rt, const void *key, size_t keylen, void *ptr)
-{
-	union radix_value v = { .ptr = ptr };
-	return radix_tree_insert(rt, key, keylen, v);
-}
-
-static inline int radix_tree_uniq_insert_ptr(struct radix_tree *rt, const void *key, size_t keylen, void *ptr)
-{
-	union radix_value v = { .ptr = ptr };
-	return radix_tree_uniq_insert(rt, key, keylen, v);
-}
 //----------------------------------------------------------------
 
 #endif

base/memory/container_of.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2018 - 2020 Red Hat, Inc. All rights reserved.
+// Copyright (C) 2018 Red Hat, Inc. All rights reserved.
 // 
 // This file is part of LVM2.
 //
@@ -13,12 +13,10 @@
 #ifndef BASE_MEMORY_CONTAINER_OF_H
 #define BASE_MEMORY_CONTAINER_OF_H
 
-#include <stddef.h>  // offsetof
-
 //----------------------------------------------------------------
 
 #define container_of(v, t, head) \
-    ((t *)((char *)(v) - offsetof(t, head)))
+    ((t *)((const char *)(v) - (const char *)&((t *) 0)->head))
 
 //----------------------------------------------------------------
 

base/memory/zalloc.h

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

conf/Makefile.in

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2004-2018 Red Hat, Inc. All rights reserved.
+# Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.
 #
 # This file is part of LVM2.
 #
@@ -25,7 +25,6 @@ PROFILES=$(PROFILE_TEMPLATES) \
 	$(srcdir)/cache-smq.profile \
 	$(srcdir)/thin-generic.profile \
 	$(srcdir)/thin-performance.profile \
-	$(srcdir)/vdo-small.profile \
 	$(srcdir)/lvmdbusd.profile
 
 include $(top_builddir)/make.tmpl
@@ -33,8 +32,8 @@ include $(top_builddir)/make.tmpl
 .PHONY: install_conf install_localconf install_profiles
 
 generate:
-	$(top_builddir)/tools/lvm dumpconfig --type default --unconfigured --withgeneralpreamble --withcomments --ignorelocal --withspaces > example.conf.in
-	$(top_builddir)/tools/lvm dumpconfig --type default --unconfigured --withlocalpreamble --withcomments --withspaces local > lvmlocal.conf.in
+	LD_LIBRARY_PATH=$(top_builddir)/libdm:$(LD_LIBRARY_PATH) $(top_builddir)/tools/lvm dumpconfig --type default --unconfigured --withgeneralpreamble --withcomments --ignorelocal --withspaces > example.conf.in
+	LD_LIBRARY_PATH=$(top_builddir)/libdm:$(LD_LIBRARY_PATH) $(top_builddir)/tools/lvm dumpconfig --type default --unconfigured --withlocalpreamble --withcomments --withspaces local > lvmlocal.conf.in
 
 install_conf: $(CONFSRC)
 	@if [ ! -e $(confdir)/$(CONFDEST) ]; then \
@@ -49,9 +48,8 @@ install_localconf: $(CONFLOCAL)
 	fi
 
 install_profiles: $(PROFILES)
-	$(SHOW) "    [INSTALL] $<"
-	$(Q) $(INSTALL_DIR) $(profiledir)
-	$(Q) $(INSTALL_DATA) $(PROFILES) $(profiledir)/
+	$(INSTALL_DIR) $(profiledir)
+	$(INSTALL_DATA) $(PROFILES) $(profiledir)/
 
 install_lvm2: install_conf install_localconf install_profiles
 

conf/lvmlocal.conf.in

@@ -28,13 +28,13 @@ local {
 	# main configuration file, e.g. lvm.conf. When used, it must be set to
 	# a unique value among all hosts sharing access to the storage,
 	# e.g. a host name.
-	#
+	# 
 	# Example
 	# Set no system ID:
 	# system_id = ""
 	# Set the system_id to a specific name:
 	# system_id = "host1"
-	#
+	# 
 	# This configuration option has an automatic default value.
 	# system_id = ""
 
@@ -49,10 +49,9 @@ local {
 	# This configuration option does not have a default value defined.
 
 	# Configuration option local/host_id.
-	# The sanlock host_id used by lvmlockd. This must be unique among all the hosts
-	# using shared VGs with sanlock. Accepted values are 1-2000, except when sanlock_align_size
-	# is configured to 1, 2 or 4, which correspond to max host_id values of 250, 500, or 1000.
-	# Applicable only if LVM is compiled with support for lvmlockd+sanlock.
+	# The lvmlockd sanlock host_id.
+	# This must be unique among all hosts, and must be between 1 and 2000.
+	# Applicable only if LVM is compiled with lockd support
 	# This configuration option has an automatic default value.
 	# host_id = 0
 }

conf/vdo-small.profile

@@ -1,21 +0,0 @@
-# Demo configuration for 'VDO' using less memory.
-# ~lvmconfig --type full | grep vdo
-
-allocation {
-	vdo_use_compression=1
-	vdo_use_deduplication=1
-	vdo_minimum_io_size=4096
-	vdo_block_map_cache_size_mb=128
-	vdo_block_map_period=16380
-	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_max_discard=1
-}

coverity/coverity_model.c

@@ -21,7 +21,7 @@
  * compile (using outdir 'cov'):
  * cov-build --dir=cov make CC=gcc
  *
- * analyze (aggressively, using 'cov')
+ * analyze (agressively, using 'cov')
  * cov-analyze --dir cov --wait-for-license --hfa --concurrency --enable-fnptr --enable-constraint-fpp --security --all --aggressiveness-level=high --field-offset-escape --user-model-file=coverity/coverity_model.xml
  *
  * generate html output (to 'html' from 'cov'):
@@ -30,8 +30,6 @@
 
 struct lv_segment;
 struct logical_volume;
-struct cmd_context;
-struct profile;
 
 struct lv_segment *first_seg(const struct logical_volume *lv)
 {
@@ -48,7 +46,6 @@ const char *find_config_tree_str(struct cmd_context *cmd, int id, struct profile
 	return "STRING";
 }
 
-/*
 struct logical_volume *origin_from_cow(const struct logical_volume *lv)
 {
 	if (lv)
@@ -56,10 +53,9 @@ struct logical_volume *origin_from_cow(const struct logical_volume *lv)
 
 	__coverity_panic__();
 }
-*/
 
 /* simple_memccpy() from glibc */
-void *memccpy(void *dest, const void *src, int c, unsigned long n)
+void *memccpy(void *dest, const void *src, int c, size_t n)
 {
 	const char *s = src;
 	char *d = dest;
@@ -72,7 +68,7 @@ void *memccpy(void *dest, const void *src, int c, unsigned long n)
 }
 
 /*
- * 2 lines below needs to be placed in coverity/config/user_nodefs.h
+ * 2 lines bellow needs to be placed in coverity/config/user_nodefs.h
  * Not sure about any other way.
  * Without them, coverity shows warning since x86 system header files
  * are using inline assembly to reset fdset
@@ -92,14 +88,9 @@ void model_FD_ZERO(void *fdset)
 /* Resent Coverity reports quite weird errors... */
 int *__errno_location(void)
 {
-	static int _i = 0;
-	return &_i;
 }
-
 const unsigned short **__ctype_b_loc (void)
 {
-	static const unsigned short *_a[1] = { 0 };
-	return _a;
 }
 
 

daemons/Makefile.in

@@ -15,7 +15,11 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-.PHONY: dmeventd cmirrord lvmpolld lvmlockd
+.PHONY: dmeventd clvmd cmirrord lvmetad lvmpolld lvmlockd
+
+ifneq ("@CLVMD@", "none")
+  SUBDIRS += clvmd
+endif
 
 ifeq ("@BUILD_CMIRRORD@", "yes")
   SUBDIRS += cmirrord
@@ -28,6 +32,10 @@ daemons.cflow: dmeventd.cflow
 endif
 endif
 
+ifeq ("@BUILD_LVMETAD@", "yes")
+  SUBDIRS += lvmetad
+endif
+
 ifeq ("@BUILD_LVMPOLLD@", "yes")
   SUBDIRS += lvmpolld
 endif
@@ -40,8 +48,12 @@ ifeq ("@BUILD_LVMDBUSD@", "yes")
   SUBDIRS += lvmdbusd
 endif
 
+ifeq ("@BUILD_DMFILEMAPD@", "yes")
+  SUBDIRS += dmfilemapd
+endif
+
 ifeq ($(MAKECMDGOALS),distclean)
-  SUBDIRS = cmirrord dmeventd lvmpolld lvmlockd lvmdbusd
+  SUBDIRS = clvmd cmirrord dmeventd lvmetad lvmpolld lvmlockd lvmdbusd dmfilemapd
 endif
 
 include $(top_builddir)/make.tmpl

daemons/clvmd/.gitignore

@@ -0,0 +1 @@
+clvmd

daemons/clvmd/Makefile.in

@@ -0,0 +1,94 @@
+#
+# Copyright (C) 2004 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 General Public License v.2.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+top_builddir = @top_builddir@
+
+CMAN_LIBS = @CMAN_LIBS@
+CMAN_CFLAGS = @CMAN_CFLAGS@
+CMAP_LIBS = @CMAP_LIBS@
+CMAP_CFLAGS = @CMAP_CFLAGS@
+CONFDB_LIBS = @CONFDB_LIBS@
+CONFDB_CFLAGS = @CONFDB_CFLAGS@
+CPG_LIBS = @CPG_LIBS@
+CPG_CFLAGS = @CPG_CFLAGS@
+DLM_LIBS = @DLM_LIBS@
+DLM_CFLAGS = @DLM_CFLAGS@
+QUORUM_LIBS = @QUORUM_LIBS@
+QUORUM_CFLAGS = @QUORUM_CFLAGS@
+SALCK_LIBS = @SALCK_LIBS@
+SALCK_CFLAGS = @SALCK_CFLAGS@
+
+SOURCES = \
+	clvmd-command.c\
+	clvmd.c\
+	lvm-functions.c\
+	refresh_clvmd.c
+
+ifneq (,$(findstring cman,, "@CLVMD@,"))
+	SOURCES += clvmd-cman.c
+	LMLIBS += $(CMAN_LIBS) $(CONFDB_LIBS) $(DLM_LIBS)
+	CFLAGS += $(CMAN_CFLAGS) $(CONFDB_CFLAGS) $(DLM_CFLAGS)
+	DEFS += -DUSE_CMAN
+endif
+
+ifneq (,$(findstring openais,, "@CLVMD@,"))
+	SOURCES += clvmd-openais.c
+	LMLIBS += $(CONFDB_LIBS) $(CPG_LIBS) $(SALCK_LIBS)
+	CFLAGS += $(CONFDB_CFLAGS) $(CPG_CFLAGS) $(SALCK_CFLAGS)
+	DEFS += -DUSE_OPENAIS
+endif
+
+ifneq (,$(findstring corosync,, "@CLVMD@,"))
+	SOURCES += clvmd-corosync.c
+	LMLIBS += $(CMAP_LIBS) $(CONFDB_LIBS) $(CPG_LIBS) $(DLM_LIBS) $(QUORUM_LIBS)
+	CFLAGS += $(CMAP_CFLAGS) $(CONFDB_CFLAGS) $(CPG_CFLAGS) $(DLM_CFLAGS) $(QUORUM_CFLAGS)
+	DEFS += -DUSE_COROSYNC
+endif
+
+ifneq (,$(findstring singlenode,, "@CLVMD@,"))
+	SOURCES += clvmd-singlenode.c
+	DEFS += -DUSE_SINGLENODE
+endif
+
+ifeq ($(MAKECMDGOALS),distclean)
+	SOURCES += clvmd-cman.c
+	SOURCES += clvmd-openais.c
+	SOURCES += clvmd-corosync.c
+	SOURCES += clvmd-singlenode.c
+endif
+
+TARGETS = \
+	clvmd
+
+include $(top_builddir)/make.tmpl
+
+LIBS += $(LVMINTERNAL_LIBS) -ldevmapper $(PTHREAD_LIBS) -laio
+CFLAGS += -fno-strict-aliasing $(EXTRA_EXEC_CFLAGS)
+
+INSTALL_TARGETS = \
+	install_clvmd
+
+clvmd: $(OBJECTS) $(top_builddir)/lib/liblvm-internal.a
+	$(CC) $(CFLAGS) $(LDFLAGS) $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS) \
+	      -o clvmd $(OBJECTS) $(LMLIBS) $(LIBS)
+
+.PHONY: install_clvmd
+
+install_clvmd: $(TARGETS)
+	$(INSTALL_PROGRAM) -D clvmd $(usrsbindir)/clvmd
+
+install: $(INSTALL_TARGETS)
+
+install_cluster: $(INSTALL_TARGETS)

daemons/clvmd/clvm.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2007 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* Definitions for CLVMD server and clients */
+
+/*
+ * The protocol spoken over the cluster and across the local socket.
+ */
+
+#ifndef _CLVM_H
+#define _CLVM_H
+
+#include "configure.h"
+#include <inttypes.h>
+
+struct clvm_header {
+	uint8_t  cmd;	        /* See below */
+	uint8_t  flags;	        /* See below */
+	uint16_t xid;	        /* Transaction ID */
+	uint32_t clientid;	/* Only used in Daemon->Daemon comms */
+	int32_t  status;	/* For replies, whether request succeeded */
+	uint32_t arglen;	/* Length of argument below.
+				   If >1500 then it will be passed
+				   around the cluster in the system LV */
+	char node[1];		/* Actually a NUL-terminated string, node name.
+				   If this is empty then the command is
+				   forwarded to all cluster nodes unless
+				   FLAG_LOCAL or FLAG_REMOTE is also set. */
+	char args[1];		/* Arguments for the command follow the
+				   node name, This member is only
+				   valid if the node name is empty */
+} __attribute__ ((packed));
+
+/* Flags */
+#define CLVMD_FLAG_LOCAL	1	/* Only do this on the local node */
+#define CLVMD_FLAG_SYSTEMLV	2	/* Data in system LV under my node name */
+#define CLVMD_FLAG_NODEERRS	4	/* Reply has errors in node-specific portion */
+#define CLVMD_FLAG_REMOTE	8	/* Do this on all nodes except for the local node */
+
+/* Name of the local socket to communicate between lvm and clvmd */
+#define CLVMD_SOCKNAME		DEFAULT_RUN_DIR "/clvmd.sock"
+
+/* Internal commands & replies */
+#define CLVMD_CMD_REPLY    1
+#define CLVMD_CMD_VERSION  2	/* Send version around cluster when we start */
+#define CLVMD_CMD_GOAWAY   3	/* Die if received this - we are running
+				   an incompatible version */
+#define CLVMD_CMD_TEST     4	/* Just for mucking about */
+
+#define CLVMD_CMD_LOCK              30
+#define CLVMD_CMD_UNLOCK            31
+
+/* Lock/Unlock commands */
+#define CLVMD_CMD_LOCK_LV           50
+#define CLVMD_CMD_LOCK_VG           51
+#define CLVMD_CMD_LOCK_QUERY	    52
+
+/* Misc functions */
+#define CLVMD_CMD_REFRESH	    40
+#define CLVMD_CMD_GET_CLUSTERNAME   41
+#define CLVMD_CMD_SET_DEBUG	    42
+#define CLVMD_CMD_VG_BACKUP	    43
+#define CLVMD_CMD_RESTART	    44
+#define CLVMD_CMD_SYNC_NAMES	    45
+
+/* Used internally by some callers, but not part of the protocol.*/
+#ifndef NODE_ALL
+#  define NODE_ALL	"*"
+#  define NODE_LOCAL	"."
+#  define NODE_REMOTE	"^"
+#endif
+
+#endif

daemons/clvmd/clvmd-cman.c

@@ -0,0 +1,505 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * CMAN communication layer for clvmd.
+ */
+
+#include "clvmd-common.h"
+
+#include <pthread.h>
+
+#include "clvmd-comms.h"
+#include "clvm.h"
+#include "clvmd.h"
+#include "lvm-functions.h"
+
+#include <libdlm.h>
+
+#include <syslog.h>
+
+#define LOCKSPACE_NAME "clvmd"
+
+struct clvmd_node
+{
+	struct cman_node *node;
+	int clvmd_up;
+};
+
+static int num_nodes;
+static struct cman_node *nodes = NULL;
+static struct cman_node this_node;
+static int count_nodes; /* size of allocated nodes array */
+static struct dm_hash_table *node_updown_hash;
+static dlm_lshandle_t *lockspace;
+static cman_handle_t c_handle;
+
+static void count_clvmds_running(void);
+static void get_members(void);
+static int nodeid_from_csid(const char *csid);
+static int name_from_nodeid(int nodeid, char *name);
+static void event_callback(cman_handle_t handle, void *private, int reason, int arg);
+static void data_callback(cman_handle_t handle, void *private,
+			  char *buf, int len, uint8_t port, int nodeid);
+
+struct lock_wait {
+	pthread_cond_t cond;
+	pthread_mutex_t mutex;
+	struct dlm_lksb lksb;
+};
+
+static int _init_cluster(void)
+{
+	node_updown_hash = dm_hash_create(100);
+
+	/* Open the cluster communication socket */
+	c_handle = cman_init(NULL);
+	if (!c_handle) {
+		syslog(LOG_ERR, "Can't open cluster manager socket: %m");
+		return -1;
+	}
+	DEBUGLOG("Connected to CMAN\n");
+
+	if (cman_start_recv_data(c_handle, data_callback, CLUSTER_PORT_CLVMD)) {
+		syslog(LOG_ERR, "Can't bind cluster socket: %m");
+		return -1;
+	}
+
+	if (cman_start_notification(c_handle, event_callback)) {
+		syslog(LOG_ERR, "Can't start cluster event listening");
+		return -1;
+	}
+
+	/* Get the cluster members list */
+	get_members();
+	count_clvmds_running();
+
+	DEBUGLOG("CMAN initialisation complete\n");
+
+	/* Create a lockspace for LV & VG locks to live in */
+	lockspace = dlm_open_lockspace(LOCKSPACE_NAME);
+	if (!lockspace) {
+		lockspace = dlm_create_lockspace(LOCKSPACE_NAME, 0600);
+		if (!lockspace) {
+			syslog(LOG_ERR, "Unable to create DLM lockspace for CLVM: %m");
+			return -1;
+		}
+		DEBUGLOG("Created DLM lockspace for CLVMD.\n");
+	} else
+		DEBUGLOG("Opened existing DLM lockspace for CLVMD.\n");
+
+	dlm_ls_pthread_init(lockspace);
+	DEBUGLOG("DLM initialisation complete\n");
+	return 0;
+}
+
+static void _cluster_init_completed(void)
+{
+	clvmd_cluster_init_completed();
+}
+
+static int _get_main_cluster_fd(void)
+{
+	return cman_get_fd(c_handle);
+}
+
+static int _get_num_nodes(void)
+{
+	int i;
+	int nnodes = 0;
+
+	/* return number of ACTIVE nodes */
+	for (i=0; i<num_nodes; i++) {
+		if (nodes[i].cn_member && nodes[i].cn_nodeid)
+			nnodes++;
+	}
+	return nnodes;
+}
+
+/* send_message with the fd check removed */
+static int _cluster_send_message(const void *buf, int msglen, const char *csid,
+				 const char *errtext)
+{
+	int nodeid = 0;
+
+	if (csid)
+		memcpy(&nodeid, csid, CMAN_MAX_CSID_LEN);
+
+	if (cman_send_data(c_handle, buf, msglen, 0, CLUSTER_PORT_CLVMD, nodeid) <= 0)
+	{
+		log_error("%s", errtext);
+	}
+	return msglen;
+}
+
+static void _get_our_csid(char *csid)
+{
+	if (this_node.cn_nodeid == 0) {
+		cman_get_node(c_handle, 0, &this_node);
+	}
+	memcpy(csid, &this_node.cn_nodeid, CMAN_MAX_CSID_LEN);
+}
+
+/* Call a callback routine for each node is that known (down means not running a clvmd) */
+static int _cluster_do_node_callback(struct local_client *client,
+				     void (*callback) (struct local_client *,
+						       const char *,
+						       int))
+{
+	int i;
+	int somedown = 0;
+
+	for (i = 0; i < _get_num_nodes(); i++) {
+		if (nodes[i].cn_member && nodes[i].cn_nodeid) {
+			int up = (int)(long)dm_hash_lookup_binary(node_updown_hash, (char *)&nodes[i].cn_nodeid, sizeof(int));
+
+			callback(client, (char *)&nodes[i].cn_nodeid, up);
+			if (!up)
+				somedown = -1;
+		}
+	}
+	return somedown;
+}
+
+/* Process OOB messages from the cluster socket */
+static void event_callback(cman_handle_t handle, void *private, int reason, int arg)
+{
+	char namebuf[MAX_CLUSTER_MEMBER_NAME_LEN];
+
+	switch (reason) {
+        case CMAN_REASON_PORTCLOSED:
+		name_from_nodeid(arg, namebuf);
+		log_notice("clvmd on node %s has died\n", namebuf);
+		DEBUGLOG("Got port closed message, removing node %s\n", namebuf);
+
+		dm_hash_insert_binary(node_updown_hash, (char *)&arg, sizeof(int), (void *)0);
+		break;
+
+	case CMAN_REASON_STATECHANGE:
+		DEBUGLOG("Got state change message, re-reading members list\n");
+		get_members();
+		break;
+
+#if defined(LIBCMAN_VERSION) && LIBCMAN_VERSION >= 2
+	case CMAN_REASON_PORTOPENED:
+		/* Ignore this, wait for startup message from clvmd itself */
+		break;
+
+	case CMAN_REASON_TRY_SHUTDOWN:
+		DEBUGLOG("Got try shutdown, sending OK\n");
+		cman_replyto_shutdown(c_handle, 1);
+		break;
+#endif
+	default:
+		/* ERROR */
+		DEBUGLOG("Got unknown event callback message: %d\n", reason);
+		break;
+	}
+}
+
+static struct local_client *cman_client;
+static int _cluster_fd_callback(struct local_client *fd, char *buf, int len,
+				const char *csid,
+				struct local_client **new_client)
+{
+
+	/* Save this for data_callback */
+	cman_client = fd;
+
+	/* We never return a new client */
+	*new_client = NULL;
+
+	return cman_dispatch(c_handle, 0);
+}
+
+
+static void data_callback(cman_handle_t handle, void *private,
+			  char *buf, int len, uint8_t port, int nodeid)
+{
+	/* Ignore looped back messages */
+	if (nodeid == this_node.cn_nodeid)
+		return;
+	process_message(cman_client, buf, len, (char *)&nodeid);
+}
+
+static void _add_up_node(const char *csid)
+{
+	/* It's up ! */
+	int nodeid = nodeid_from_csid(csid);
+
+	dm_hash_insert_binary(node_updown_hash, (char *)&nodeid, sizeof(int), (void *)1);
+	DEBUGLOG("Added new node %d to updown list\n", nodeid);
+}
+
+static void _cluster_closedown(void)
+{
+	dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
+	cman_finish(c_handle);
+}
+
+static int is_listening(int nodeid)
+{
+	int status;
+
+	do {
+		status = cman_is_listening(c_handle, nodeid, CLUSTER_PORT_CLVMD);
+		if (status < 0 && errno == EBUSY) {	/* Don't busywait */
+			sleep(1);
+			errno = EBUSY;	/* In case sleep trashes it */
+		}
+	}
+	while (status < 0 && errno == EBUSY);
+
+	return status;
+}
+
+/* Populate the list of CLVMDs running.
+   called only at startup time */
+static void count_clvmds_running(void)
+{
+	int i;
+
+	for (i = 0; i < num_nodes; i++) {
+		int nodeid = nodes[i].cn_nodeid;
+
+		if (is_listening(nodeid) == 1)
+			dm_hash_insert_binary(node_updown_hash, (void *)&nodeid, sizeof(int), (void*)1);
+		else
+			dm_hash_insert_binary(node_updown_hash, (void *)&nodeid, sizeof(int), (void*)0);
+	}
+}
+
+/* Get a list of active cluster members */
+static void get_members(void)
+{
+	int retnodes;
+	int status;
+	int i;
+	int high_nodeid = 0;
+
+	num_nodes = cman_get_node_count(c_handle);
+	if (num_nodes == -1) {
+		log_error("Unable to get node count");
+		return;
+	}
+
+	/* Not enough room for new nodes list ? */
+	if (num_nodes > count_nodes && nodes) {
+		free(nodes);
+		nodes = NULL;
+	}
+
+	if (nodes == NULL) {
+		count_nodes = num_nodes + 10; /* Overallocate a little */
+		nodes = malloc(count_nodes * sizeof(struct cman_node));
+		if (!nodes) {
+			log_error("Unable to allocate nodes array\n");
+			exit(5);
+		}
+	}
+
+	status = cman_get_nodes(c_handle, count_nodes, &retnodes, nodes);
+	if (status < 0) {
+		log_error("Unable to get node details");
+		exit(6);
+	}
+
+	/* Get the highest nodeid */
+	for (i=0; i<retnodes; i++) {
+		if (nodes[i].cn_nodeid > high_nodeid)
+			high_nodeid = nodes[i].cn_nodeid;
+	}
+}
+
+
+/* Convert a node name to a CSID */
+static int _csid_from_name(char *csid, const char *name)
+{
+	int i;
+
+	for (i = 0; i < num_nodes; i++) {
+		if (strcmp(name, nodes[i].cn_name) == 0) {
+			memcpy(csid, &nodes[i].cn_nodeid, CMAN_MAX_CSID_LEN);
+			return 0;
+		}
+	}
+	return -1;
+}
+
+/* Convert a CSID to a node name */
+static int _name_from_csid(const char *csid, char *name)
+{
+	int i;
+
+	for (i = 0; i < num_nodes; i++) {
+		if (memcmp(csid, &nodes[i].cn_nodeid, CMAN_MAX_CSID_LEN) == 0) {
+			strcpy(name, nodes[i].cn_name);
+			return 0;
+		}
+	}
+	/* Who?? */
+	strcpy(name, "Unknown");
+	return -1;
+}
+
+/* Convert a node ID to a node name */
+static int name_from_nodeid(int nodeid, char *name)
+{
+	int i;
+
+	for (i = 0; i < num_nodes; i++) {
+		if (nodeid == nodes[i].cn_nodeid) {
+			strcpy(name, nodes[i].cn_name);
+			return 0;
+		}
+	}
+	/* Who?? */
+	strcpy(name, "Unknown");
+	return -1;
+}
+
+/* Convert a CSID to a node ID */
+static int nodeid_from_csid(const char *csid)
+{
+        int nodeid;
+
+	memcpy(&nodeid, csid, CMAN_MAX_CSID_LEN);
+
+	return nodeid;
+}
+
+static int _is_quorate(void)
+{
+	return cman_is_quorate(c_handle);
+}
+
+static void sync_ast_routine(void *arg)
+{
+	struct lock_wait *lwait = arg;
+
+	pthread_mutex_lock(&lwait->mutex);
+	pthread_cond_signal(&lwait->cond);
+	pthread_mutex_unlock(&lwait->mutex);
+}
+
+static int _sync_lock(const char *resource, int mode, int flags, int *lockid)
+{
+	int status;
+	struct lock_wait lwait;
+
+	if (!lockid) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	DEBUGLOG("sync_lock: '%s' mode:%d flags=%d\n", resource,mode,flags);
+	/* Conversions need the lockid in the LKSB */
+	if (flags & LKF_CONVERT)
+		lwait.lksb.sb_lkid = *lockid;
+
+	pthread_cond_init(&lwait.cond, NULL);
+	pthread_mutex_init(&lwait.mutex, NULL);
+	pthread_mutex_lock(&lwait.mutex);
+
+	status = dlm_ls_lock(lockspace,
+			     mode,
+			     &lwait.lksb,
+			     flags,
+			     resource,
+			     strlen(resource),
+			     0, sync_ast_routine, &lwait, NULL, NULL);
+	if (status)
+		return status;
+
+	/* Wait for it to complete */
+	pthread_cond_wait(&lwait.cond, &lwait.mutex);
+	pthread_mutex_unlock(&lwait.mutex);
+
+	*lockid = lwait.lksb.sb_lkid;
+
+	errno = lwait.lksb.sb_status;
+	DEBUGLOG("sync_lock: returning lkid %x\n", *lockid);
+	if (lwait.lksb.sb_status)
+		return -1;
+	else
+		return 0;
+}
+
+static int _sync_unlock(const char *resource /* UNUSED */, int lockid)
+{
+	int status;
+	struct lock_wait lwait;
+
+	DEBUGLOG("sync_unlock: '%s' lkid:%x\n", resource, lockid);
+
+	pthread_cond_init(&lwait.cond, NULL);
+	pthread_mutex_init(&lwait.mutex, NULL);
+	pthread_mutex_lock(&lwait.mutex);
+
+	status = dlm_ls_unlock(lockspace, lockid, 0, &lwait.lksb, &lwait);
+
+	if (status)
+		return status;
+
+	/* Wait for it to complete */
+	pthread_cond_wait(&lwait.cond, &lwait.mutex);
+	pthread_mutex_unlock(&lwait.mutex);
+
+	errno = lwait.lksb.sb_status;
+	if (lwait.lksb.sb_status != EUNLOCK)
+		return -1;
+	else
+		return 0;
+
+}
+
+static int _get_cluster_name(char *buf, int buflen)
+{
+	cman_cluster_t cluster_info;
+	int status;
+
+	status = cman_get_cluster(c_handle, &cluster_info);
+	if (!status) {
+		strncpy(buf, cluster_info.ci_name, buflen);
+	}
+	return status;
+}
+
+static struct cluster_ops _cluster_cman_ops = {
+	.name                     = "cman",
+	.cluster_init_completed   = _cluster_init_completed,
+	.cluster_send_message     = _cluster_send_message,
+	.name_from_csid           = _name_from_csid,
+	.csid_from_name           = _csid_from_name,
+	.get_num_nodes            = _get_num_nodes,
+	.cluster_fd_callback      = _cluster_fd_callback,
+	.get_main_cluster_fd      = _get_main_cluster_fd,
+	.cluster_do_node_callback = _cluster_do_node_callback,
+	.is_quorate               = _is_quorate,
+	.get_our_csid             = _get_our_csid,
+	.add_up_node              = _add_up_node,
+	.cluster_closedown        = _cluster_closedown,
+	.get_cluster_name         = _get_cluster_name,
+	.sync_lock                = _sync_lock,
+	.sync_unlock              = _sync_unlock,
+};
+
+struct cluster_ops *init_cman_cluster(void)
+{
+	if (!_init_cluster())
+		return &_cluster_cman_ops;
+	else
+		return NULL;
+}

daemons/clvmd/clvmd-command.c

@@ -0,0 +1,415 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2011 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+
+  CLVMD Cluster LVM daemon command processor.
+
+  To add commands to the daemon simply add a processor in do_command and return
+  and messages back in buf and the length in *retlen. The initial value of
+  buflen is the maximum size of the buffer. if buf is not large enough then it
+  may be reallocated by the functions in here to a suitable size bearing in
+  mind that anything larger than the passed-in size will have to be returned
+  using the system LV and so performance will suffer.
+
+  The status return will be negated and passed back to the originating node.
+
+  pre- and post- command routines are called only on the local node. The
+  purpose is primarily to get and release locks, though the pre- routine should
+  also do any other local setups required by the command (if any) and can
+  return a failure code that prevents the command from being distributed around
+  the cluster
+
+  The pre- and post- routines are run in their own thread so can block as long
+  they like, do_command is run in the main clvmd thread so should not block for
+  too long. If the pre-command returns an error code (!=0) then the command
+  will not be propogated around the cluster but the post-command WILL be called
+
+  Also note that the pre and post routine are *always* called on the local
+  node, even if the command to be executed was only requested to run on a
+  remote node. It may peek inside the client structure to check the status of
+  the command.
+
+  The clients of the daemon must, naturally, understand the return messages and
+  codes.
+
+  Routines in here may only READ the values in the client structure passed in
+  apart from client->private which they are free to do what they like with.
+
+*/
+
+#include "clvmd-common.h"
+#include "clvmd-comms.h"
+#include "clvm.h"
+#include "clvmd.h"
+#include "lvm-globals.h"
+#include "lvm-functions.h"
+
+#include "locking.h"
+
+#include <sys/utsname.h>
+
+extern struct cluster_ops *clops;
+static int restart_clvmd(void);
+
+/* This is where all the real work happens:
+   NOTE: client will be NULL when this is executed on a remote node */
+int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
+	       char **buf, int buflen, int *retlen)
+{
+	char *args = msg->node + strlen(msg->node) + 1;
+	int arglen = msglen - sizeof(struct clvm_header) - strlen(msg->node);
+	int status = 0;
+	char *lockname;
+	const char *locktype;
+	struct utsname nodeinfo;
+	unsigned char lock_cmd;
+	unsigned char lock_flags;
+
+	/* Do the command */
+	switch (msg->cmd) {
+		/* Just a test message */
+	case CLVMD_CMD_TEST:
+		if (arglen > buflen) {
+			char *new_buf;
+			buflen = arglen + 200;
+			new_buf = realloc(*buf, buflen);
+			if (new_buf == NULL) {
+				status = errno;
+				free (*buf);
+			}
+			*buf = new_buf;
+		}
+		if (*buf) {
+			if (uname(&nodeinfo))
+				memset(&nodeinfo, 0, sizeof(nodeinfo));
+
+			*retlen = 1 + dm_snprintf(*buf, buflen,
+						  "TEST from %s: %s v%s",
+						  nodeinfo.nodename, args,
+						  nodeinfo.release);
+		}
+		break;
+
+	case CLVMD_CMD_LOCK_VG:
+		lock_cmd = args[0];
+		lock_flags = args[1];
+		lockname = &args[2];
+		/* Check to see if the VG is in use by LVM1 */
+		do_lock_vg(lock_cmd, lock_flags, lockname);
+		break;
+
+	case CLVMD_CMD_LOCK_LV:
+		/* This is the biggie */
+		lock_cmd = args[0];
+		lock_flags = args[1];
+		lockname = &args[2];
+		status = do_lock_lv(lock_cmd, lock_flags, lockname);
+		/* Replace EIO with something less scary */
+		if (status == EIO) {
+			*retlen = 1 + dm_snprintf(*buf, buflen, "%s",
+						  get_last_lvm_error());
+			return EIO;
+		}
+		break;
+
+	case CLVMD_CMD_LOCK_QUERY:
+		lockname = &args[2];
+		if (buflen < 3)
+			return EIO;
+		if ((locktype = do_lock_query(lockname)))
+			*retlen = 1 + dm_snprintf(*buf, buflen, "%s", locktype);
+		break;
+
+	case CLVMD_CMD_REFRESH:
+		do_refresh_cache();
+		break;
+
+	case CLVMD_CMD_SYNC_NAMES:
+		lvm_do_fs_unlock();
+		break;
+
+	case CLVMD_CMD_SET_DEBUG:
+		clvmd_set_debug((debug_t) args[0]);
+		break;
+
+	case CLVMD_CMD_RESTART:
+		status = restart_clvmd();
+		break;
+
+	case CLVMD_CMD_GET_CLUSTERNAME:
+		status = clops->get_cluster_name(*buf, buflen);
+		if (!status)
+			*retlen = strlen(*buf)+1;
+		break;
+
+	case CLVMD_CMD_VG_BACKUP:
+		/*
+		 * Do not run backup on local node, caller should do that.
+		 */
+		if (!client)
+			lvm_do_backup(&args[2]);
+		break;
+
+	default:
+		/* Won't get here because command is validated in pre_command */
+		break;
+	}
+
+	/* Check the status of the command and return the error text */
+	if (status) {
+		if (*buf)
+			*retlen = dm_snprintf(*buf, buflen, "%s", strerror(status)) + 1;
+		else
+			*retlen = 0;
+	}
+
+	return status;
+}
+
+static int lock_vg(struct local_client *client)
+{
+	struct dm_hash_table *lock_hash;
+	struct clvm_header *header =
+		(struct clvm_header *) client->bits.localsock.cmd;
+	unsigned char lock_cmd;
+	int lock_mode;
+	char *args = header->node + strlen(header->node) + 1;
+	int lkid;
+	int status;
+	char *lockname;
+
+	/*
+	 * Keep a track of VG locks in our own hash table. In current
+	 * practice there should only ever be more than two VGs locked
+	 * if a user tries to merge lots of them at once
+	 */
+	if (!client->bits.localsock.private) {
+		if (!(lock_hash = dm_hash_create(3)))
+			return ENOMEM;
+		client->bits.localsock.private = (void *) lock_hash;
+	} else
+		lock_hash = (struct dm_hash_table *) client->bits.localsock.private;
+
+	lock_cmd = args[0] & (LCK_NONBLOCK | LCK_HOLD | LCK_SCOPE_MASK | LCK_TYPE_MASK);
+	lock_mode = ((int) lock_cmd & LCK_TYPE_MASK);
+	/* lock_flags = args[1]; */
+	lockname = &args[2];
+	DEBUGLOG("(%p) doing PRE command LOCK_VG '%s' at %x\n", client, lockname, lock_cmd);
+
+	if (lock_mode == LCK_UNLOCK) {
+		if (!(lkid = (int) (long) dm_hash_lookup(lock_hash, lockname)))
+			return EINVAL;
+
+		if ((status = sync_unlock(lockname, lkid)))
+			status = errno;
+		else
+			dm_hash_remove(lock_hash, lockname);
+	} else {
+		/* Read locks need to be PR; other modes get passed through */
+		if (lock_mode == LCK_READ)
+			lock_mode = LCK_PREAD;
+
+		if ((status = sync_lock(lockname, lock_mode, (lock_cmd & LCK_NONBLOCK) ? LCKF_NOQUEUE : 0, &lkid)))
+			status = errno;
+		else if (!dm_hash_insert(lock_hash, lockname, (void *) (long) lkid))
+			return ENOMEM;
+	}
+
+	return status;
+}
+
+
+/* Pre-command is a good place to get locks that are needed only for the duration
+   of the commands around the cluster (don't forget to free them in post-command),
+   and to sanity check the command arguments */
+int do_pre_command(struct local_client *client)
+{
+	struct clvm_header *header =
+	    (struct clvm_header *) client->bits.localsock.cmd;
+	unsigned char lock_cmd;
+	unsigned char lock_flags;
+	char *args = header->node + strlen(header->node) + 1;
+	int lockid = 0;
+	int status = 0;
+	char *lockname;
+
+	switch (header->cmd) {
+	case CLVMD_CMD_TEST:
+		status = sync_lock("CLVMD_TEST", LCK_EXCL, 0, &lockid);
+		client->bits.localsock.private = (void *)(long)lockid;
+		break;
+
+	case CLVMD_CMD_LOCK_VG:
+		lockname = &args[2];
+		/* We take out a real lock unless LCK_CACHE was set */
+		if (!strncmp(lockname, "V_", 2) ||
+		    !strncmp(lockname, "P_#", 3))
+			status = lock_vg(client);
+		break;
+
+	case CLVMD_CMD_LOCK_LV:
+		lock_cmd = args[0];
+		lock_flags = args[1];
+		lockname = &args[2];
+		status = pre_lock_lv(lock_cmd, lock_flags, lockname);
+		break;
+
+	case CLVMD_CMD_REFRESH:
+	case CLVMD_CMD_GET_CLUSTERNAME:
+	case CLVMD_CMD_SET_DEBUG:
+	case CLVMD_CMD_VG_BACKUP:
+	case CLVMD_CMD_SYNC_NAMES:
+	case CLVMD_CMD_LOCK_QUERY:
+	case CLVMD_CMD_RESTART:
+		break;
+
+	default:
+		log_error("Unknown command %d received\n", header->cmd);
+		status = EINVAL;
+	}
+	return status;
+}
+
+/* Note that the post-command routine is called even if the pre-command or the real command
+   failed */
+int do_post_command(struct local_client *client)
+{
+	struct clvm_header *header =
+	    (struct clvm_header *) client->bits.localsock.cmd;
+	int status = 0;
+	unsigned char lock_cmd;
+	unsigned char lock_flags;
+	char *args = header->node + strlen(header->node) + 1;
+	char *lockname;
+
+	switch (header->cmd) {
+	case CLVMD_CMD_TEST:
+		status = sync_unlock("CLVMD_TEST", (int) (long) client->bits.localsock.private);
+		client->bits.localsock.private = NULL;
+		break;
+
+	case CLVMD_CMD_LOCK_LV:
+		lock_cmd = args[0];
+		lock_flags = args[1];
+		lockname = &args[2];
+		status = post_lock_lv(lock_cmd, lock_flags, lockname);
+		break;
+
+	default:
+		/* Nothing to do here */
+		break;
+	}
+	return status;
+}
+
+
+/* Called when the client is about to be deleted */
+void cmd_client_cleanup(struct local_client *client)
+{
+	struct dm_hash_node *v;
+	struct dm_hash_table *lock_hash;
+	int lkid;
+	char *lockname;
+
+	DEBUGLOG("(%p) Client thread cleanup\n", client);
+	if (!client->bits.localsock.private)
+		return;
+
+	lock_hash = (struct dm_hash_table *)client->bits.localsock.private;
+
+	dm_hash_iterate(v, lock_hash) {
+		lkid = (int)(long)dm_hash_get_data(lock_hash, v);
+		lockname = dm_hash_get_key(lock_hash, v);
+		DEBUGLOG("(%p) Cleanup: Unlocking lock %s %x\n", client, lockname, lkid);
+		(void) sync_unlock(lockname, lkid);
+	}
+
+	dm_hash_destroy(lock_hash);
+	client->bits.localsock.private = NULL;
+}
+
+static int restart_clvmd(void)
+{
+	const char **argv;
+	char *lv_name;
+	int argc = 0, max_locks = 0;
+	struct dm_hash_node *hn = NULL;
+	char debug_arg[16];
+	const char *clvmd = getenv("LVM_CLVMD_BINARY") ? : CLVMD_PATH;
+
+	DEBUGLOG("clvmd restart requested\n");
+
+	/* Count exclusively-open LVs */
+	do {
+		hn = get_next_excl_lock(hn, &lv_name);
+		if (lv_name) {
+			max_locks++;
+			if (!*lv_name)
+				break; /* FIXME: Is this error ? */
+		}
+	} while (hn);
+
+	/* clvmd + locks (-E uuid) + debug (-d X) + NULL */
+	if (!(argv = malloc((max_locks * 2 + 6) * sizeof(*argv))))
+		goto_out;
+
+	/*
+	 * Build the command-line
+	 */
+	argv[argc++] = "clvmd";
+
+	/* Propagate debug options */
+	if (clvmd_get_debug()) {
+		if (dm_snprintf(debug_arg, sizeof(debug_arg), "-d%u", clvmd_get_debug()) < 0)
+			goto_out;
+		argv[argc++] = debug_arg;
+	}
+
+	/* Propagate foreground options */
+	if (clvmd_get_foreground())
+		argv[argc++] = "-f";
+
+	argv[argc++] = "-I";
+	argv[argc++] = clops->name;
+
+	/* Now add the exclusively-open LVs */
+	hn = NULL;
+	do {
+		hn = get_next_excl_lock(hn, &lv_name);
+		if (lv_name) {
+			if (!*lv_name)
+				break; /* FIXME: Is this error ? */
+			argv[argc++] = "-E";
+			argv[argc++] = lv_name;
+			DEBUGLOG("excl lock: %s\n", lv_name);
+		}
+	} while (hn);
+	argv[argc] = NULL;
+
+	/* Exec new clvmd */
+	DEBUGLOG("--- Restarting %s ---\n", clvmd);
+	for (argc = 1; argv[argc]; argc++) DEBUGLOG("--- %d: %s\n", argc, argv[argc]);
+
+	/* NOTE: This will fail when downgrading! */
+	execvp(clvmd, (char **)argv);
+out:
+	/* We failed */
+	DEBUGLOG("Restart of clvmd failed.\n");
+
+	free(argv);
+
+	return EIO;
+}

daemons/clvmd/clvmd-common.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2010 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -12,11 +12,16 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef _LIBDM_KDEV_H
-#define _LIBDM_KDEV_H
+/*
+ * This file must be included first by every clvmd source file.
+ */
+#ifndef _LVM_CLVMD_COMMON_H
+#define _LVM_CLVMD_COMMON_H
 
-#define MAJOR(dev)      ((dev & 0xfff00) >> 8)
-#define MINOR(dev)      ((dev & 0xff) | ((dev >> 12) & 0xfff00))
-#define MKDEV(ma,mi)    (((dev_t)mi & 0xff) | ((dev_t)ma << 8) | (((dev_t)mi & ~0xff) << 12))
+#define _REENTRANT
+
+#include "tool.h"
+
+#include "lvm-logging.h"
 
 #endif

daemons/clvmd/clvmd-comms.h

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2011 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * Abstraction layer for clvmd cluster communications
+ */
+
+#ifndef _CLVMD_COMMS_H
+#define _CLVMD_COMMS_H
+
+struct local_client;
+
+struct cluster_ops {
+	const char *name;
+	void (*cluster_init_completed) (void);
+
+	int (*cluster_send_message) (const void *buf, int msglen,
+				     const char *csid,
+				     const char *errtext);
+	int (*name_from_csid) (const char *csid, char *name);
+	int (*csid_from_name) (char *csid, const char *name);
+	int (*get_num_nodes) (void);
+	int (*cluster_fd_callback) (struct local_client *fd, char *buf, int len,
+				    const char *csid,
+				    struct local_client **new_client);
+	int (*get_main_cluster_fd) (void);	/* gets accept FD or cman cluster socket */
+	int (*cluster_do_node_callback) (struct local_client *client,
+					 void (*callback) (struct local_client *,
+							   const char *csid,
+							   int node_up));
+	int (*is_quorate) (void);
+
+	void (*get_our_csid) (char *csid);
+	void (*add_up_node) (const char *csid);
+	void (*reread_config) (void);
+	void (*cluster_closedown) (void);
+
+	int (*get_cluster_name)(char *buf, int buflen);
+
+	int (*sync_lock) (const char *resource, int mode,
+			  int flags, int *lockid);
+	int (*sync_unlock) (const char *resource, int lockid);
+
+};
+
+#ifdef USE_CMAN
+#  include <netinet/in.h>
+#  include "libcman.h"
+#  define CMAN_MAX_CSID_LEN 4
+#  ifndef MAX_CSID_LEN
+#    define MAX_CSID_LEN CMAN_MAX_CSID_LEN
+#  endif
+#  undef MAX_CLUSTER_MEMBER_NAME_LEN
+#  define MAX_CLUSTER_MEMBER_NAME_LEN   CMAN_MAX_NODENAME_LEN
+#  define CMAN_MAX_CLUSTER_MESSAGE 1500
+#  define CLUSTER_PORT_CLVMD 11
+struct cluster_ops *init_cman_cluster(void);
+#endif
+
+#ifdef USE_OPENAIS
+#  include <openais/saAis.h>
+#  include <corosync/totem/totem.h>
+#  define OPENAIS_CSID_LEN (sizeof(int))
+#  define OPENAIS_MAX_CLUSTER_MESSAGE         MESSAGE_SIZE_MAX
+#  define OPENAIS_MAX_CLUSTER_MEMBER_NAME_LEN SA_MAX_NAME_LENGTH
+#  ifndef MAX_CLUSTER_MEMBER_NAME_LEN
+#    define MAX_CLUSTER_MEMBER_NAME_LEN       SA_MAX_NAME_LENGTH
+#  endif
+#  ifndef CMAN_MAX_CLUSTER_MESSAGE
+#    define CMAN_MAX_CLUSTER_MESSAGE          MESSAGE_SIZE_MAX
+#  endif
+#  ifndef MAX_CSID_LEN
+#    define MAX_CSID_LEN sizeof(int)
+#  endif
+struct cluster_ops *init_openais_cluster(void);
+#endif
+
+#ifdef USE_COROSYNC
+#  include <corosync/corotypes.h>
+#  define COROSYNC_CSID_LEN (sizeof(int))
+#  define COROSYNC_MAX_CLUSTER_MESSAGE         65535
+#  define COROSYNC_MAX_CLUSTER_MEMBER_NAME_LEN CS_MAX_NAME_LENGTH
+#  ifndef MAX_CLUSTER_MEMBER_NAME_LEN
+#    define MAX_CLUSTER_MEMBER_NAME_LEN       CS_MAX_NAME_LENGTH
+#  endif
+#  ifndef CMAN_MAX_CLUSTER_MESSAGE
+#    define CMAN_MAX_CLUSTER_MESSAGE          65535
+#  endif
+#  ifndef MAX_CSID_LEN
+#    define MAX_CSID_LEN sizeof(int)
+#  endif
+struct cluster_ops *init_corosync_cluster(void);
+#endif
+
+#ifdef USE_SINGLENODE
+#  define SINGLENODE_CSID_LEN (sizeof(int))
+#  ifndef MAX_CLUSTER_MEMBER_NAME_LEN
+#    define MAX_CLUSTER_MEMBER_NAME_LEN       64
+#  endif
+#  define SINGLENODE_MAX_CLUSTER_MESSAGE          65535
+#  ifndef MAX_CSID_LEN
+#    define MAX_CSID_LEN sizeof(int)
+#  endif
+struct cluster_ops *init_singlenode_cluster(void);
+#endif
+
+#endif

daemons/clvmd/clvmd-corosync.c

@@ -0,0 +1,662 @@
+/*
+ * Copyright (C) 2009-2012 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
+ */
+
+/*
+ * This provides the interface between clvmd and corosync/DLM as the cluster
+ * and lock manager.
+ */
+
+#include "clvmd-common.h"
+
+#include <pthread.h>
+
+#include "clvm.h"
+#include "clvmd-comms.h"
+#include "clvmd.h"
+#include "lvm-functions.h"
+
+#include "locking.h"
+
+#include <corosync/cpg.h>
+#include <corosync/quorum.h>
+
+#ifdef HAVE_COROSYNC_CONFDB_H
+#  include <corosync/confdb.h>
+#elif defined HAVE_COROSYNC_CMAP_H
+#  include <corosync/cmap.h>
+#else
+#  error "Either HAVE_COROSYNC_CONFDB_H or HAVE_COROSYNC_CMAP_H must be defined."
+#endif
+
+#include <libdlm.h>
+
+#include <syslog.h>
+
+/* Timeout value for several corosync calls */
+#define LOCKSPACE_NAME "clvmd"
+
+static void corosync_cpg_deliver_callback (cpg_handle_t handle,
+				  const struct cpg_name *groupName,
+				  uint32_t nodeid,
+				  uint32_t pid,
+				  void *msg,
+				  size_t msg_len);
+static void corosync_cpg_confchg_callback(cpg_handle_t handle,
+				 const struct cpg_name *groupName,
+				 const struct cpg_address *member_list, size_t member_list_entries,
+				 const struct cpg_address *left_list, size_t left_list_entries,
+				 const struct cpg_address *joined_list, size_t joined_list_entries);
+static void _cluster_closedown(void);
+
+/* Hash list of nodes in the cluster */
+static struct dm_hash_table *node_hash;
+
+/* Number of active nodes */
+static int num_nodes;
+static unsigned int our_nodeid;
+
+static struct local_client *cluster_client;
+
+/* Corosync handles */
+static cpg_handle_t cpg_handle;
+static quorum_handle_t quorum_handle;
+
+/* DLM Handle */
+static dlm_lshandle_t *lockspace;
+
+static struct cpg_name cpg_group_name;
+
+/* Corosync callback structs */
+cpg_callbacks_t corosync_cpg_callbacks = {
+	.cpg_deliver_fn =            corosync_cpg_deliver_callback,
+	.cpg_confchg_fn =            corosync_cpg_confchg_callback,
+};
+
+quorum_callbacks_t quorum_callbacks = {
+	.quorum_notify_fn = NULL,
+};
+
+struct node_info
+{
+	enum {NODE_DOWN, NODE_CLVMD} state;
+	int nodeid;
+};
+
+
+/* Set errno to something approximating the right value and return 0 or -1 */
+static int cs_to_errno(cs_error_t err)
+{
+	switch(err)
+	{
+	case CS_OK:
+		return 0;
+        case CS_ERR_LIBRARY:
+		errno = EINVAL;
+		break;
+        case CS_ERR_VERSION:
+		errno = EINVAL;
+		break;
+        case CS_ERR_INIT:
+		errno = EINVAL;
+		break;
+        case CS_ERR_TIMEOUT:
+		errno = ETIME;
+		break;
+        case CS_ERR_TRY_AGAIN:
+		errno = EAGAIN;
+		break;
+        case CS_ERR_INVALID_PARAM:
+		errno = EINVAL;
+		break;
+        case CS_ERR_NO_MEMORY:
+		errno = ENOMEM;
+		break;
+        case CS_ERR_BAD_HANDLE:
+		errno = EINVAL;
+		break;
+        case CS_ERR_BUSY:
+		errno = EBUSY;
+		break;
+        case CS_ERR_ACCESS:
+		errno = EPERM;
+		break;
+        case CS_ERR_NOT_EXIST:
+		errno = ENOENT;
+		break;
+        case CS_ERR_NAME_TOO_LONG:
+		errno = ENAMETOOLONG;
+		break;
+        case CS_ERR_EXIST:
+		errno = EEXIST;
+		break;
+        case CS_ERR_NO_SPACE:
+		errno = ENOSPC;
+		break;
+        case CS_ERR_INTERRUPT:
+		errno = EINTR;
+		break;
+	case CS_ERR_NAME_NOT_FOUND:
+		errno = ENOENT;
+		break;
+        case CS_ERR_NO_RESOURCES:
+		errno = ENOMEM;
+		break;
+        case CS_ERR_NOT_SUPPORTED:
+		errno = EOPNOTSUPP;
+		break;
+        case CS_ERR_BAD_OPERATION:
+		errno = EINVAL;
+		break;
+        case CS_ERR_FAILED_OPERATION:
+		errno = EIO;
+		break;
+        case CS_ERR_MESSAGE_ERROR:
+		errno = EIO;
+		break;
+        case CS_ERR_QUEUE_FULL:
+		errno = EXFULL;
+		break;
+        case CS_ERR_QUEUE_NOT_AVAILABLE:
+		errno = EINVAL;
+		break;
+        case CS_ERR_BAD_FLAGS:
+		errno = EINVAL;
+		break;
+        case CS_ERR_TOO_BIG:
+		errno = E2BIG;
+		break;
+        case CS_ERR_NO_SECTIONS:
+		errno = ENOMEM;
+		break;
+	default:
+		errno = EINVAL;
+		break;
+	}
+	return -1;
+}
+
+static char *print_corosync_csid(const char *csid)
+{
+	static char buf[128];
+	int id;
+
+	memcpy(&id, csid, sizeof(int));
+	sprintf(buf, "%d", id);
+	return buf;
+}
+
+static void corosync_cpg_deliver_callback (cpg_handle_t handle,
+				  const struct cpg_name *groupName,
+				  uint32_t nodeid,
+				  uint32_t pid,
+				  void *msg,
+				  size_t msg_len)
+{
+	int target_nodeid;
+
+	memcpy(&target_nodeid, msg, COROSYNC_CSID_LEN);
+
+	DEBUGLOG("%u got message from nodeid %d for %d. len %zd\n",
+		 our_nodeid, nodeid, target_nodeid, msg_len-4);
+
+	if (nodeid != our_nodeid)
+		if (target_nodeid == our_nodeid || target_nodeid == 0)
+			process_message(cluster_client, (char *)msg+COROSYNC_CSID_LEN,
+					msg_len-COROSYNC_CSID_LEN, (char*)&nodeid);
+}
+
+static void corosync_cpg_confchg_callback(cpg_handle_t handle,
+				 const struct cpg_name *groupName,
+				 const struct cpg_address *member_list, size_t member_list_entries,
+				 const struct cpg_address *left_list, size_t left_list_entries,
+				 const struct cpg_address *joined_list, size_t joined_list_entries)
+{
+	int i;
+	struct node_info *ninfo;
+
+	DEBUGLOG("confchg callback. %zd joined, %zd left, %zd members\n",
+		 joined_list_entries, left_list_entries, member_list_entries);
+
+	for (i=0; i<joined_list_entries; i++) {
+		ninfo = dm_hash_lookup_binary(node_hash,
+					      (char *)&joined_list[i].nodeid,
+					      COROSYNC_CSID_LEN);
+		if (!ninfo) {
+			ninfo = malloc(sizeof(struct node_info));
+			if (!ninfo) {
+				break;
+			}
+			else {
+				ninfo->nodeid = joined_list[i].nodeid;
+				dm_hash_insert_binary(node_hash,
+						      (char *)&ninfo->nodeid,
+						      COROSYNC_CSID_LEN, ninfo);
+			}
+		}
+		ninfo->state = NODE_CLVMD;
+	}
+
+	for (i=0; i<left_list_entries; i++) {
+		ninfo = dm_hash_lookup_binary(node_hash,
+					      (char *)&left_list[i].nodeid,
+					      COROSYNC_CSID_LEN);
+		if (ninfo)
+			ninfo->state = NODE_DOWN;
+	}
+
+	num_nodes = member_list_entries;
+}
+
+static int _init_cluster(void)
+{
+	cs_error_t err;
+
+#ifdef QUORUM_SET	/* corosync/quorum.h */
+	uint32_t quorum_type;
+#endif
+
+	node_hash = dm_hash_create(100);
+
+	err = cpg_initialize(&cpg_handle,
+			     &corosync_cpg_callbacks);
+	if (err != CS_OK) {
+		syslog(LOG_ERR, "Cannot initialise Corosync CPG service: %d",
+		       err);
+		DEBUGLOG("Cannot initialise Corosync CPG service: %d", err);
+		return cs_to_errno(err);
+	}
+
+#ifdef QUORUM_SET
+	err = quorum_initialize(&quorum_handle,
+				&quorum_callbacks,
+				&quorum_type);
+
+	if (quorum_type != QUORUM_SET) {
+		syslog(LOG_ERR, "Corosync quorum service is not configured");
+		DEBUGLOG("Corosync quorum service is not configured");
+		return EINVAL;
+	}
+#else
+	err = quorum_initialize(&quorum_handle,
+				&quorum_callbacks);
+#endif
+
+	if (err != CS_OK) {
+		syslog(LOG_ERR, "Cannot initialise Corosync quorum service: %d",
+		       err);
+		DEBUGLOG("Cannot initialise Corosync quorum service: %d", err);
+		return cs_to_errno(err);
+	}
+
+	/* Create a lockspace for LV & VG locks to live in */
+	lockspace = dlm_open_lockspace(LOCKSPACE_NAME);
+	if (!lockspace) {
+		lockspace = dlm_create_lockspace(LOCKSPACE_NAME, 0600);
+		if (!lockspace) {
+			syslog(LOG_ERR, "Unable to create DLM lockspace for CLVM: %m");
+			return -1;
+		}
+		DEBUGLOG("Created DLM lockspace for CLVMD.\n");
+	} else
+		DEBUGLOG("Opened existing DLM lockspace for CLVMD.\n");
+
+	dlm_ls_pthread_init(lockspace);
+	DEBUGLOG("DLM initialisation complete\n");
+
+	/* Connect to the clvmd group */
+	strcpy((char *)cpg_group_name.value, "clvmd");
+	cpg_group_name.length = strlen((char *)cpg_group_name.value);
+	err = cpg_join(cpg_handle, &cpg_group_name);
+	if (err != CS_OK) {
+		cpg_finalize(cpg_handle);
+		quorum_finalize(quorum_handle);
+		dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
+		syslog(LOG_ERR, "Cannot join clvmd process group");
+		DEBUGLOG("Cannot join clvmd process group: %d\n", err);
+		return cs_to_errno(err);
+	}
+
+	err = cpg_local_get(cpg_handle,
+			    &our_nodeid);
+	if (err != CS_OK) {
+		cpg_finalize(cpg_handle);
+		quorum_finalize(quorum_handle);
+		dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
+		syslog(LOG_ERR, "Cannot get local node id\n");
+		return cs_to_errno(err);
+	}
+	DEBUGLOG("Our local node id is %d\n", our_nodeid);
+
+	DEBUGLOG("Connected to Corosync\n");
+
+	return 0;
+}
+
+static void _cluster_closedown(void)
+{
+	dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
+	cpg_finalize(cpg_handle);
+	quorum_finalize(quorum_handle);
+}
+
+static void _get_our_csid(char *csid)
+{
+	memcpy(csid, &our_nodeid, sizeof(int));
+}
+
+/* Corosync doesn't really have nmode names so we
+   just use the node ID in hex instead */
+static int _csid_from_name(char *csid, const char *name)
+{
+	int nodeid;
+	struct node_info *ninfo;
+
+	if (sscanf(name, "%x", &nodeid) == 1) {
+		ninfo = dm_hash_lookup_binary(node_hash, csid, COROSYNC_CSID_LEN);
+		if (ninfo)
+			return nodeid;
+	}
+	return -1;
+}
+
+static int _name_from_csid(const char *csid, char *name)
+{
+	struct node_info *ninfo;
+
+	ninfo = dm_hash_lookup_binary(node_hash, csid, COROSYNC_CSID_LEN);
+	if (!ninfo)
+	{
+		sprintf(name, "UNKNOWN %s", print_corosync_csid(csid));
+		return -1;
+	}
+
+	sprintf(name, "%x", ninfo->nodeid);
+	return 0;
+}
+
+static int _get_num_nodes(void)
+{
+	DEBUGLOG("num_nodes = %d\n", num_nodes);
+	return num_nodes;
+}
+
+/* Node is now known to be running a clvmd */
+static void _add_up_node(const char *csid)
+{
+	struct node_info *ninfo;
+
+	ninfo = dm_hash_lookup_binary(node_hash, csid, COROSYNC_CSID_LEN);
+	if (!ninfo) {
+		DEBUGLOG("corosync_add_up_node no node_hash entry for csid %s\n",
+			 print_corosync_csid(csid));
+		return;
+	}
+
+	DEBUGLOG("corosync_add_up_node %d\n", ninfo->nodeid);
+
+	ninfo->state = NODE_CLVMD;
+
+	return;
+}
+
+/* Call a callback for each node, so the caller knows whether it's up or down */
+static int _cluster_do_node_callback(struct local_client *master_client,
+				     void (*callback)(struct local_client *,
+						      const char *csid, int node_up))
+{
+	struct dm_hash_node *hn;
+	struct node_info *ninfo;
+
+	dm_hash_iterate(hn, node_hash)
+	{
+		char csid[COROSYNC_CSID_LEN];
+
+		ninfo = dm_hash_get_data(node_hash, hn);
+		memcpy(csid, dm_hash_get_key(node_hash, hn), COROSYNC_CSID_LEN);
+
+		DEBUGLOG("down_callback. node %d, state = %d\n", ninfo->nodeid,
+			 ninfo->state);
+
+		if (ninfo->state == NODE_CLVMD)
+			callback(master_client, csid, 1);
+	}
+	return 0;
+}
+
+/* Real locking */
+static int _lock_resource(const char *resource, int mode, int flags, int *lockid)
+{
+	struct dlm_lksb lksb;
+	int err;
+
+	DEBUGLOG("lock_resource '%s', flags=%d, mode=%d\n", resource, flags, mode);
+
+	if (flags & LKF_CONVERT)
+		lksb.sb_lkid = *lockid;
+
+	err = dlm_ls_lock_wait(lockspace,
+			       mode,
+			       &lksb,
+			       flags,
+			       resource,
+			       strlen(resource),
+			       0,
+			       NULL, NULL, NULL);
+
+	if (err != 0)
+	{
+		DEBUGLOG("dlm_ls_lock returned %d\n", errno);
+		return err;
+	}
+	if (lksb.sb_status != 0)
+	{
+		DEBUGLOG("dlm_ls_lock returns lksb.sb_status %d\n", lksb.sb_status);
+		errno = lksb.sb_status;
+		return -1;
+	}
+
+	DEBUGLOG("lock_resource returning %d, lock_id=%x\n", err, lksb.sb_lkid);
+
+	*lockid = lksb.sb_lkid;
+
+	return 0;
+}
+
+
+static int _unlock_resource(const char *resource, int lockid)
+{
+	struct dlm_lksb lksb;
+	int err;
+
+	DEBUGLOG("unlock_resource: %s lockid: %x\n", resource, lockid);
+	lksb.sb_lkid = lockid;
+
+	err = dlm_ls_unlock_wait(lockspace,
+				 lockid,
+				 0,
+				 &lksb);
+	if (err != 0)
+	{
+		DEBUGLOG("Unlock returned %d\n", err);
+		return err;
+	}
+	if (lksb.sb_status != EUNLOCK)
+	{
+		DEBUGLOG("dlm_ls_unlock_wait returns lksb.sb_status: %d\n", lksb.sb_status);
+		errno = lksb.sb_status;
+		return -1;
+	}   
+
+
+	return 0;
+}
+
+static int _is_quorate(void)
+{
+	int quorate;
+	if (quorum_getquorate(quorum_handle, &quorate) == CS_OK)
+		return quorate;
+	else
+		return 0;
+}
+
+static int _get_main_cluster_fd(void)
+{
+	int select_fd;
+
+	cpg_fd_get(cpg_handle, &select_fd);
+	return select_fd;
+}
+
+static int _cluster_fd_callback(struct local_client *fd, char *buf, int len,
+				const char *csid,
+				struct local_client **new_client)
+{
+	cluster_client = fd;
+	*new_client = NULL;
+	cpg_dispatch(cpg_handle, CS_DISPATCH_ONE);
+	return 1;
+}
+
+static int _cluster_send_message(const void *buf, int msglen, const char *csid,
+				 const char *errtext)
+{
+	static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
+	struct iovec iov[2];
+	cs_error_t err;
+	int target_node;
+
+	if (csid)
+		memcpy(&target_node, csid, COROSYNC_CSID_LEN);
+	else
+		target_node = 0;
+
+	iov[0].iov_base = &target_node;
+	iov[0].iov_len = sizeof(int);
+	iov[1].iov_base = (char *)buf;
+	iov[1].iov_len = msglen;
+
+	pthread_mutex_lock(&_mutex);
+	err = cpg_mcast_joined(cpg_handle, CPG_TYPE_AGREED, iov, 2);
+	pthread_mutex_unlock(&_mutex);
+
+	return cs_to_errno(err);
+}
+
+#ifdef HAVE_COROSYNC_CONFDB_H
+/*
+ * We are not necessarily connected to a Red Hat Cluster system,
+ * but if we are, this returns the cluster name from cluster.conf.
+ * I've used confdb rather than ccs to reduce the inter-package
+ * dependancies as well as to allow people to set a cluster name
+ * for themselves even if they are not running on RH cluster.
+ */
+static int _get_cluster_name(char *buf, int buflen)
+{
+	confdb_handle_t handle;
+	int result;
+	size_t namelen = buflen;
+	hdb_handle_t cluster_handle;
+	confdb_callbacks_t callbacks = {
+		.confdb_key_change_notify_fn = NULL,
+		.confdb_object_create_change_notify_fn = NULL,
+		.confdb_object_delete_change_notify_fn = NULL
+	};
+
+	/* This is a default in case everything else fails */
+	strncpy(buf, "Corosync", buflen);
+
+	/* Look for a cluster name in confdb */
+	result = confdb_initialize (&handle, &callbacks);
+        if (result != CS_OK)
+		return 0;
+
+        result = confdb_object_find_start(handle, OBJECT_PARENT_HANDLE);
+	if (result != CS_OK)
+		goto out;
+
+        result = confdb_object_find(handle, OBJECT_PARENT_HANDLE, (void *)"cluster", strlen("cluster"), &cluster_handle);
+        if (result != CS_OK)
+		goto out;
+
+        result = confdb_key_get(handle, cluster_handle, (void *)"name", strlen("name"), buf, &namelen);
+        if (result != CS_OK)
+		goto out;
+
+	buf[namelen] = '\0';
+
+out:
+	confdb_finalize(handle);
+	return 0;
+}
+
+#elif defined HAVE_COROSYNC_CMAP_H
+
+static int _get_cluster_name(char *buf, int buflen)
+{
+	cmap_handle_t cmap_handle = 0;
+	int result;
+	char *name = NULL;
+
+	/* This is a default in case everything else fails */
+	strncpy(buf, "Corosync", buflen);
+
+	/* Look for a cluster name in cmap */
+	result = cmap_initialize(&cmap_handle);
+	if (result != CS_OK)
+		return 0;
+
+	result = cmap_get_string(cmap_handle, "totem.cluster_name", &name);
+	if (result != CS_OK)
+		goto out;
+
+	memset(buf, 0, buflen);
+	strncpy(buf, name, buflen - 1);
+
+out:
+	if (name)
+		free(name);
+	cmap_finalize(cmap_handle);
+	return 0;
+}
+
+#endif
+
+static struct cluster_ops _cluster_corosync_ops = {
+	.name                     = "corosync",
+	.cluster_init_completed   = NULL,
+	.cluster_send_message     = _cluster_send_message,
+	.name_from_csid           = _name_from_csid,
+	.csid_from_name           = _csid_from_name,
+	.get_num_nodes            = _get_num_nodes,
+	.cluster_fd_callback      = _cluster_fd_callback,
+	.get_main_cluster_fd      = _get_main_cluster_fd,
+	.cluster_do_node_callback = _cluster_do_node_callback,
+	.is_quorate               = _is_quorate,
+	.get_our_csid             = _get_our_csid,
+	.add_up_node              = _add_up_node,
+	.reread_config            = NULL,
+	.cluster_closedown        = _cluster_closedown,
+	.get_cluster_name         = _get_cluster_name,
+	.sync_lock                = _lock_resource,
+	.sync_unlock              = _unlock_resource,
+};
+
+struct cluster_ops *init_corosync_cluster(void)
+{
+	if (!_init_cluster())
+		return &_cluster_corosync_ops;
+	else
+		return NULL;
+}

daemons/clvmd/clvmd-openais.c

@@ -0,0 +1,687 @@
+/*
+ * Copyright (C) 2007-2009 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
+ */
+
+/*
+ * This provides the interface between clvmd and OpenAIS as the cluster
+ * and lock manager.
+ */
+
+#include "clvmd-common.h"
+
+#include <pthread.h>
+#include <fcntl.h>
+#include <syslog.h>
+
+#include <openais/saAis.h>
+#include <openais/saLck.h>
+
+#include <corosync/corotypes.h>
+#include <corosync/cpg.h>
+
+#include "locking.h"
+#include "clvm.h"
+#include "clvmd-comms.h"
+#include "lvm-functions.h"
+#include "clvmd.h"
+
+/* Timeout value for several openais calls */
+#define TIMEOUT 10
+
+static void openais_cpg_deliver_callback (cpg_handle_t handle,
+				  const struct cpg_name *groupName,
+				  uint32_t nodeid,
+				  uint32_t pid,
+				  void *msg,
+				  size_t msg_len);
+static void openais_cpg_confchg_callback(cpg_handle_t handle,
+				 const struct cpg_name *groupName,
+				 const struct cpg_address *member_list, size_t member_list_entries,
+				 const struct cpg_address *left_list, size_t left_list_entries,
+				 const struct cpg_address *joined_list, size_t joined_list_entries);
+
+static void _cluster_closedown(void);
+
+/* Hash list of nodes in the cluster */
+static struct dm_hash_table *node_hash;
+
+/* For associating lock IDs & resource handles */
+static struct dm_hash_table *lock_hash;
+
+/* Number of active nodes */
+static int num_nodes;
+static unsigned int our_nodeid;
+
+static struct local_client *cluster_client;
+
+/* OpenAIS handles */
+static cpg_handle_t cpg_handle;
+static SaLckHandleT lck_handle;
+
+static struct cpg_name cpg_group_name;
+
+/* Openais callback structs */
+cpg_callbacks_t openais_cpg_callbacks = {
+	.cpg_deliver_fn =            openais_cpg_deliver_callback,
+	.cpg_confchg_fn =            openais_cpg_confchg_callback,
+};
+
+struct node_info
+{
+	enum {NODE_UNKNOWN, NODE_DOWN, NODE_UP, NODE_CLVMD} state;
+	int nodeid;
+};
+
+struct lock_info
+{
+	SaLckResourceHandleT res_handle;
+	SaLckLockIdT         lock_id;
+	SaNameT              lock_name;
+};
+
+/* Set errno to something approximating the right value and return 0 or -1 */
+static int ais_to_errno(SaAisErrorT err)
+{
+	switch(err)
+	{
+	case SA_AIS_OK:
+		return 0;
+        case SA_AIS_ERR_LIBRARY:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_VERSION:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_INIT:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_TIMEOUT:
+		errno = ETIME;
+		break;
+        case SA_AIS_ERR_TRY_AGAIN:
+		errno = EAGAIN;
+		break;
+        case SA_AIS_ERR_INVALID_PARAM:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_NO_MEMORY:
+		errno = ENOMEM;
+		break;
+        case SA_AIS_ERR_BAD_HANDLE:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_BUSY:
+		errno = EBUSY;
+		break;
+        case SA_AIS_ERR_ACCESS:
+		errno = EPERM;
+		break;
+        case SA_AIS_ERR_NOT_EXIST:
+		errno = ENOENT;
+		break;
+        case SA_AIS_ERR_NAME_TOO_LONG:
+		errno = ENAMETOOLONG;
+		break;
+        case SA_AIS_ERR_EXIST:
+		errno = EEXIST;
+		break;
+        case SA_AIS_ERR_NO_SPACE:
+		errno = ENOSPC;
+		break;
+        case SA_AIS_ERR_INTERRUPT:
+		errno = EINTR;
+		break;
+	case SA_AIS_ERR_NAME_NOT_FOUND:
+		errno = ENOENT;
+		break;
+        case SA_AIS_ERR_NO_RESOURCES:
+		errno = ENOMEM;
+		break;
+        case SA_AIS_ERR_NOT_SUPPORTED:
+		errno = EOPNOTSUPP;
+		break;
+        case SA_AIS_ERR_BAD_OPERATION:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_FAILED_OPERATION:
+		errno = EIO;
+		break;
+        case SA_AIS_ERR_MESSAGE_ERROR:
+		errno = EIO;
+		break;
+        case SA_AIS_ERR_QUEUE_FULL:
+		errno = EXFULL;
+		break;
+        case SA_AIS_ERR_QUEUE_NOT_AVAILABLE:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_BAD_FLAGS:
+		errno = EINVAL;
+		break;
+        case SA_AIS_ERR_TOO_BIG:
+		errno = E2BIG;
+		break;
+        case SA_AIS_ERR_NO_SECTIONS:
+		errno = ENOMEM;
+		break;
+	default:
+		errno = EINVAL;
+		break;
+	}
+	return -1;
+}
+
+static char *print_openais_csid(const char *csid)
+{
+	static char buf[128];
+	int id;
+
+	memcpy(&id, csid, sizeof(int));
+	sprintf(buf, "%d", id);
+	return buf;
+}
+
+static int add_internal_client(int fd, fd_callback_t callback)
+{
+	struct local_client *client;
+
+	DEBUGLOG("Add_internal_client, fd = %d\n", fd);
+
+	if (!(client = dm_zalloc(sizeof(*client)))) {
+		DEBUGLOG("malloc failed\n");
+		return -1;
+	}
+
+	client->fd = fd;
+	client->type = CLUSTER_INTERNAL;
+	client->callback = callback;
+	add_client(client);
+
+	/* Set Close-on-exec */
+	fcntl(fd, F_SETFD, 1);
+
+	return 0;
+}
+
+static void openais_cpg_deliver_callback (cpg_handle_t handle,
+				  const struct cpg_name *groupName,
+				  uint32_t nodeid,
+				  uint32_t pid,
+				  void *msg,
+				  size_t msg_len)
+{
+	int target_nodeid;
+
+	memcpy(&target_nodeid, msg, OPENAIS_CSID_LEN);
+
+	DEBUGLOG("%u got message from nodeid %d for %d. len %" PRIsize_t "\n",
+		 our_nodeid, nodeid, target_nodeid, msg_len-4);
+
+	if (nodeid != our_nodeid)
+		if (target_nodeid == our_nodeid || target_nodeid == 0)
+			process_message(cluster_client, (char *)msg+OPENAIS_CSID_LEN,
+					msg_len-OPENAIS_CSID_LEN, (char*)&nodeid);
+}
+
+static void openais_cpg_confchg_callback(cpg_handle_t handle,
+				 const struct cpg_name *groupName,
+				 const struct cpg_address *member_list, size_t member_list_entries,
+				 const struct cpg_address *left_list, size_t left_list_entries,
+				 const struct cpg_address *joined_list, size_t joined_list_entries)
+{
+	int i;
+	struct node_info *ninfo;
+
+	DEBUGLOG("confchg callback. %" PRIsize_t " joined, "
+		 FMTsize_t " left, %" PRIsize_t " members\n",
+		 joined_list_entries, left_list_entries, member_list_entries);
+
+	for (i=0; i<joined_list_entries; i++) {
+		ninfo = dm_hash_lookup_binary(node_hash,
+					      (char *)&joined_list[i].nodeid,
+					      OPENAIS_CSID_LEN);
+		if (!ninfo) {
+			ninfo = malloc(sizeof(struct node_info));
+			if (!ninfo) {
+				break;
+			}
+			else {
+				ninfo->nodeid = joined_list[i].nodeid;
+				dm_hash_insert_binary(node_hash,
+						      (char *)&ninfo->nodeid,
+						      OPENAIS_CSID_LEN, ninfo);
+			}
+		}
+		ninfo->state = NODE_CLVMD;
+	}
+
+	for (i=0; i<left_list_entries; i++) {
+		ninfo = dm_hash_lookup_binary(node_hash,
+					      (char *)&left_list[i].nodeid,
+					      OPENAIS_CSID_LEN);
+		if (ninfo)
+			ninfo->state = NODE_DOWN;
+	}
+
+	for (i=0; i<member_list_entries; i++) {
+		if (member_list[i].nodeid == 0) continue;
+		ninfo = dm_hash_lookup_binary(node_hash,
+				(char *)&member_list[i].nodeid,
+				OPENAIS_CSID_LEN);
+		if (!ninfo) {
+			ninfo = malloc(sizeof(struct node_info));
+			if (!ninfo) {
+				break;
+			}
+			else {
+				ninfo->nodeid = member_list[i].nodeid;
+				dm_hash_insert_binary(node_hash,
+						(char *)&ninfo->nodeid,
+						OPENAIS_CSID_LEN, ninfo);
+			}
+		}
+		ninfo->state = NODE_CLVMD;
+	}
+
+	num_nodes = member_list_entries;
+}
+
+static int lck_dispatch(struct local_client *client, char *buf, int len,
+			const char *csid, struct local_client **new_client)
+{
+	*new_client = NULL;
+	saLckDispatch(lck_handle, SA_DISPATCH_ONE);
+	return 1;
+}
+
+static int _init_cluster(void)
+{
+	SaAisErrorT err;
+	SaVersionT  ver = { 'B', 1, 1 };
+	int select_fd;
+
+	node_hash = dm_hash_create(100);
+	lock_hash = dm_hash_create(10);
+
+	err = cpg_initialize(&cpg_handle,
+			     &openais_cpg_callbacks);
+	if (err != SA_AIS_OK) {
+		syslog(LOG_ERR, "Cannot initialise OpenAIS CPG service: %d",
+		       err);
+		DEBUGLOG("Cannot initialise OpenAIS CPG service: %d", err);
+		return ais_to_errno(err);
+	}
+
+	err = saLckInitialize(&lck_handle,
+					NULL,
+			      &ver);
+	if (err != SA_AIS_OK) {
+		cpg_initialize(&cpg_handle, &openais_cpg_callbacks);
+		syslog(LOG_ERR, "Cannot initialise OpenAIS lock service: %d",
+		       err);
+		DEBUGLOG("Cannot initialise OpenAIS lock service: %d\n\n", err);
+		return ais_to_errno(err);
+	}
+
+	/* Connect to the clvmd group */
+	strcpy((char *)cpg_group_name.value, "clvmd");
+	cpg_group_name.length = strlen((char *)cpg_group_name.value);
+	err = cpg_join(cpg_handle, &cpg_group_name);
+	if (err != SA_AIS_OK) {
+		cpg_finalize(cpg_handle);
+		saLckFinalize(lck_handle);
+		syslog(LOG_ERR, "Cannot join clvmd process group");
+		DEBUGLOG("Cannot join clvmd process group: %d\n", err);
+		return ais_to_errno(err);
+	}
+
+	err = cpg_local_get(cpg_handle,
+			    &our_nodeid);
+	if (err != SA_AIS_OK) {
+		cpg_finalize(cpg_handle);
+		saLckFinalize(lck_handle);
+		syslog(LOG_ERR, "Cannot get local node id\n");
+		return ais_to_errno(err);
+	}
+	DEBUGLOG("Our local node id is %d\n", our_nodeid);
+
+	saLckSelectionObjectGet(lck_handle, (SaSelectionObjectT *)&select_fd);
+	add_internal_client(select_fd, lck_dispatch);
+
+	DEBUGLOG("Connected to OpenAIS\n");
+
+	return 0;
+}
+
+static void _cluster_closedown(void)
+{
+	saLckFinalize(lck_handle);
+	cpg_finalize(cpg_handle);
+}
+
+static void _get_our_csid(char *csid)
+{
+	memcpy(csid, &our_nodeid, sizeof(int));
+}
+
+/* OpenAIS doesn't really have nmode names so we
+   just use the node ID in hex instead */
+static int _csid_from_name(char *csid, const char *name)
+{
+	int nodeid;
+	struct node_info *ninfo;
+
+	if (sscanf(name, "%x", &nodeid) == 1) {
+		ninfo = dm_hash_lookup_binary(node_hash, csid, OPENAIS_CSID_LEN);
+		if (ninfo)
+			return nodeid;
+	}
+	return -1;
+}
+
+static int _name_from_csid(const char *csid, char *name)
+{
+	struct node_info *ninfo;
+
+	ninfo = dm_hash_lookup_binary(node_hash, csid, OPENAIS_CSID_LEN);
+	if (!ninfo)
+	{
+		sprintf(name, "UNKNOWN %s", print_openais_csid(csid));
+		return -1;
+	}
+
+	sprintf(name, "%x", ninfo->nodeid);
+	return 0;
+}
+
+static int _get_num_nodes()
+{
+	DEBUGLOG("num_nodes = %d\n", num_nodes);
+	return num_nodes;
+}
+
+/* Node is now known to be running a clvmd */
+static void _add_up_node(const char *csid)
+{
+	struct node_info *ninfo;
+
+	ninfo = dm_hash_lookup_binary(node_hash, csid, OPENAIS_CSID_LEN);
+	if (!ninfo) {
+		DEBUGLOG("openais_add_up_node no node_hash entry for csid %s\n",
+			 print_openais_csid(csid));
+		return;
+	}
+
+	DEBUGLOG("openais_add_up_node %d\n", ninfo->nodeid);
+
+	ninfo->state = NODE_CLVMD;
+}
+
+/* Call a callback for each node, so the caller knows whether it's up or down */
+static int _cluster_do_node_callback(struct local_client *master_client,
+				     void (*callback)(struct local_client *,
+						      const char *csid, int node_up))
+{
+	struct dm_hash_node *hn;
+	struct node_info *ninfo;
+	int somedown = 0;
+
+	dm_hash_iterate(hn, node_hash)
+	{
+		char csid[OPENAIS_CSID_LEN];
+
+		ninfo = dm_hash_get_data(node_hash, hn);
+		memcpy(csid, dm_hash_get_key(node_hash, hn), OPENAIS_CSID_LEN);
+
+		DEBUGLOG("down_callback. node %d, state = %d\n", ninfo->nodeid,
+			 ninfo->state);
+
+		if (ninfo->state != NODE_DOWN)
+			callback(master_client, csid, ninfo->state == NODE_CLVMD);
+		if (ninfo->state != NODE_CLVMD)
+			somedown = -1;
+	}
+	return somedown;
+}
+
+/* Real locking */
+static int _lock_resource(char *resource, int mode, int flags, int *lockid)
+{
+	struct lock_info *linfo;
+	SaLckResourceHandleT res_handle;
+	SaAisErrorT err;
+	SaLckLockIdT lock_id;
+	SaLckLockStatusT lockStatus;
+
+	/* This needs to be converted from DLM/LVM2 value for OpenAIS LCK */
+	if (flags & LCK_NONBLOCK) flags = SA_LCK_LOCK_NO_QUEUE;
+
+	linfo = malloc(sizeof(struct lock_info));
+	if (!linfo)
+		return -1;
+
+	DEBUGLOG("lock_resource '%s', flags=%d, mode=%d\n", resource, flags, mode);
+
+	linfo->lock_name.length = strlen(resource)+1;
+	strcpy((char *)linfo->lock_name.value, resource);
+
+	err = saLckResourceOpen(lck_handle, &linfo->lock_name,
+				SA_LCK_RESOURCE_CREATE, TIMEOUT, &res_handle);
+	if (err != SA_AIS_OK)
+	{
+		DEBUGLOG("ResourceOpen returned %d\n", err);
+		free(linfo);
+		return ais_to_errno(err);
+	}
+
+	err = saLckResourceLock(
+			res_handle,
+			&lock_id,
+			mode,
+			flags,
+			0,
+			SA_TIME_END,
+			&lockStatus);
+	if (err != SA_AIS_OK && lockStatus != SA_LCK_LOCK_GRANTED)
+	{
+		free(linfo);
+		saLckResourceClose(res_handle);
+		return ais_to_errno(err);
+	}
+
+	/* Wait for it to complete */
+
+	DEBUGLOG("lock_resource returning %d, lock_id=%" PRIx64 "\n",
+		 err, lock_id);
+
+	linfo->lock_id = lock_id;
+	linfo->res_handle = res_handle;
+
+	dm_hash_insert(lock_hash, resource, linfo);
+
+	return ais_to_errno(err);
+}
+
+
+static int _unlock_resource(char *resource, int lockid)
+{
+	SaAisErrorT err;
+	struct lock_info *linfo;
+
+	DEBUGLOG("unlock_resource %s\n", resource);
+	linfo = dm_hash_lookup(lock_hash, resource);
+	if (!linfo)
+		return 0;
+
+	DEBUGLOG("unlock_resource: lockid: %" PRIx64 "\n", linfo->lock_id);
+	err = saLckResourceUnlock(linfo->lock_id, SA_TIME_END);
+	if (err != SA_AIS_OK)
+	{
+		DEBUGLOG("Unlock returned %d\n", err);
+		return ais_to_errno(err);
+	}
+
+	/* Release the resource */
+	dm_hash_remove(lock_hash, resource);
+	saLckResourceClose(linfo->res_handle);
+	free(linfo);
+
+	return ais_to_errno(err);
+}
+
+static int _sync_lock(const char *resource, int mode, int flags, int *lockid)
+{
+	int status;
+	char lock1[strlen(resource)+3];
+	char lock2[strlen(resource)+3];
+
+	snprintf(lock1, sizeof(lock1), "%s-1", resource);
+	snprintf(lock2, sizeof(lock2), "%s-2", resource);
+
+	switch (mode)
+	{
+	case LCK_EXCL:
+		status = _lock_resource(lock1, SA_LCK_EX_LOCK_MODE, flags, lockid);
+		if (status)
+			goto out;
+
+		/* If we can't get this lock too then bail out */
+		status = _lock_resource(lock2, SA_LCK_EX_LOCK_MODE, LCK_NONBLOCK,
+					lockid);
+		if (status == SA_LCK_LOCK_NOT_QUEUED)
+		{
+			_unlock_resource(lock1, *lockid);
+			status = -1;
+			errno = EAGAIN;
+		}
+		break;
+
+	case LCK_PREAD:
+	case LCK_READ:
+		status = _lock_resource(lock1, SA_LCK_PR_LOCK_MODE, flags, lockid);
+		if (status)
+			goto out;
+		_unlock_resource(lock2, *lockid);
+		break;
+
+	case LCK_WRITE:
+		status = _lock_resource(lock2, SA_LCK_EX_LOCK_MODE, flags, lockid);
+		if (status)
+			goto out;
+		_unlock_resource(lock1, *lockid);
+		break;
+
+	default:
+		status = -1;
+		errno = EINVAL;
+		break;
+	}
+out:
+	*lockid = mode;
+	return status;
+}
+
+static int _sync_unlock(const char *resource, int lockid)
+{
+	int status = 0;
+	char lock1[strlen(resource)+3];
+	char lock2[strlen(resource)+3];
+
+	snprintf(lock1, sizeof(lock1), "%s-1", resource);
+	snprintf(lock2, sizeof(lock2), "%s-2", resource);
+
+	_unlock_resource(lock1, lockid);
+	_unlock_resource(lock2, lockid);
+
+	return status;
+}
+
+/* We are always quorate ! */
+static int _is_quorate()
+{
+	return 1;
+}
+
+static int _get_main_cluster_fd(void)
+{
+	int select_fd;
+
+	cpg_fd_get(cpg_handle, &select_fd);
+	return select_fd;
+}
+
+static int _cluster_fd_callback(struct local_client *fd, char *buf, int len,
+				const char *csid,
+				struct local_client **new_client)
+{
+	cluster_client = fd;
+	*new_client = NULL;
+	cpg_dispatch(cpg_handle, SA_DISPATCH_ONE);
+	return 1;
+}
+
+static int _cluster_send_message(const void *buf, int msglen, const char *csid,
+				 const char *errtext)
+{
+	struct iovec iov[2];
+	SaAisErrorT err;
+	int target_node;
+
+	if (csid)
+		memcpy(&target_node, csid, OPENAIS_CSID_LEN);
+	else
+		target_node = 0;
+
+	iov[0].iov_base = &target_node;
+	iov[0].iov_len = sizeof(int);
+	iov[1].iov_base = (char *)buf;
+	iov[1].iov_len = msglen;
+
+	err = cpg_mcast_joined(cpg_handle, CPG_TYPE_AGREED, iov, 2);
+	return ais_to_errno(err);
+}
+
+/* We don't have a cluster name to report here */
+static int _get_cluster_name(char *buf, int buflen)
+{
+	strncpy(buf, "OpenAIS", buflen);
+	return 0;
+}
+
+static struct cluster_ops _cluster_openais_ops = {
+	.name                     = "openais",
+	.cluster_init_completed   = NULL,
+	.cluster_send_message     = _cluster_send_message,
+	.name_from_csid           = _name_from_csid,
+	.csid_from_name           = _csid_from_name,
+	.get_num_nodes            = _get_num_nodes,
+	.cluster_fd_callback      = _cluster_fd_callback,
+	.get_main_cluster_fd      = _get_main_cluster_fd,
+	.cluster_do_node_callback = _cluster_do_node_callback,
+	.is_quorate               = _is_quorate,
+	.get_our_csid             = _get_our_csid,
+	.add_up_node              = _add_up_node,
+	.reread_config            = NULL,
+	.cluster_closedown        = _cluster_closedown,
+	.get_cluster_name         = _get_cluster_name,
+	.sync_lock                = _sync_lock,
+	.sync_unlock              = _sync_unlock,
+};
+
+struct cluster_ops *init_openais_cluster(void)
+{
+	if (!_init_cluster())
+		return &_cluster_openais_ops;
+
+	return NULL;
+}

daemons/clvmd/clvmd-singlenode.c

@@ -0,0 +1,382 @@
+/*
+ * Copyright (C) 2009-2013 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 "clvmd-common.h"
+
+#include <pthread.h>
+
+#include "locking.h"
+#include "clvm.h"
+#include "clvmd-comms.h"
+#include "clvmd.h"
+
+#include <sys/un.h>
+#include <sys/socket.h>
+#include <fcntl.h>
+
+static const char SINGLENODE_CLVMD_SOCKNAME[] = DEFAULT_RUN_DIR "/clvmd_singlenode.sock";
+static int listen_fd = -1;
+
+static struct dm_hash_table *_locks;
+static int _lockid;
+
+static pthread_mutex_t _lock_mutex = PTHREAD_MUTEX_INITIALIZER;
+/* Using one common condition for all locks for simplicity */
+static pthread_cond_t _lock_cond = PTHREAD_COND_INITIALIZER;
+
+struct lock {
+	struct dm_list list;
+	int lockid;
+	int mode;
+};
+
+static void close_comms(void)
+{
+	if (listen_fd != -1 && close(listen_fd))
+		stack;
+	(void)unlink(SINGLENODE_CLVMD_SOCKNAME);
+	listen_fd = -1;
+}
+
+static int init_comms(void)
+{
+	mode_t old_mask;
+	struct sockaddr_un addr = { .sun_family = AF_UNIX };
+
+	if (!dm_strncpy(addr.sun_path, SINGLENODE_CLVMD_SOCKNAME,
+			sizeof(addr.sun_path))) {
+		DEBUGLOG("%s: singlenode socket name too long.",
+			 SINGLENODE_CLVMD_SOCKNAME);
+		return -1;
+	}
+
+	close_comms();
+
+	(void) dm_prepare_selinux_context(SINGLENODE_CLVMD_SOCKNAME, S_IFSOCK);
+	old_mask = umask(0077);
+
+	listen_fd = socket(PF_UNIX, SOCK_STREAM, 0);
+	if (listen_fd < 0) {
+		DEBUGLOG("Can't create local socket: %s\n", strerror(errno));
+		goto error;
+	}
+	/* Set Close-on-exec */
+	if (fcntl(listen_fd, F_SETFD, 1)) {
+		DEBUGLOG("Setting CLOEXEC on client fd failed: %s\n", strerror(errno));
+		goto error;
+	}
+
+	if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+		DEBUGLOG("Can't bind local socket: %s\n", strerror(errno));
+		goto error;
+	}
+	if (listen(listen_fd, 10) < 0) {
+		DEBUGLOG("Can't listen local socket: %s\n", strerror(errno));
+		goto error;
+	}
+
+	umask(old_mask);
+	(void) dm_prepare_selinux_context(NULL, 0);
+	return 0;
+error:
+	umask(old_mask);
+	(void) dm_prepare_selinux_context(NULL, 0);
+	close_comms();
+	return -1;
+}
+
+static int _init_cluster(void)
+{
+	int r;
+
+	if (!(_locks = dm_hash_create(128))) {
+		DEBUGLOG("Failed to allocate single-node hash table.\n");
+		return 1;
+	}
+
+	r = init_comms();
+	if (r) {
+		dm_hash_destroy(_locks);
+		_locks = NULL;
+		return r;
+	}
+
+	DEBUGLOG("Single-node cluster initialised.\n");
+	return 0;
+}
+
+static void _cluster_closedown(void)
+{
+	close_comms();
+
+	/* If there is any awaited resource, kill it softly */
+	pthread_mutex_lock(&_lock_mutex);
+	dm_hash_destroy(_locks);
+	_locks = NULL;
+	_lockid = 0;
+	pthread_cond_broadcast(&_lock_cond); /* wakeup waiters */
+	pthread_mutex_unlock(&_lock_mutex);
+}
+
+static void _get_our_csid(char *csid)
+{
+	int nodeid = 1;
+	memcpy(csid, &nodeid, sizeof(int));
+}
+
+static int _csid_from_name(char *csid, const char *name)
+{
+	return 1;
+}
+
+static int _name_from_csid(const char *csid, char *name)
+{
+	strcpy(name, "SINGLENODE");
+	return 0;
+}
+
+static int _get_num_nodes(void)
+{
+	return 1;
+}
+
+/* Node is now known to be running a clvmd */
+static void _add_up_node(const char *csid)
+{
+}
+
+/* Call a callback for each node, so the caller knows whether it's up or down */
+static int _cluster_do_node_callback(struct local_client *master_client,
+				     void (*callback)(struct local_client *,
+				     const char *csid, int node_up))
+{
+	return 0;
+}
+
+int _lock_file(const char *file, uint32_t flags);
+
+static const char *_get_mode(int mode)
+{
+	switch (mode) {
+	case LCK_NULL: return "NULL";
+	case LCK_READ: return "READ";
+	case LCK_PREAD: return "PREAD";
+	case LCK_WRITE: return "WRITE";
+	case LCK_EXCL: return "EXCLUSIVE";
+	case LCK_UNLOCK: return "UNLOCK";
+	default: return "????";
+	}
+}
+
+/* Real locking */
+static int _lock_resource(const char *resource, int mode, int flags, int *lockid)
+{
+	/* DLM table of allowed transition states */
+	static const int _dlm_table[6][6] = {
+	/* Mode	   NL	CR	CW	PR	PW	EX */
+	/* NL */ { 1,	 1,	 1,	 1,	 1,	 1},
+	/* CR */ { 1,	 1,	 1,	 1,	 1,	 0},
+	/* CW */ { 1,	 1,	 1,	 0,	 0,	 0},
+	/* PR */ { 1,	 1,	 0,	 1,	 0,	 0},
+	/* PW */ { 1,	 1,	 0,	 0,	 0,	 0},
+	/* EX */ { 1,	 0,	 0,	 0,	 0,	 0}
+	};
+
+	struct lock *lck = NULL, *lckt;
+	struct dm_list *head;
+
+	DEBUGLOG("Locking resource %s, flags=0x%02x (%s%s%s), mode=%s (%d)\n",
+		 resource, flags,
+		 (flags & LCKF_NOQUEUE) ? "NOQUEUE" : "",
+		 ((flags & (LCKF_NOQUEUE | LCKF_CONVERT)) ==
+		  (LCKF_NOQUEUE | LCKF_CONVERT)) ? "|" : "",
+		 (flags & LCKF_CONVERT) ? "CONVERT" : "",
+		 _get_mode(mode), mode);
+
+	mode &= LCK_TYPE_MASK;
+	pthread_mutex_lock(&_lock_mutex);
+
+retry:
+	if (!(head = dm_hash_lookup(_locks, resource))) {
+		if (flags & LCKF_CONVERT) {
+			/* In real DLM, lock is identified only by lockid, resource is not used */
+			DEBUGLOG("Unlocked resource %s cannot be converted\n", resource);
+			goto_bad;
+		}
+		/* Add new locked resource */
+		if (!(head = dm_malloc(sizeof(struct dm_list))) ||
+		    !dm_hash_insert(_locks, resource, head)) {
+			dm_free(head);
+			goto_bad;
+		}
+
+		dm_list_init(head);
+	} else	/* Update/convert locked resource */
+		dm_list_iterate_items(lck, head) {
+			/* Check is all locks are compatible with requested lock */
+			if (flags & LCKF_CONVERT) {
+				if (lck->lockid != *lockid)
+					continue;
+
+				DEBUGLOG("Converting resource %s lockid=%d mode:%s -> %s...\n",
+					 resource, lck->lockid, _get_mode(lck->mode), _get_mode(mode));
+				dm_list_iterate_items(lckt, head) {
+					if ((lckt->lockid != *lockid) &&
+					    !_dlm_table[mode][lckt->mode]) {
+						if (!(flags & LCKF_NOQUEUE) &&
+						    /* TODO: Real dlm uses here conversion queues */
+						    !pthread_cond_wait(&_lock_cond, &_lock_mutex) &&
+						    _locks) /* End of the game? */
+							goto retry;
+						goto bad;
+					}
+				}
+				lck->mode = mode; /* Lock is now converted */
+				goto out;
+			} else if (!_dlm_table[mode][lck->mode]) {
+				DEBUGLOG("Resource %s already locked lockid=%d, mode:%s\n",
+					 resource, lck->lockid, _get_mode(lck->mode));
+				if (!(flags & LCKF_NOQUEUE) &&
+				    !pthread_cond_wait(&_lock_cond, &_lock_mutex) &&
+				    _locks) { /* End of the game? */
+					DEBUGLOG("Resource %s retrying lock in mode:%s...\n",
+						 resource, _get_mode(mode));
+					goto retry;
+				}
+				goto bad;
+			}
+		}
+
+	if (!(flags & LCKF_CONVERT)) {
+		if (!(lck = dm_malloc(sizeof(struct lock))))
+			goto_bad;
+
+		*lockid = lck->lockid = ++_lockid;
+		lck->mode = mode;
+		dm_list_add(head, &lck->list);
+	}
+out:
+	pthread_cond_broadcast(&_lock_cond); /* to wakeup waiters */
+	pthread_mutex_unlock(&_lock_mutex);
+	DEBUGLOG("Locked resource %s, lockid=%d, mode=%s\n",
+		 resource, lck->lockid, _get_mode(lck->mode));
+
+	return 0;
+bad:
+	pthread_cond_broadcast(&_lock_cond); /* to wakeup waiters */
+	pthread_mutex_unlock(&_lock_mutex);
+	DEBUGLOG("Failed to lock resource %s\n", resource);
+
+	return 1; /* fail */
+}
+
+static int _unlock_resource(const char *resource, int lockid)
+{
+	struct lock *lck;
+	struct dm_list *head;
+	int r = 1;
+
+	if (lockid < 0) {
+		DEBUGLOG("Not tracking unlock of lockid -1: %s, lockid=%d\n",
+			 resource, lockid);
+		return 1;
+	}
+
+	DEBUGLOG("Unlocking resource %s, lockid=%d\n", resource, lockid);
+	pthread_mutex_lock(&_lock_mutex);
+	pthread_cond_broadcast(&_lock_cond); /* wakeup waiters */
+
+	if (!(head = dm_hash_lookup(_locks, resource))) {
+		pthread_mutex_unlock(&_lock_mutex);
+		DEBUGLOG("Resource %s is not locked.\n", resource);
+		return 1;
+	}
+
+	dm_list_iterate_items(lck, head)
+		if (lck->lockid == lockid) {
+			dm_list_del(&lck->list);
+			dm_free(lck);
+			r = 0;
+			goto out;
+		}
+
+	DEBUGLOG("Resource %s has wrong lockid %d.\n", resource, lockid);
+out:
+	if (dm_list_empty(head)) {
+		//DEBUGLOG("Resource %s is no longer hashed (lockid=%d).\n", resource, lockid);
+		dm_hash_remove(_locks, resource);
+		dm_free(head);
+	}
+
+	pthread_mutex_unlock(&_lock_mutex);
+
+	return r;
+}
+
+static int _is_quorate(void)
+{
+	return 1;
+}
+
+static int _get_main_cluster_fd(void)
+{
+	return listen_fd;
+}
+
+static int _cluster_fd_callback(struct local_client *fd, char *buf, int len,
+				const char *csid,
+				struct local_client **new_client)
+{
+	return 1;
+}
+
+static int _cluster_send_message(const void *buf, int msglen,
+				 const char *csid,
+				 const char *errtext)
+{
+	return 0;
+}
+
+static int _get_cluster_name(char *buf, int buflen)
+{
+	return dm_strncpy(buf, "localcluster", buflen) ? 0 : 1;
+}
+
+static struct cluster_ops _cluster_singlenode_ops = {
+	.name                     = "singlenode",
+	.cluster_init_completed   = NULL,
+	.cluster_send_message     = _cluster_send_message,
+	.name_from_csid           = _name_from_csid,
+	.csid_from_name           = _csid_from_name,
+	.get_num_nodes            = _get_num_nodes,
+	.cluster_fd_callback      = _cluster_fd_callback,
+	.get_main_cluster_fd      = _get_main_cluster_fd,
+	.cluster_do_node_callback = _cluster_do_node_callback,
+	.is_quorate               = _is_quorate,
+	.get_our_csid             = _get_our_csid,
+	.add_up_node              = _add_up_node,
+	.reread_config            = NULL,
+	.cluster_closedown        = _cluster_closedown,
+	.get_cluster_name         = _get_cluster_name,
+	.sync_lock                = _lock_resource,
+	.sync_unlock              = _unlock_resource,
+};
+
+struct cluster_ops *init_singlenode_cluster(void)
+{
+	if (!_init_cluster())
+		return &_cluster_singlenode_ops;
+
+	return NULL;
+}

daemons/clvmd/clvmd.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _CLVMD_H
+#define _CLVMD_H
+
+#define CLVMD_MAJOR_VERSION 0
+#define CLVMD_MINOR_VERSION 2
+#define CLVMD_PATCH_VERSION 1
+
+/* Default time (in seconds) we will wait for all remote commands to execute
+   before declaring them dead */
+#define DEFAULT_CMD_TIMEOUT 60
+
+/* One of these for each reply we get from command execution on a node */
+struct node_reply {
+	char node[MAX_CLUSTER_MEMBER_NAME_LEN];
+	char *replymsg;
+	int status;
+	struct node_reply *next;
+};
+
+typedef enum {DEBUG_OFF, DEBUG_STDERR, DEBUG_SYSLOG} debug_t;
+
+/*
+ * These exist for the use of local sockets only when we are
+ * collecting responses from all cluster nodes
+ */
+struct localsock_bits {
+	struct node_reply *replies;
+	int num_replies;
+	int expected_replies;
+	time_t sent_time;	/* So we can check for timeouts */
+	int in_progress;	/* Only execute one cmd at a time per client */
+	int sent_out;		/* Flag to indicate that a command was sent
+				   to remote nodes */
+	void *private;		/* Private area for command processor use */
+	void *cmd;		/* Whole command as passed down local socket */
+	int cmd_len;		/* Length of above */
+	int pipe;		/* Pipe to send PRE completion status down */
+	int finished;		/* Flag to tell subthread to exit */
+	int all_success;	/* Set to 0 if any node (or the pre_command)
+				   failed */
+	int cleanup_needed;     /* helper for cleanup_zombie */
+	struct local_client *pipe_client;
+	pthread_t threadid;
+	enum { PRE_COMMAND, POST_COMMAND } state;
+	pthread_mutex_t mutex;	/* Main thread and worker synchronisation */
+	pthread_cond_t cond;
+};
+
+/* Entries for PIPE clients */
+struct pipe_bits {
+	struct local_client *client;	/* Actual (localsock) client */
+	pthread_t threadid;		/* Our own copy of the thread id */
+};
+
+/* Entries for Network socket clients */
+struct netsock_bits {
+	void *private;
+	int flags;
+};
+
+typedef int (*fd_callback_t) (struct local_client * fd, char *buf, int len,
+			      const char *csid,
+			      struct local_client ** new_client);
+
+/* One of these for each fd we are listening on */
+struct local_client {
+	int fd;
+	enum { CLUSTER_MAIN_SOCK, CLUSTER_DATA_SOCK, LOCAL_RENDEZVOUS,
+		    LOCAL_SOCK, THREAD_PIPE, CLUSTER_INTERNAL } type;
+	struct local_client *next;
+	unsigned short xid;
+	fd_callback_t callback;
+	uint8_t removeme;
+
+	union {
+		struct localsock_bits localsock;
+		struct pipe_bits pipe;
+		struct netsock_bits net;
+	} bits;
+};
+
+#define DEBUGLOG(fmt, args...) debuglog(fmt, ## args)
+
+#ifndef max
+#define max(a,b) ((a)>(b)?(a):(b))
+#endif
+
+/* The real command processor is in clvmd-command.c */
+extern int do_command(struct local_client *client, struct clvm_header *msg,
+		      int msglen, char **buf, int buflen, int *retlen);
+
+/* Pre and post command routines are called only on the local node */
+extern int do_pre_command(struct local_client *client);
+extern int do_post_command(struct local_client *client);
+extern void cmd_client_cleanup(struct local_client *client);
+extern int add_client(struct local_client *new_client);
+
+extern void clvmd_cluster_init_completed(void);
+extern void process_message(struct local_client *client, char *buf,
+			    int len, const char *csid);
+extern void debuglog(const char *fmt, ... )
+  __attribute__ ((format(printf, 1, 2)));
+
+void clvmd_set_debug(debug_t new_de);
+debug_t clvmd_get_debug(void);
+int clvmd_get_foreground(void);
+
+int sync_lock(const char *resource, int mode, int flags, int *lockid);
+int sync_unlock(const char *resource, int lockid);
+
+#endif

daemons/clvmd/lvm-functions.c

@@ -0,0 +1,927 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2012 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "clvmd-common.h"
+
+#include <pthread.h>
+
+#include "clvm.h"
+#include "clvmd-comms.h"
+#include "clvmd.h"
+#include "lvm-functions.h"
+
+/* LVM2 headers */
+#include "toolcontext.h"
+#include "lvmcache.h"
+#include "lvm-globals.h"
+#include "activate.h"
+#include "archiver.h"
+#include "memlock.h"
+
+#include <syslog.h>
+
+static struct cmd_context *cmd = NULL;
+static struct dm_hash_table *lv_hash = NULL;
+static pthread_mutex_t lv_hash_lock;
+static pthread_mutex_t lvm_lock;
+static char last_error[1024];
+
+struct lv_info {
+	int lock_id;
+	int lock_mode;
+};
+
+static const char *decode_full_locking_cmd(uint32_t cmdl)
+{
+	static char buf[128];
+	const char *type;
+	const char *scope;
+	const char *command;
+
+	switch (cmdl & LCK_TYPE_MASK) {
+	case LCK_NULL:
+		type = "NULL";
+		break;
+	case LCK_READ:
+		type = "READ";
+		break;
+	case LCK_PREAD:
+		type = "PREAD";
+		break;
+	case LCK_WRITE:
+		type = "WRITE";
+		break;
+	case LCK_EXCL:
+		type = "EXCL";
+		break;
+	case LCK_UNLOCK:
+		type = "UNLOCK";
+		break;
+	default:
+		type = "unknown";
+		break;
+	}
+
+	switch (cmdl & LCK_SCOPE_MASK) {
+	case LCK_VG:
+		scope = "VG";
+		command = "LCK_VG";
+		break;
+	case LCK_LV:
+		scope = "LV";
+		switch (cmdl & LCK_MASK) {
+		case LCK_LV_EXCLUSIVE & LCK_MASK:
+			command = "LCK_LV_EXCLUSIVE";
+			break;
+		case LCK_LV_SUSPEND & LCK_MASK:
+			command = "LCK_LV_SUSPEND";
+			break;
+		case LCK_LV_RESUME & LCK_MASK:
+			command = "LCK_LV_RESUME";
+			break;
+		case LCK_LV_ACTIVATE & LCK_MASK:
+			command = "LCK_LV_ACTIVATE";
+			break;
+		case LCK_LV_DEACTIVATE & LCK_MASK:
+			command = "LCK_LV_DEACTIVATE";
+			break;
+		default:
+			command = "unknown";
+			break;
+		}
+		break;
+	default:
+		scope = "unknown";
+		command = "unknown";
+		break;
+	}
+
+	sprintf(buf, "0x%x %s (%s|%s%s%s%s%s)", cmdl, command, type, scope,
+		cmdl & LCK_NONBLOCK   ? "|NONBLOCK" : "",
+		cmdl & LCK_HOLD       ? "|HOLD" : "",
+		cmdl & LCK_CLUSTER_VG ? "|CLUSTER_VG" : "",
+		cmdl & LCK_CACHE      ? "|CACHE" : "");
+
+	return buf;
+}
+
+/*
+ * Only processes 8 bits: excludes LCK_CACHE.
+ */
+static const char *decode_locking_cmd(unsigned char cmdl)
+{
+	return decode_full_locking_cmd((uint32_t) cmdl);
+}
+
+static const char *decode_flags(unsigned char flags)
+{
+	static char buf[128];
+	int len;
+
+	len = sprintf(buf, "0x%x ( %s%s%s%s%s%s%s%s)", flags,
+		flags & LCK_PARTIAL_MODE	  ? "PARTIAL_MODE|" : "",
+		flags & LCK_MIRROR_NOSYNC_MODE	  ? "MIRROR_NOSYNC|" : "",
+		flags & LCK_DMEVENTD_MONITOR_MODE ? "DMEVENTD_MONITOR|" : "",
+		flags & LCK_ORIGIN_ONLY_MODE ? "ORIGIN_ONLY|" : "",
+		flags & LCK_TEST_MODE ? "TEST|" : "",
+		flags & LCK_CONVERT_MODE ? "CONVERT|" : "",
+		flags & LCK_DMEVENTD_MONITOR_IGNORE ? "DMEVENTD_MONITOR_IGNORE|" : "",
+		flags & LCK_REVERT_MODE ? "REVERT|" : "");
+
+	if (len > 1)
+		buf[len - 2] = ' ';
+	else
+		buf[0] = '\0';
+
+	return buf;
+}
+
+char *get_last_lvm_error(void)
+{
+	return last_error;
+}
+
+/*
+ * Hash lock info helpers
+ */
+static struct lv_info *lookup_info(const char *resource)
+{
+	struct lv_info *lvi;
+
+	pthread_mutex_lock(&lv_hash_lock);
+	lvi = dm_hash_lookup(lv_hash, resource);
+	pthread_mutex_unlock(&lv_hash_lock);
+
+	return lvi;
+}
+
+static int insert_info(const char *resource, struct lv_info *lvi)
+{
+	int ret;
+
+	pthread_mutex_lock(&lv_hash_lock);
+	ret = dm_hash_insert(lv_hash, resource, lvi);
+	pthread_mutex_unlock(&lv_hash_lock);
+
+	return ret;
+}
+
+static void remove_info(const char *resource)
+{
+	int num_open;
+
+	pthread_mutex_lock(&lv_hash_lock);
+	dm_hash_remove(lv_hash, resource);
+
+	/* When last lock is remove, validate there are not left opened devices */
+	if (!dm_hash_get_first(lv_hash)) {
+		if (critical_section())
+			log_error(INTERNAL_ERROR "No volumes are locked however clvmd is in activation mode critical section.");
+		if ((num_open = dev_cache_check_for_open_devices()))
+			log_error(INTERNAL_ERROR "No volumes are locked however %d devices are still open.", num_open);
+	}
+
+	pthread_mutex_unlock(&lv_hash_lock);
+}
+
+/*
+ * Return the mode a lock is currently held at (or -1 if not held)
+ */
+static int get_current_lock(char *resource)
+{
+	struct lv_info *lvi;
+
+	if ((lvi = lookup_info(resource)))
+		return lvi->lock_mode;
+
+	return -1;
+}
+
+
+void init_lvhash(void)
+{
+	/* Create hash table for keeping LV locks & status */
+	lv_hash = dm_hash_create(1024);
+	pthread_mutex_init(&lv_hash_lock, NULL);
+	pthread_mutex_init(&lvm_lock, NULL);
+}
+
+/* Called at shutdown to tidy the lockspace */
+void destroy_lvhash(void)
+{
+	struct dm_hash_node *v;
+	struct lv_info *lvi;
+	char *resource;
+	int status;
+
+	pthread_mutex_lock(&lv_hash_lock);
+
+	dm_hash_iterate(v, lv_hash) {
+		lvi = dm_hash_get_data(lv_hash, v);
+		resource = dm_hash_get_key(lv_hash, v);
+
+		if ((status = sync_unlock(resource, lvi->lock_id)))
+			DEBUGLOG("unlock_all. unlock failed(%d): %s\n",
+				 status,  strerror(errno));
+		dm_free(lvi);
+	}
+
+	dm_hash_destroy(lv_hash);
+	lv_hash = NULL;
+
+	pthread_mutex_unlock(&lv_hash_lock);
+}
+
+/* Gets a real lock and keeps the info in the hash table */
+static int hold_lock(char *resource, int mode, int flags)
+{
+	int status;
+	int saved_errno;
+	struct lv_info *lvi;
+
+	/* Mask off invalid options */
+	flags &= LCKF_NOQUEUE | LCKF_CONVERT;
+
+	lvi = lookup_info(resource);
+
+	if (lvi) {
+		if (lvi->lock_mode == mode) {
+			DEBUGLOG("hold_lock, lock mode %d already held\n",
+				 mode);
+			return 0;
+		}
+		if ((lvi->lock_mode == LCK_EXCL) && (mode == LCK_WRITE)) {
+			DEBUGLOG("hold_lock, lock already held LCK_EXCL, "
+				 "ignoring LCK_WRITE request\n");
+			return 0;
+		}
+	}
+
+	/* Only allow explicit conversions */
+	if (lvi && !(flags & LCKF_CONVERT)) {
+		errno = EBUSY;
+		return -1;
+	}
+	if (lvi) {
+		/* Already exists - convert it */
+		status = sync_lock(resource, mode, flags, &lvi->lock_id);
+		saved_errno = errno;
+		if (!status)
+			lvi->lock_mode = mode;
+		else
+			DEBUGLOG("hold_lock. convert to %d failed: %s\n", mode,
+				 strerror(errno));
+		errno = saved_errno;
+	} else {
+		if (!(lvi = dm_malloc(sizeof(struct lv_info)))) {
+			errno = ENOMEM;
+			return -1;
+		}
+
+		lvi->lock_mode = mode;
+		lvi->lock_id = 0;
+		status = sync_lock(resource, mode, flags & ~LCKF_CONVERT, &lvi->lock_id);
+		saved_errno = errno;
+		if (status) {
+			dm_free(lvi);
+			DEBUGLOG("hold_lock. lock at %d failed: %s\n", mode,
+				 strerror(errno));
+		} else
+			if (!insert_info(resource, lvi)) {
+				errno = ENOMEM;
+				return -1;
+			}
+
+		errno = saved_errno;
+	}
+	return status;
+}
+
+/* Unlock and remove it from the hash table */
+static int hold_unlock(char *resource)
+{
+	struct lv_info *lvi;
+	int status;
+	int saved_errno;
+
+	if (!(lvi = lookup_info(resource))) {
+		DEBUGLOG("hold_unlock, lock not already held\n");
+		return 0;
+	}
+
+	status = sync_unlock(resource, lvi->lock_id);
+	saved_errno = errno;
+	if (!status) {
+		remove_info(resource);
+		dm_free(lvi);
+	} else {
+		DEBUGLOG("hold_unlock. unlock failed(%d): %s\n", status,
+			 strerror(errno));
+	}
+
+	errno = saved_errno;
+	return status;
+}
+
+/* Watch the return codes here.
+   liblvm API functions return 1(true) for success, 0(false) for failure and don't set errno.
+   libdlm API functions return 0 for success, -1 for failure and do set errno.
+   These functions here return 0 for success or >0 for failure (where the retcode is errno)
+*/
+
+/* Activate LV exclusive or non-exclusive */
+static int do_activate_lv(char *resource, unsigned char command, unsigned char lock_flags, int mode)
+{
+	int oldmode;
+	int status;
+	int activate_lv;
+	int exclusive = 0;
+	struct lvinfo lvi;
+
+	/* Is it already open ? */
+	oldmode = get_current_lock(resource);
+	if (oldmode == mode && (command & LCK_CLUSTER_VG)) {
+		DEBUGLOG("do_activate_lv, lock already held at %d\n", oldmode);
+		return 0;	/* Nothing to do */
+	}
+
+	/* Does the config file want us to activate this LV ? */
+	if (!lv_activation_filter(cmd, resource, &activate_lv, NULL))
+		return EIO;
+
+	if (!activate_lv)
+		return 0;	/* Success, we did nothing! */
+
+	/* Do we need to activate exclusively? */
+	if ((activate_lv == 2) || (mode == LCK_EXCL)) {
+		exclusive = 1;
+		mode = LCK_EXCL;
+	}
+
+	/*
+	 * Try to get the lock if it's a clustered volume group.
+	 * Use lock conversion only if requested, to prevent implicit conversion
+	 * of exclusive lock to shared one during activation.
+	 */
+	if (!test_mode() && command & LCK_CLUSTER_VG) {
+		status = hold_lock(resource, mode, LCKF_NOQUEUE | ((lock_flags & LCK_CONVERT_MODE) ? LCKF_CONVERT:0));
+		if (status) {
+			/* Return an LVM-sensible error for this.
+			 * Forcing EIO makes the upper level return this text
+			 * rather than the strerror text for EAGAIN.
+			 */
+			if (errno == EAGAIN) {
+				sprintf(last_error, "Volume is busy on another node");
+				errno = EIO;
+			}
+			return errno;
+		}
+	}
+
+	/* If it's suspended then resume it */
+	if (!lv_info_by_lvid(cmd, resource, 0, &lvi, 0, 0))
+		goto error;
+
+	if (lvi.suspended) {
+		critical_section_inc(cmd, "resuming");
+		if (!lv_resume(cmd, resource, 0, NULL)) {
+			critical_section_dec(cmd, "resumed");
+			goto error;
+		}
+	}
+
+	/* Now activate it */
+	if (!lv_activate(cmd, resource, exclusive, 0, 0, NULL))
+		goto error;
+
+	return 0;
+
+error:
+	if (!test_mode() && (oldmode == -1 || oldmode != mode))
+		(void)hold_unlock(resource);
+	return EIO;
+}
+
+/* Resume the LV if it was active */
+static int do_resume_lv(char *resource, unsigned char command, unsigned char lock_flags)
+{
+	int oldmode, origin_only, exclusive, revert;
+
+	/* Is it open ? */
+	oldmode = get_current_lock(resource);
+	if (oldmode == -1 && (command & LCK_CLUSTER_VG)) {
+		DEBUGLOG("do_resume_lv, lock not already held\n");
+		return 0;	/* We don't need to do anything */
+	}
+	origin_only = (lock_flags & LCK_ORIGIN_ONLY_MODE) ? 1 : 0;
+	exclusive = (oldmode == LCK_EXCL) ? 1 : 0;
+	revert = (lock_flags & LCK_REVERT_MODE) ? 1 : 0;
+
+	if (!lv_resume_if_active(cmd, resource, origin_only, exclusive, revert, NULL))
+		return EIO;
+
+	return 0;
+}
+
+/* Suspend the device if active */
+static int do_suspend_lv(char *resource, unsigned char command, unsigned char lock_flags)
+{
+	int oldmode;
+	unsigned origin_only = (lock_flags & LCK_ORIGIN_ONLY_MODE) ? 1 : 0;
+	unsigned exclusive;
+
+	/* Is it open ? */
+	oldmode = get_current_lock(resource);
+	if (oldmode == -1 && (command & LCK_CLUSTER_VG)) {
+		DEBUGLOG("do_suspend_lv, lock not already held\n");
+		return 0; /* Not active, so it's OK */
+	}
+
+	exclusive = (oldmode == LCK_EXCL) ? 1 : 0;
+
+	/* Always call lv_suspend to read commited and precommited data */
+	if (!lv_suspend_if_active(cmd, resource, origin_only, exclusive, NULL, NULL))
+		return EIO;
+
+	return 0;
+}
+
+static int do_deactivate_lv(char *resource, unsigned char command, unsigned char lock_flags)
+{
+	int oldmode;
+	int status;
+
+	/* Is it open ? */
+	oldmode = get_current_lock(resource);
+	if (oldmode == -1 && (command & LCK_CLUSTER_VG)) {
+		DEBUGLOG("do_deactivate_lock, lock not already held\n");
+		return 0;	/* We don't need to do anything */
+	}
+
+	if (!lv_deactivate(cmd, resource, NULL))
+		return EIO;
+
+	if (!test_mode() && command & LCK_CLUSTER_VG) {
+		status = hold_unlock(resource);
+		if (status)
+			return errno;
+	}
+
+	return 0;
+}
+
+const char *do_lock_query(char *resource)
+{
+	int mode;
+	const char *type;
+
+	mode = get_current_lock(resource);
+	switch (mode) {
+	case LCK_NULL: type = "NL"; break;
+	case LCK_READ: type = "CR"; break;
+	case LCK_PREAD:type = "PR"; break;
+	case LCK_WRITE:type = "PW"; break;
+	case LCK_EXCL: type = "EX"; break;
+	default: type = NULL;
+	}
+
+	DEBUGLOG("do_lock_query: resource '%s', mode %i (%s)\n", resource, mode, type ?: "--");
+
+	return type;
+}
+
+/* This is the LOCK_LV part that happens on all nodes in the cluster -
+   it is responsible for the interaction with device-mapper and LVM */
+int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
+{
+	int status = 0;
+
+	DEBUGLOG("do_lock_lv: resource '%s', cmd = %s, flags = %s, critical_section = %d\n",
+		 resource, decode_locking_cmd(command), decode_flags(lock_flags), critical_section());
+
+	if (!cmd->initialized.config || config_files_changed(cmd)) {
+		/* Reinitialise various settings inc. logging, filters */
+		if (do_refresh_cache()) {
+			log_error("Updated config file invalid. Aborting.");
+			return EINVAL;
+		}
+	}
+
+	pthread_mutex_lock(&lvm_lock);
+	init_test((lock_flags & LCK_TEST_MODE) ? 1 : 0);
+
+	if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
+		init_mirror_in_sync(1);
+
+	if (lock_flags & LCK_DMEVENTD_MONITOR_IGNORE)
+		init_dmeventd_monitor(DMEVENTD_MONITOR_IGNORE);
+	else {
+		if (lock_flags & LCK_DMEVENTD_MONITOR_MODE)
+			init_dmeventd_monitor(1);
+		else
+			init_dmeventd_monitor(0);
+	}
+
+	cmd->partial_activation = (lock_flags & LCK_PARTIAL_MODE) ? 1 : 0;
+
+	/* clvmd should never try to read suspended device */
+	init_ignore_suspended_devices(1);
+
+	switch (command & LCK_MASK) {
+	case LCK_LV_EXCLUSIVE:
+		status = do_activate_lv(resource, command, lock_flags, LCK_EXCL);
+		break;
+
+	case LCK_LV_SUSPEND:
+		status = do_suspend_lv(resource, command, lock_flags);
+		break;
+
+	case LCK_UNLOCK:
+	case LCK_LV_RESUME:	/* if active */
+		status = do_resume_lv(resource, command, lock_flags);
+		break;
+
+	case LCK_LV_ACTIVATE:
+		status = do_activate_lv(resource, command, lock_flags, LCK_READ);
+		break;
+
+	case LCK_LV_DEACTIVATE:
+		status = do_deactivate_lv(resource, command, lock_flags);
+		break;
+
+	default:
+		DEBUGLOG("Invalid LV command 0x%x\n", command);
+		status = EINVAL;
+		break;
+	}
+
+	if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
+		init_mirror_in_sync(0);
+
+	cmd->partial_activation = 0;
+
+	/* clean the pool for another command */
+	dm_pool_empty(cmd->mem);
+	init_test(0);
+	pthread_mutex_unlock(&lvm_lock);
+
+	DEBUGLOG("Command return is %d, critical_section is %d\n", status, critical_section());
+	return status;
+}
+
+/* Functions to do on the local node only BEFORE the cluster-wide stuff above happens */
+int pre_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
+{
+	/* Nearly all the stuff happens cluster-wide. Apart from SUSPEND. Here we get the
+	   lock out on this node (because we are the node modifying the metadata)
+	   before suspending cluster-wide.
+	   LCKF_CONVERT is used always, local node is going to modify metadata
+	 */
+	if ((command & (LCK_SCOPE_MASK | LCK_TYPE_MASK)) == LCK_LV_SUSPEND &&
+	    (command & LCK_CLUSTER_VG)) {
+		DEBUGLOG("pre_lock_lv: resource '%s', cmd = %s, flags = %s\n",
+			 resource, decode_locking_cmd(command), decode_flags(lock_flags));
+
+		if (!(lock_flags & LCK_TEST_MODE) &&
+		    hold_lock(resource, LCK_WRITE, LCKF_NOQUEUE | LCKF_CONVERT))
+			return errno;
+	}
+	return 0;
+}
+
+/* Functions to do on the local node only AFTER the cluster-wide stuff above happens */
+int post_lock_lv(unsigned char command, unsigned char lock_flags,
+		 char *resource)
+{
+	int status;
+	unsigned origin_only = (lock_flags & LCK_ORIGIN_ONLY_MODE) ? 1 : 0;
+
+	/* Opposite of above, done on resume after a metadata update */
+	if ((command & (LCK_SCOPE_MASK | LCK_TYPE_MASK)) == LCK_LV_RESUME &&
+	    (command & LCK_CLUSTER_VG)) {
+		int oldmode;
+
+		DEBUGLOG("post_lock_lv: resource '%s', cmd = %s, flags = %s\n",
+			 resource, decode_locking_cmd(command), decode_flags(lock_flags));
+
+		/* If the lock state is PW then restore it to what it was */
+		oldmode = get_current_lock(resource);
+		if (oldmode == LCK_WRITE) {
+			struct lvinfo lvi;
+
+			pthread_mutex_lock(&lvm_lock);
+			status = lv_info_by_lvid(cmd, resource, origin_only, &lvi, 0, 0);
+			pthread_mutex_unlock(&lvm_lock);
+			if (!status)
+				return EIO;
+
+			if (!(lock_flags & LCK_TEST_MODE)) {
+				if (lvi.exists) {
+					if (hold_lock(resource, LCK_READ, LCKF_CONVERT))
+						return errno;
+				} else if (hold_unlock(resource))
+					return errno;
+			}
+		}
+	}
+	return 0;
+}
+
+int do_refresh_cache(void)
+{
+	DEBUGLOG("Refreshing context\n");
+	log_notice("Refreshing context");
+
+	pthread_mutex_lock(&lvm_lock);
+
+	if (!refresh_toolcontext(cmd)) {
+		pthread_mutex_unlock(&lvm_lock);
+		return -1;
+	}
+
+	init_ignore_suspended_devices(1);
+	lvmcache_label_scan(cmd);
+	label_scan_destroy(cmd); /* destroys bcache (to close devs), keeps lvmcache */
+	dm_pool_empty(cmd->mem);
+
+	pthread_mutex_unlock(&lvm_lock);
+
+	return 0;
+}
+
+/*
+ * Handle VG lock - drop metadata or update lvmcache state
+ */
+void do_lock_vg(unsigned char command, unsigned char lock_flags, char *resource)
+{
+	uint32_t lock_cmd = command;
+	char *vgname = resource + 2;
+
+	lock_cmd &= (LCK_SCOPE_MASK | LCK_TYPE_MASK | LCK_HOLD);
+
+	/*
+	 * Check if LCK_CACHE should be set. All P_ locks except # are cache related.
+	 */
+	if (strncmp(resource, "P_#", 3) && !strncmp(resource, "P_", 2))
+		lock_cmd |= LCK_CACHE;
+
+	DEBUGLOG("do_lock_vg: resource '%s', cmd = %s, flags = %s, critical_section = %d\n",
+		 resource, decode_full_locking_cmd(lock_cmd), decode_flags(lock_flags), critical_section());
+
+	/* P_#global causes a full cache refresh */
+	if (!strcmp(resource, "P_" VG_GLOBAL)) {
+		do_refresh_cache();
+		return;
+	}
+
+	pthread_mutex_lock(&lvm_lock);
+	init_test((lock_flags & LCK_TEST_MODE) ? 1 : 0);
+
+	switch (lock_cmd) {
+		case LCK_VG_COMMIT:
+			DEBUGLOG("vg_commit notification for VG %s\n", vgname);
+			lvmcache_commit_metadata(vgname);
+			break;
+		case LCK_VG_REVERT:
+			DEBUGLOG("vg_revert notification for VG %s\n", vgname);
+			lvmcache_drop_metadata(vgname, 1);
+			break;
+		case LCK_VG_DROP_CACHE:
+		default:
+			DEBUGLOG("Invalidating cached metadata for VG %s\n", vgname);
+			lvmcache_drop_metadata(vgname, 0);
+	}
+
+	init_test(0);
+	pthread_mutex_unlock(&lvm_lock);
+}
+
+/*
+ * Ideally, clvmd should be started before any LVs are active
+ * but this may not be the case...
+ * I suppose this also comes in handy if clvmd crashes, not that it would!
+ */
+static int get_initial_state(struct dm_hash_table *excl_uuid)
+{
+	int lock_mode;
+	char lv[65], vg[65], flags[26], vg_flags[26]; /* with space for '\0' */
+	char uuid[65];
+	char line[255];
+	char *lvs_cmd;
+	const char *lvm_binary = getenv("LVM_BINARY") ? : LVM_PATH;
+	FILE *lvs;
+
+	if (dm_asprintf(&lvs_cmd, "%s lvs  --config 'log{command_names=0 prefix=\"\"}' "
+			"--nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr,vg_attr",
+			lvm_binary) < 0)
+		return_0;
+
+	/* FIXME: Maybe link and use liblvm2cmd directly instead of fork */
+	if (!(lvs = popen(lvs_cmd, "r"))) {
+		dm_free(lvs_cmd);
+		return 0;
+	}
+
+	while (fgets(line, sizeof(line), lvs)) {
+	        if (sscanf(line, "%64s %64s %25s %25s\n", vg, lv, flags, vg_flags) == 4) {
+
+			/* States: s:suspended a:active S:dropped snapshot I:invalid snapshot */
+		        if (strlen(vg) == 38 &&                         /* is is a valid UUID ? */
+			    (flags[4] == 'a' || flags[4] == 's') &&	/* is it active or suspended? */
+			    vg_flags[5] == 'c') {			/* is it clustered ? */
+				/* Convert hyphen-separated UUIDs into one */
+				memcpy(&uuid[0], &vg[0], 6);
+				memcpy(&uuid[6], &vg[7], 4);
+				memcpy(&uuid[10], &vg[12], 4);
+				memcpy(&uuid[14], &vg[17], 4);
+				memcpy(&uuid[18], &vg[22], 4);
+				memcpy(&uuid[22], &vg[27], 4);
+				memcpy(&uuid[26], &vg[32], 6);
+				memcpy(&uuid[32], &lv[0], 6);
+				memcpy(&uuid[38], &lv[7], 4);
+				memcpy(&uuid[42], &lv[12], 4);
+				memcpy(&uuid[46], &lv[17], 4);
+				memcpy(&uuid[50], &lv[22], 4);
+				memcpy(&uuid[54], &lv[27], 4);
+				memcpy(&uuid[58], &lv[32], 6);
+				uuid[64] = '\0';
+
+				/* Look for this lock in the list of EX locks
+				   we were passed on the command-line */
+				lock_mode = (dm_hash_lookup(excl_uuid, uuid)) ?
+					LCK_EXCL : LCK_READ;
+
+				DEBUGLOG("getting initial lock for %s\n", uuid);
+				if (hold_lock(uuid, lock_mode, LCKF_NOQUEUE))
+					DEBUGLOG("Failed to hold lock %s\n", uuid);
+			}
+		}
+	}
+	if (pclose(lvs))
+		DEBUGLOG("lvs pclose failed: %s\n", strerror(errno));
+
+	dm_free(lvs_cmd);
+
+	return 1;
+}
+
+static void lvm2_log_fn(int level, const char *file, int line, int dm_errno,
+			const char *message)
+{
+
+	/* Send messages to the normal LVM2 logging system too,
+	   so we get debug output when it's asked for.
+ 	   We need to NULL the function ptr otherwise it will just call
+	   back into here! */
+	init_log_fn(NULL);
+	print_log(level, file, line, dm_errno, "%s", message);
+	init_log_fn(lvm2_log_fn);
+
+	/*
+	 * Ignore non-error messages, but store the latest one for returning
+	 * to the user.
+	 */
+	if (level != _LOG_ERR && level != _LOG_FATAL)
+		return;
+
+	(void) dm_strncpy(last_error, message, sizeof(last_error));
+}
+
+/* This checks some basic cluster-LVM configuration stuff */
+static void check_config(void)
+{
+	int locking_type;
+
+	locking_type = find_config_tree_int(cmd, global_locking_type_CFG, NULL);
+
+	if (locking_type == 3) /* compiled-in cluster support */
+		return;
+
+	if (locking_type == 2) { /* External library, check name */
+		const char *libname;
+
+		libname = find_config_tree_str(cmd, global_locking_library_CFG, NULL);
+		if (libname && strstr(libname, "liblvm2clusterlock.so"))
+			return;
+
+		log_error("Incorrect LVM locking library specified in lvm.conf, cluster operations may not work.");
+		return;
+	}
+	log_error("locking_type not set correctly in lvm.conf, cluster operations will not work.");
+}
+
+/* Backups up the LVM metadata if it's changed */
+void lvm_do_backup(const char *vgname)
+{
+	struct volume_group * vg;
+	int consistent = 0;
+
+	DEBUGLOG("Triggering backup of VG metadata for %s.\n", vgname);
+
+	pthread_mutex_lock(&lvm_lock);
+
+	vg = vg_read_internal(cmd, vgname, NULL /*vgid*/, 0, 0, WARN_PV_READ, &consistent);
+
+	if (vg && consistent)
+		check_current_backup(vg);
+	else
+		log_error("Error backing up metadata, can't find VG for group %s", vgname);
+
+	release_vg(vg);
+	dm_pool_empty(cmd->mem);
+
+	pthread_mutex_unlock(&lvm_lock);
+}
+
+struct dm_hash_node *get_next_excl_lock(struct dm_hash_node *v, char **name)
+{
+	struct lv_info *lvi;
+
+	*name = NULL;
+	if (!v)
+		v = dm_hash_get_first(lv_hash);
+
+	do {
+		if (v) {
+			lvi = dm_hash_get_data(lv_hash, v);
+			DEBUGLOG("Looking for EX locks. found %x mode %d\n", lvi->lock_id, lvi->lock_mode);
+
+			if (lvi->lock_mode == LCK_EXCL) {
+				*name = dm_hash_get_key(lv_hash, v);
+			}
+			v = dm_hash_get_next(lv_hash, v);
+		}
+	} while (v && !*name);
+
+	if (*name)
+		DEBUGLOG("returning EXclusive UUID %s\n", *name);
+	return v;
+}
+
+void lvm_do_fs_unlock(void)
+{
+	pthread_mutex_lock(&lvm_lock);
+	DEBUGLOG("Syncing device names\n");
+	fs_unlock();
+	pthread_mutex_unlock(&lvm_lock);
+}
+
+/* Called to initialise the LVM context of the daemon */
+int init_clvm(struct dm_hash_table *excl_uuid)
+{
+	/* Use LOG_DAEMON for syslog messages instead of LOG_USER */
+	init_syslog(LOG_DAEMON);
+	openlog("clvmd", LOG_PID, LOG_DAEMON);
+
+	/* Initialise already held locks */
+	if (!get_initial_state(excl_uuid))
+		log_error("Cannot load initial lock states.");
+
+	if (!udev_init_library_context())
+		stack;
+
+	if (!(cmd = create_toolcontext(1, NULL, 0, 1, 1, 1))) {
+		log_error("Failed to allocate command context");
+		udev_fin_library_context();
+		return 0;
+	}
+
+	if (stored_errno()) {
+		destroy_toolcontext(cmd);
+		return 0;
+	}
+
+	cmd->cmd_line = "clvmd";
+
+	/* Check lvm.conf is setup for cluster-LVM */
+	check_config();
+	init_ignore_suspended_devices(1);
+
+	/* Trap log messages so we can pass them back to the user */
+	init_log_fn(lvm2_log_fn);
+	memlock_inc_daemon(cmd);
+
+	return 1;
+}
+
+void destroy_lvm(void)
+{
+	if (cmd) {
+		memlock_dec_daemon(cmd);
+		destroy_toolcontext(cmd);
+		udev_fin_library_context();
+		cmd = NULL;
+	}
+}

daemons/clvmd/lvm-functions.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2010 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* Functions in lvm-functions.c */
+
+#ifndef _LVM_FUNCTIONS_H
+#define _LVM_FUNCTIONS_H
+
+extern int pre_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
+		       char *resource);
+extern int do_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
+		      char *resource);
+extern const char *do_lock_query(char *resource);
+extern int post_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
+			char *resource);
+extern int do_refresh_cache(void);
+extern int init_clvm(struct dm_hash_table *excl_uuid);
+extern void destroy_lvm(void);
+extern void init_lvhash(void);
+extern void destroy_lvhash(void);
+extern void lvm_do_backup(const char *vgname);
+extern char *get_last_lvm_error(void);
+extern void do_lock_vg(unsigned char command, unsigned char lock_flags,
+		      char *resource);
+extern struct dm_hash_node *get_next_excl_lock(struct dm_hash_node *v, char **name);
+void lvm_do_fs_unlock(void);
+
+#endif

daemons/clvmd/refresh_clvmd.c

@@ -0,0 +1,382 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2010 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/* FIXME Remove duplicated functions from this file. */
+
+/*
+ * Send a command to a running clvmd from the command-line
+ */
+
+#include "clvmd-common.h"
+
+#include "clvm.h"
+#include "refresh_clvmd.h"
+
+#include <stddef.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+typedef struct lvm_response {
+	char node[255];
+	char *response;
+	int status;
+	int len;
+} lvm_response_t;
+
+/*
+ * This gets stuck at the start of memory we allocate so we
+ * can sanity-check it at deallocation time
+ */
+#define LVM_SIGNATURE 0x434C564D
+
+static int _clvmd_sock = -1;
+
+/* Open connection to the clvm daemon */
+static int _open_local_sock(void)
+{
+	int local_socket;
+	struct sockaddr_un sockaddr = { .sun_family = AF_UNIX };
+
+	if (!dm_strncpy(sockaddr.sun_path, CLVMD_SOCKNAME, sizeof(sockaddr.sun_path))) {
+		fprintf(stderr, "%s: clvmd socket name too long.", CLVMD_SOCKNAME);
+		return -1;
+	}
+
+	/* Open local socket */
+	if ((local_socket = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
+		fprintf(stderr, "Local socket creation failed: %s", strerror(errno));
+		return -1;
+	}
+
+	if (connect(local_socket,(struct sockaddr *) &sockaddr,
+		    sizeof(sockaddr))) {
+		int saved_errno = errno;
+
+		fprintf(stderr, "connect() failed on local socket: %s\n",
+			  strerror(errno));
+		if (close(local_socket))
+			return -1;
+
+		errno = saved_errno;
+		return -1;
+	}
+
+	return local_socket;
+}
+
+/* Send a request and return the status */
+static int _send_request(const char *inbuf, int inlen, char **retbuf, int no_response)
+{
+	char outbuf[PIPE_BUF];
+	struct clvm_header *outheader = (struct clvm_header *) outbuf;
+	int len;
+	unsigned off;
+	int buflen;
+	int err;
+
+	/* Send it to CLVMD */
+ rewrite:
+	if ( (err = write(_clvmd_sock, inbuf, inlen)) != inlen) {
+	        if (err == -1 && errno == EINTR)
+		        goto rewrite;
+		fprintf(stderr, "Error writing data to clvmd: %s", strerror(errno));
+		return 0;
+	}
+	if (no_response)
+		return 1;
+
+	/* Get the response */
+ reread:
+	if ((len = read(_clvmd_sock, outbuf, sizeof(struct clvm_header))) < 0) {
+	        if (errno == EINTR)
+		        goto reread;
+		fprintf(stderr, "Error reading data from clvmd: %s", strerror(errno));
+		return 0;
+	}
+
+	if (len == 0) {
+		fprintf(stderr, "EOF reading CLVMD");
+		errno = ENOTCONN;
+		return 0;
+	}
+
+	/* Allocate buffer */
+	buflen = len + outheader->arglen;
+	*retbuf = dm_malloc(buflen);
+	if (!*retbuf) {
+		errno = ENOMEM;
+		return 0;
+	}
+
+	/* Copy the header */
+	memcpy(*retbuf, outbuf, len);
+	outheader = (struct clvm_header *) *retbuf;
+
+	/* Read the returned values */
+	off = 1;		/* we've already read the first byte */
+	while (off <= outheader->arglen && len > 0) {
+		len = read(_clvmd_sock, outheader->args + off,
+			   buflen - off - offsetof(struct clvm_header, args));
+		if (len > 0)
+			off += len;
+	}
+
+	/* Was it an error ? */
+	if (outheader->status != 0) {
+		errno = outheader->status;
+
+		/* Only return an error here if there are no node-specific
+		   errors present in the message that might have more detail */
+		if (!(outheader->flags & CLVMD_FLAG_NODEERRS)) {
+			fprintf(stderr, "cluster request failed: %s\n", strerror(errno));
+			return 0;
+		}
+
+	}
+
+	return 1;
+}
+
+/* Build the structure header and parse-out wildcard node names */
+static void _build_header(struct clvm_header *head, int cmd, const char *node,
+			  unsigned int len)
+{
+	head->cmd = cmd;
+	head->status = 0;
+	head->flags = 0;
+	head->xid = 0;
+	head->clientid = 0;
+	if (len)
+		/* 1 byte is used from struct clvm_header.args[1], so -> len - 1 */
+		head->arglen = len - 1;
+	else {
+		head->arglen = 0;
+		*head->args = '\0';
+	}
+
+	/*
+	 * Translate special node names.
+	 */
+	if (!node || !strcmp(node, NODE_ALL))
+		head->node[0] = '\0';
+	else if (!strcmp(node, NODE_LOCAL)) {
+		head->node[0] = '\0';
+		head->flags = CLVMD_FLAG_LOCAL;
+	} else
+		strcpy(head->node, node);
+}
+
+/*
+ * Send a message to a(or all) node(s) in the cluster and wait for replies
+ */
+static int _cluster_request(char cmd, const char *node, void *data, int len,
+			    lvm_response_t ** response, int *num, int no_response)
+{
+	char outbuf[sizeof(struct clvm_header) + len + strlen(node) + 1];
+	char *inptr;
+	char *retbuf = NULL;
+	int status;
+	int i;
+	int num_responses = 0;
+	struct clvm_header *head = (struct clvm_header *) outbuf;
+	lvm_response_t *rarray;
+
+	*num = 0;
+
+	if (_clvmd_sock == -1)
+		_clvmd_sock = _open_local_sock();
+
+	if (_clvmd_sock == -1)
+		return 0;
+
+	_build_header(head, cmd, node, len);
+	if (len)
+		memcpy(head->node + strlen(head->node) + 1, data, len);
+
+	status = _send_request(outbuf, sizeof(struct clvm_header) +
+			       strlen(head->node) + len, &retbuf, no_response);
+	if (!status || no_response)
+		goto out;
+
+	/* Count the number of responses we got */
+	head = (struct clvm_header *) retbuf;
+	inptr = head->args;
+	while (inptr[0]) {
+		num_responses++;
+		inptr += strlen(inptr) + 1;
+		inptr += sizeof(int);
+		inptr += strlen(inptr) + 1;
+	}
+
+	/*
+	 * Allocate response array.
+	 * With an extra pair of INTs on the front to sanity
+	 * check the pointer when we are given it back to free
+	 */
+	*response = NULL;
+	if (!(rarray = dm_malloc(sizeof(lvm_response_t) * num_responses +
+				 sizeof(int) * 2))) {
+		errno = ENOMEM;
+		status = 0;
+		goto out;
+	}
+
+	/* Unpack the response into an lvm_response_t array */
+	inptr = head->args;
+	i = 0;
+	while (inptr[0]) {
+		strcpy(rarray[i].node, inptr);
+		inptr += strlen(inptr) + 1;
+
+		memcpy(&rarray[i].status, inptr, sizeof(int));
+		inptr += sizeof(int);
+
+		rarray[i].response = dm_malloc(strlen(inptr) + 1);
+		if (rarray[i].response == NULL) {
+			/* Free up everything else and return error */
+			int j;
+			for (j = 0; j < i; j++)
+				dm_free(rarray[i].response);
+			dm_free(rarray);
+			errno = ENOMEM;
+			status = 0;
+			goto out;
+		}
+
+		strcpy(rarray[i].response, inptr);
+		rarray[i].len = strlen(inptr);
+		inptr += strlen(inptr) + 1;
+		i++;
+	}
+	*num = num_responses;
+	*response = rarray;
+
+      out:
+	dm_free(retbuf);
+
+	return status;
+}
+
+/* Free reply array */
+static int _cluster_free_request(lvm_response_t * response, int num)
+{
+	int i;
+
+	for (i = 0; i < num; i++) {
+		dm_free(response[i].response);
+	}
+
+	dm_free(response);
+
+	return 1;
+}
+
+int refresh_clvmd(int all_nodes)
+{
+	int num_responses;
+	char args[1]; // No args really.
+	lvm_response_t *response = NULL;
+	int saved_errno;
+	int status;
+	int i;
+
+	status = _cluster_request(CLVMD_CMD_REFRESH, all_nodes ? NODE_ALL : NODE_LOCAL, args, 0, &response, &num_responses, 0);
+
+	/* If any nodes were down then display them and return an error */
+	for (i = 0; i < num_responses; i++) {
+		if (response[i].status == EHOSTDOWN) {
+			fprintf(stderr, "clvmd not running on node %s",
+				  response[i].node);
+			status = 0;
+			errno = response[i].status;
+		} else if (response[i].status) {
+			fprintf(stderr, "Error resetting node %s: %s",
+				  response[i].node,
+				  response[i].response[0] ?
+				  	response[i].response :
+				  	strerror(response[i].status));
+			status = 0;
+			errno = response[i].status;
+		}
+	}
+
+	saved_errno = errno;
+	_cluster_free_request(response, num_responses);
+	errno = saved_errno;
+
+	return status;
+}
+
+int restart_clvmd(int all_nodes)
+{
+	int dummy, status;
+
+	status = _cluster_request(CLVMD_CMD_RESTART, all_nodes ? NODE_ALL : NODE_LOCAL, NULL, 0, NULL, &dummy, 1);
+
+	/*
+	 * FIXME: we cannot receive response, clvmd re-exec before it.
+	 *        but also should not close socket too early (the whole rq is dropped then).
+	 * FIXME: This should be handled this way:
+	 *  - client waits for RESTART ack (and socket close)
+	 *  - server restarts
+	 *  - client checks that server is ready again (VERSION command?)
+	 */
+	usleep(500000);
+
+	return status;
+}
+
+int debug_clvmd(int level, int clusterwide)
+{
+	int num_responses;
+	char args[1];
+	const char *nodes;
+	lvm_response_t *response = NULL;
+	int saved_errno;
+	int status;
+	int i;
+
+	args[0] = level;
+	if (clusterwide)
+		nodes = NODE_ALL;
+	else
+		nodes = NODE_LOCAL;
+
+	status = _cluster_request(CLVMD_CMD_SET_DEBUG, nodes, args, 1, &response, &num_responses, 0);
+
+	/* If any nodes were down then display them and return an error */
+	for (i = 0; i < num_responses; i++) {
+		if (response[i].status == EHOSTDOWN) {
+			fprintf(stderr, "clvmd not running on node %s",
+				  response[i].node);
+			status = 0;
+			errno = response[i].status;
+		} else if (response[i].status) {
+			fprintf(stderr, "Error setting debug on node %s: %s",
+				  response[i].node,
+				  response[i].response[0] ?
+				  	response[i].response :
+				  	strerror(response[i].status));
+			status = 0;
+			errno = response[i].status;
+		}
+	}
+
+	saved_errno = errno;
+	_cluster_free_request(response, num_responses);
+	errno = saved_errno;
+
+	return status;
+}

daemons/clvmd/refresh_clvmd.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2007 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 General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+int refresh_clvmd(int all_nodes);
+int restart_clvmd(int all_nodes);
+int debug_clvmd(int level, int clusterwide);
+

daemons/cmirrord/Makefile.in

@@ -17,27 +17,23 @@ top_builddir = @top_builddir@
 
 CPG_LIBS = @CPG_LIBS@
 CPG_CFLAGS = @CPG_CFLAGS@
+SACKPT_LIBS = @SACKPT_LIBS@
+SACKPT_CFLAGS = @SACKPT_CFLAGS@
 
 SOURCES = clogd.c cluster.c compat.c functions.c link_mon.c local.c logging.c
 
 TARGETS = cmirrord
 
-CFLOW_SOURCES = $(addprefix $(srcdir)/, $(SOURCES))
-CFLOW_TARGET := $(TARGETS)
-
 include $(top_builddir)/make.tmpl
 
-LMLIBS += $(CPG_LIBS)
-CFLAGS += $(CPG_CFLAGS) $(EXTRA_EXEC_CFLAGS)
+LIBS += -ldevmapper
+LMLIBS += $(CPG_LIBS) $(SACKPT_LIBS)
+CFLAGS += $(CPG_CFLAGS) $(SACKPT_CFLAGS) $(EXTRA_EXEC_CFLAGS)
 LDFLAGS += $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS)
 
-cmirrord: $(OBJECTS)
-	$(SHOW) "    [CC] $@"
-	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) \
-		$(LMLIBS) -L$(top_builddir)/libdm -ldevmapper $(LIBS)
+cmirrord: $(OBJECTS) $(top_builddir)/lib/liblvm-internal.a
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) \
+		$(LVMLIBS) $(LMLIBS) $(LIBS)
 
-install_cluster: $(TARGETS)
-	$(SHOW) "    [INSTALL] $<"
-	$(Q) $(INSTALL_PROGRAM) -D $< $(usrsbindir)/$(<F)
-
-install: install_cluster
+install: $(TARGETS)
+	$(INSTALL_PROGRAM) -D cmirrord $(usrsbindir)/cmirrord

daemons/cmirrord/clogd.c

@@ -43,14 +43,14 @@ static void usage (FILE *dest)
 int main(int argc, char *argv[])
 {
 	int foreground_mode = 0;
-	static const struct option _long_options[] = {
+	struct option longopts[] = {
 		{ "foreground", no_argument, NULL, 'f' },
 		{ "help"      , no_argument, NULL, 'h' },
 		{ 0, 0, 0, 0 }
 	};
 	int opt;
 
-	while ((opt = getopt_long (argc, argv, "fh", _long_options, NULL)) != -1) {
+	while ((opt = getopt_long (argc, argv, "fh", longopts, NULL)) != -1) {
 		switch (opt) {
 		case 'f':
 			foreground_mode = 1;
@@ -245,7 +245,6 @@ static void daemonize(void)
 	}
 
 	LOG_OPEN("cmirrord", LOG_PID, LOG_DAEMON);
-	/* coverity[leaked_handle] devnull cannot leak here */
 }
 
 /*

daemons/cmirrord/cluster.c

@@ -16,11 +16,7 @@
 #include "functions.h"
 #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
+#include "xlate.h"
 
 #include <corosync/cpg.h>
 #include <errno.h>
@@ -108,7 +104,7 @@ static SaVersionT version = { 'B', 1, 1 };
 #endif
 
 #define DEBUGGING_HISTORY 100
-#define DEBUGGING_BUFLEN 270
+#define DEBUGGING_BUFLEN 128
 #define LOG_SPRINT(cc, f, arg...) do {				\
 		cc->idx++;					\
 		cc->idx = cc->idx % DEBUGGING_HISTORY;		\
@@ -279,7 +275,7 @@ static int handle_cluster_request(struct clog_cpg *entry __attribute__((unused))
 	 * With resumes, we only handle our own.
 	 * Resume is a special case that requires
 	 * local action (to set up CPG), followed by
-	 * a cluster action to coordinate reading
+	 * a cluster action to co-ordinate reading
 	 * the disk and checkpointing
 	 */
 	if (tmp->u_rq.request_type == DM_ULOG_RESUME) {
@@ -403,12 +399,13 @@ static struct checkpoint_data *prepare_checkpoint(struct clog_cpg *entry,
 		return NULL;
 	}
 
-	new = zalloc(sizeof(*new));
+	new = malloc(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,12 +640,13 @@ static int export_checkpoint(struct checkpoint_data *cp)
 	rq_size += RECOVERING_REGION_SECTION_SIZE;
 	rq_size += cp->bitmap_size * 2; /* clean|sync_bits */
 
-	rq = zalloc(rq_size);
+	rq = malloc(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;
@@ -1091,7 +1089,6 @@ static void cpg_message_callback(cpg_handle_t handle, const struct cpg_name *gna
 	    (rq->u_rq.request_type != DM_ULOG_RESUME) &&
 	    (rq->u_rq.request_type != DM_ULOG_CLEAR_REGION) &&
 	    (rq->u_rq.request_type != DM_ULOG_CHECKPOINT_READY)) {
-		/* coverity[suspicious_sizeof] allocation is using varargs data @end */
 		tmp_rq = malloc(DM_ULOG_REQUEST_SIZE);
 		if (!tmp_rq) {
 			/*
@@ -1341,7 +1338,6 @@ static void cpg_join_callback(struct clog_cpg *match,
 		goto out;
 	}
 
-	/* coverity[suspicious_sizeof] allocation is using varargs data @end */
 	rq = malloc(DM_ULOG_REQUEST_SIZE);
 	if (!rq) {
 		LOG_ERROR("cpg_config_callback: "
@@ -1385,7 +1381,7 @@ static void cpg_leave_callback(struct clog_cpg *match,
 			       size_t member_list_entries)
 {
 	unsigned i;
-	int j, fd = -1;
+	int j, fd;
 	uint32_t lowest = match->lowest_id;
 	struct clog_request *rq, *n;
 	struct checkpoint_data *p_cp, *c_cp;
@@ -1550,7 +1546,7 @@ static void cpg_config_callback(cpg_handle_t handle, const struct cpg_name *gnam
 				   member_list, member_list_entries);
 }
 
-static cpg_callbacks_t cpg_callbacks = {
+cpg_callbacks_t cpg_callbacks = {
 	.cpg_deliver_fn = cpg_message_callback,
 	.cpg_confchg_fn = cpg_config_callback,
 };
@@ -1622,11 +1618,12 @@ int create_cluster_cpg(char *uuid, uint64_t luid)
 			return -EEXIST;
 		}
 
-	new = zalloc(sizeof(*new));
+	new = malloc(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);
@@ -1634,7 +1631,7 @@ int create_cluster_cpg(char *uuid, uint64_t luid)
 
 	size = ((strlen(uuid) + 1) > CPG_MAX_NAME_LENGTH) ?
 		CPG_MAX_NAME_LENGTH : (strlen(uuid) + 1);
-	dm_strncpy(new->name.value, uuid, size);
+	(void) dm_strncpy(new->name.value, uuid, size);
 	new->name.length = (uint32_t)size;
 	new->luid = luid;
 

daemons/cmirrord/cluster.h

@@ -12,8 +12,8 @@
 #ifndef _LVM_CLOG_CLUSTER_H
 #define _LVM_CLOG_CLUSTER_H
 
-#include "libdm/libdevmapper.h"
-#include "libdm/misc/dm-log-userspace.h"
+#include "dm-log-userspace.h"
+#include "libdevmapper.h"
 
 #define DM_ULOG_RESPONSE 0x1000U /* in last byte of 32-bit value */
 #define DM_ULOG_CHECKPOINT_READY 21
@@ -39,7 +39,7 @@ struct clog_request {
 	 * machine.  If the two are equal, there is no need
 	 * to do endian conversions.
 	 */
-	union version_u {
+	union {
 		uint64_t version[2]; /* LE version and native version */
 		struct dm_list list;
 	} u;

daemons/cmirrord/compat.c

@@ -8,7 +8,7 @@
 #include "logging.h"
 #include "cluster.h"
 #include "compat.h"
-#include "lib/mm/xlate.h"
+#include "xlate.h"
 
 #include <errno.h>
 

daemons/cmirrord/compat.h

@@ -8,8 +8,6 @@
 #ifndef _LVM_CLOG_COMPAT_H
 #define _LVM_CLOG_COMPAT_H
 
-#include <stddef.h>
-
 /*
  * The intermachine communication structure version are:
  *	0: Unused
@@ -21,8 +19,6 @@
  */
 #define CLOG_TFR_VERSION 5
 
-struct clog_request;
-
 int clog_request_to_network(struct clog_request *rq);
 int clog_request_from_network(void *data, size_t data_len);
 

daemons/cmirrord/functions.c

@@ -11,7 +11,6 @@
  */
 #include "logging.h"
 #include "functions.h"
-#include "base/memory/zalloc.h"
 
 #include <sys/sysmacros.h>
 #include <dirent.h>
@@ -34,7 +33,7 @@
 #define LOG_OFFSET 2
 
 #define RESYNC_HISTORY 50
-#define RESYNC_BUFLEN 270
+#define RESYNC_BUFLEN 128
 //static char resync_history[RESYNC_HISTORY][128];
 //static int idx = 0;
 #define LOG_SPRINT(_lc, f, arg...) do {					\
@@ -67,7 +66,7 @@ struct log_c {
 	uint32_t recoverer;
 	uint64_t recovering_region; /* -1 means not recovering */
 	uint64_t skip_bit_warning; /* used to warn if region skipped */
-	unsigned sync_search;
+	int sync_search;
 
 	int resume_override;
 
@@ -220,7 +219,7 @@ static int rw_log(struct log_c *lc, int do_write)
 	if (r < 0)
 		LOG_ERROR("[%s] rw_log:  read failure: %s",
 			  SHORT_UUID(lc->uuid), strerror(errno));
-	if ((unsigned) r != lc->disk_size)
+	if (r != lc->disk_size)
 		return -EIO; /* Failed disk read */
 	return 0;
 }
@@ -254,7 +253,7 @@ static int read_log(struct log_c *lc)
 	bitset_size = lc->region_count / 8;
 	bitset_size += (lc->region_count % 8) ? 1 : 0;
 
-	/* 'lc->clean_bits + 1' because dm_bitset_t leads with a uint32_t */
+	/* 'lc->clean_bits + 1' becasue dm_bitset_t leads with a uint32_t */
 	memcpy(lc->clean_bits + 1, (char *)lc->disk_buffer + 1024, bitset_size);
 
 	return 0;
@@ -281,7 +280,7 @@ static int write_log(struct log_c *lc)
 	bitset_size = lc->region_count / 8;
 	bitset_size += (lc->region_count % 8) ? 1 : 0;
 
-	/* 'lc->clean_bits + 1' because dm_bitset_t leads with a uint32_t */
+	/* 'lc->clean_bits + 1' becasue dm_bitset_t leads with a uint32_t */
 	memcpy((char *)lc->disk_buffer + 1024, lc->clean_bits + 1, bitset_size);
 
 	if (rw_log(lc, 1)) {
@@ -292,13 +291,13 @@ static int write_log(struct log_c *lc)
 }
 
 /* FIXME Rewrite this function taking advantage of the udev changes (where in use) to improve its efficiency! */
-static int find_disk_path(char *major_minor_str, char *path_rtn, size_t sz, int *unlink_path __attribute__((unused)))
+static int find_disk_path(char *major_minor_str, char *path_rtn, int *unlink_path __attribute__((unused)))
 {
 	int r;
 	DIR *dp;
 	struct dirent *dep;
 	struct stat statbuf;
-	unsigned major, minor;
+	int major, minor;
 
 	if (!strstr(major_minor_str, ":")) {
 		r = stat(major_minor_str, &statbuf);
@@ -306,7 +305,7 @@ static int find_disk_path(char *major_minor_str, char *path_rtn, size_t sz, int
 			return -errno;
 		if (!S_ISBLK(statbuf.st_mode))
 			return -EINVAL;
-		dm_strncpy(path_rtn, major_minor_str, sz);
+		sprintf(path_rtn, "%s", major_minor_str);
 		return 0;
 	}
 
@@ -329,7 +328,7 @@ static int find_disk_path(char *major_minor_str, char *path_rtn, size_t sz, int
 		 * wanted.
 		 */
 
-		snprintf(path_rtn, sz, "/dev/mapper/%s", dep->d_name);
+		sprintf(path_rtn, "/dev/mapper/%s", dep->d_name);
 		if (stat(path_rtn, &statbuf) < 0) {
 			LOG_DBG("Unable to stat %s", path_rtn);
 			continue;
@@ -378,7 +377,7 @@ static int _clog_ctr(char *uuid, uint64_t luid,
 	uint32_t block_on_error = 0;
 
 	int disk_log;
-	char disk_path[PATH_MAX] = { 0 };
+	char disk_path[PATH_MAX];
 	int unlink_path = 0;
 	long page_size;
 	int pages;
@@ -394,7 +393,7 @@ static int _clog_ctr(char *uuid, uint64_t luid,
 			goto fail;
 		}
 
-		r = find_disk_path(argv[0], disk_path, sizeof(disk_path), &unlink_path);
+		r = find_disk_path(argv[0], disk_path, &unlink_path);
 		if (r) {
 			LOG_ERROR("Unable to find path to device %s", argv[0]);
 			goto fail;
@@ -436,7 +435,7 @@ static int _clog_ctr(char *uuid, uint64_t luid,
 			block_on_error = 1;
 	}
 
-	lc = zalloc(sizeof(*lc));
+	lc = dm_zalloc(sizeof(*lc));
 	if (!lc) {
 		LOG_ERROR("Unable to allocate cluster log context");
 		r = -ENOMEM;
@@ -452,7 +451,7 @@ static int _clog_ctr(char *uuid, uint64_t luid,
 	lc->skip_bit_warning = region_count;
 	lc->disk_fd = -1;
 	lc->log_dev_failed = 0;
-	if (!_dm_strncpy(lc->uuid, uuid, DM_UUID_LEN)) {
+	if (!dm_strncpy(lc->uuid, uuid, DM_UUID_LEN)) {
 		LOG_ERROR("Cannot use too long UUID %s.", uuid);
 		r = -EINVAL;
 		goto fail;
@@ -533,9 +532,9 @@ fail:
 			LOG_ERROR("Close device error, %s: %s",
 				  disk_path, strerror(errno));
 		free(lc->disk_buffer);
-		free(lc->sync_bits);
-		free(lc->clean_bits);
-		free(lc);
+		dm_free(lc->sync_bits);
+		dm_free(lc->clean_bits);
+		dm_free(lc);
 	}
 	return r;
 }
@@ -658,10 +657,11 @@ static int clog_dtr(struct dm_ulog_request *rq)
 	if (lc->disk_fd != -1 && close(lc->disk_fd))
 		LOG_ERROR("Failed to close disk log: %s",
 			  strerror(errno));
-	free(lc->disk_buffer);
-	free(lc->clean_bits);
-	free(lc->sync_bits);
-	free(lc);
+	if (lc->disk_buffer)
+		free(lc->disk_buffer);
+	dm_free(lc->clean_bits);
+	dm_free(lc->sync_bits);
+	dm_free(lc);
 
 	return 0;
 }
@@ -927,7 +927,7 @@ int local_resume(struct dm_ulog_request *rq)
  *
  * Since this value doesn't change, the kernel
  * should not need to talk to server to get this
- * The function is here for completeness
+ * The function is here for completness
  *
  * Returns: 0 on success, -EXXX on failure
  */
@@ -1018,7 +1018,7 @@ static int clog_in_sync(struct dm_ulog_request *rq)
 	 * happen for reads is that additional read attempts may be
 	 * taken.
 	 *
-	 * Further investigation may be required to determine if there are
+	 * Futher investigation may be required to determine if there are
 	 * similar possible outcomes when the mirror is in the process of
 	 * recovering.  In that case, lc->in_sync would not have been set
 	 * yet.

daemons/cmirrord/functions.h

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

daemons/cmirrord/local.c

@@ -266,7 +266,7 @@ static int do_local_work(void *data __attribute__((unused)))
 					  RQ_TYPE(u_rq->request_type));
 			break;
 		}
-		/* ELSE */ /* fall through */
+		/* ELSE, fall through */
 	case DM_ULOG_IS_CLEAN:
 	case DM_ULOG_FLUSH:
 	case DM_ULOG_MARK_REGION:

daemons/cmirrord/local.h

@@ -12,8 +12,6 @@
 #ifndef _LVM_CLOG_LOCAL_H
 #define _LVM_CLOG_LOCAL_H
 
-struct dm_ulog_request;
-
 int init_local(void);
 void cleanup_local(void);
 

daemons/cmirrord/logging.c

@@ -11,7 +11,7 @@
  */
 #include "logging.h"
 
-const char * const __rq_types_off_by_one[] = {
+const char *__rq_types_off_by_one[] = {
 	"DM_ULOG_CTR",
 	"DM_ULOG_DTR",
 	"DM_ULOG_PRESUSPEND",

daemons/cmirrord/logging.h

@@ -13,6 +13,9 @@
 #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>
@@ -20,7 +23,7 @@
 /* SHORT_UUID - print last 8 chars of a string */
 #define SHORT_UUID(x) (strlen(x) > 8) ? ((x) + (strlen(x) - 8)) : (x)
 
-extern const char * const __rq_types_off_by_one[];
+extern const char *__rq_types_off_by_one[];
 #define RQ_TYPE(x) __rq_types_off_by_one[(x) - 1]
 
 extern int log_tabbing;

daemons/dmeventd/Makefile.in

@@ -14,21 +14,11 @@
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
-abs_srcdir = @abs_srcdir@
 
 SOURCES = libdevmapper-event.c
 SOURCES2 = dmeventd.c
 
 TARGETS = dmeventd
-CFLOW_SOURCES = $(addprefix $(srcdir)/, $(SOURCES) $(SOURCES2) \
-	plugins/lvm2/dmeventd_lvm.c \
-	plugins/mirror/dmeventd_mirror.c \
-	plugins/raid/dmeventd_raid.c \
-	plugins/snapshot/dmeventd_snapshot.c \
-	plugins/thin/dmeventd_thin.c \
-	plugins/vdo/dmeventd_vdo.c \
-	)
-CFLOW_TARGET := $(TARGETS)
 
 .PHONY: install_lib_dynamic install_lib_static install_include \
 	install_pkgconfig install_dmeventd_dynamic install_dmeventd_static \
@@ -47,7 +37,6 @@ endif
 
 LIB_VERSION = $(LIB_VERSION_DM)
 LIB_SHARED = $(LIB_NAME).$(LIB_SUFFIX)
-LIBS = $(PTHREAD_LIBS) -L$(interfacebuilddir) -ldevmapper
 
 CLEAN_TARGETS = dmeventd.static $(LIB_NAME).a
 
@@ -57,6 +46,7 @@ endif
 
 CFLOW_LIST = $(SOURCES)
 CFLOW_LIST_TARGET = $(LIB_NAME).cflow
+CFLOW_TARGET = dmeventd
 
 EXPORTED_HEADER = $(srcdir)/libdevmapper-event.h
 EXPORTED_FN_PREFIX = dm_event
@@ -65,47 +55,49 @@ include $(top_builddir)/make.tmpl
 
 all: device-mapper
 device-mapper: $(TARGETS)
-plugins.device-mapper: $(LIB_SHARED)
 
 CFLAGS_dmeventd.o += $(EXTRA_EXEC_CFLAGS)
+LIBS += -ldevmapper $(PTHREAD_LIBS)
 
 dmeventd: $(LIB_SHARED) dmeventd.o
-	$(SHOW) "    [CC] $@"
-	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS) dmeventd.o \
+	$(CC) $(CFLAGS) -L. $(LDFLAGS) $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS) dmeventd.o \
 		-o $@ $(DL_LIBS) $(DMEVENT_LIBS) $(LIBS)
 
-dmeventd.static: $(LIB_STATIC) dmeventd.o
-	$(SHOW) "    [CC] $@"
-	$(Q) $(CC) $(CFLAGS) $(LDFLAGS) $(STATIC_LDFLAGS) -static dmeventd.o \
+dmeventd.static: $(LIB_STATIC) dmeventd.o $(interfacebuilddir)/libdevmapper.a
+	$(CC) $(CFLAGS) $(LDFLAGS) -static -L. -L$(interfacebuilddir) dmeventd.o \
 		-o $@ $(DL_LIBS) $(DMEVENT_LIBS) $(LIBS) $(STATIC_LIBS)
 
 ifeq ("@PKGCONFIG@", "yes")
   INSTALL_LIB_TARGETS += install_pkgconfig
 endif
 
+ifneq ("$(CFLOW_CMD)", "")
+CFLOW_SOURCES = $(addprefix $(srcdir)/, $(SOURCES))
+-include $(top_builddir)/libdm/libdevmapper.cflow
+-include $(top_builddir)/lib/liblvm-internal.cflow
+-include $(top_builddir)/lib/liblvm2cmd.cflow
+-include $(top_builddir)/daemons/dmeventd/$(LIB_NAME).cflow
+-include $(top_builddir)/daemons/dmeventd/plugins/mirror/$(LIB_NAME)-lvm2mirror.cflow
+endif
+
 install_include: $(srcdir)/libdevmapper-event.h
-	$(SHOW) "    [INSTALL] $(<F)"
-	$(Q) $(INSTALL_DATA) -D $< $(includedir)/$(<F)
+	$(INSTALL_DATA) -D $< $(includedir)/$(<F)
 
 install_pkgconfig: libdevmapper-event.pc
-	$(SHOW) "    [INSTALL] $<"
-	$(Q) $(INSTALL_DATA) -D $< $(pkgconfigdir)/devmapper-event.pc
+	$(INSTALL_DATA) -D $< $(pkgconfigdir)/devmapper-event.pc
 
 install_lib_dynamic: install_lib_shared
 
 install_lib_static: $(LIB_STATIC)
-	$(SHOW) "    [INSTALL] $<"
-	$(Q) $(INSTALL_DATA) -D $< $(usrlibdir)/$(<F)
+	$(INSTALL_DATA) -D $< $(usrlibdir)/$(<F)
 
 install_lib: $(INSTALL_LIB_TARGETS)
 
 install_dmeventd_dynamic: dmeventd
-	$(SHOW) "    [INSTALL] $<"
-	$(Q) $(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
+	$(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
 
 install_dmeventd_static: dmeventd.static
-	$(SHOW) "    [INSTALL] $<"
-	$(Q) $(INSTALL_PROGRAM) -D $< $(staticdir)/$(<F)
+	$(INSTALL_PROGRAM) -D $< $(staticdir)/$(<F)
 
 install_dmeventd: $(INSTALL_DMEVENTD_TARGETS)
 

daemons/dmeventd/dmeventd.c

@@ -16,25 +16,23 @@
  * dmeventd - dm event daemon to monitor active mapped devices
  */
 
+#include "dm-logging.h"
 
 #include "libdevmapper-event.h"
 #include "dmeventd.h"
 
-#include "libdm/misc/dm-logging.h"
-#include "base/memory/zalloc.h"
-
-#include "libdaemon/server/daemon-stray.h"
+#include "tool.h"
 
 #include <dlfcn.h>
 #include <pthread.h>
+#include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <sys/time.h>
 #include <sys/resource.h>
 #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,6 +60,8 @@
 
 #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 */
@@ -92,10 +92,12 @@ static const size_t THREAD_STACK_SIZE = 300 * 1024;
 /* Default idle exit timeout 1 hour (in seconds) */
 static const time_t DMEVENTD_IDLE_EXIT_TIMEOUT = 60 * 60;
 
+static int _debug_level = 0;
+static int _use_syslog = 1;
 static int _systemd_activation = 0;
 static int _foreground = 0;
+static int _restart = 0;
 static time_t _idle_since = 0;
-static const char *_exit_on = DEFAULT_DMEVENTD_EXIT_ON_PATH;
 static char **_initial_registrations = 0;
 
 /* FIXME Make configurable at runtime */
@@ -200,9 +202,9 @@ struct message_data {
 	char *dso_name;		/* Name of DSO. */
 	char *device_uuid;	/* Mapped device path. */
 	char *events_str;	/* Events string as fetched from message. */
-	unsigned events_field;	/* Events bitfield. */
-	uint32_t timeout_secs;
+	enum dm_event_mask events_field;	/* Events bitfield. */
 	char *timeout_str;
+	uint32_t timeout_secs;
 	struct dm_event_daemon_message *msg;	/* Pointer to message buffer. */
 };
 
@@ -236,7 +238,7 @@ struct thread_status {
 	int status;		/* See DM_THREAD_{REGISTERING,RUNNING,DONE} */
 
 	int events;		/* bitfield for event filter. */
-	int current_events;	/* bitfield for occurred events. */
+	int current_events;	/* bitfield for occured events. */
 	struct dm_task *wait_task;
 	int pending;		/* Set when event filter change is pending */
 	time_t next_time;
@@ -262,19 +264,19 @@ static pthread_cond_t _timeout_cond = PTHREAD_COND_INITIALIZER;
 /* DSO data allocate/free. */
 static void _free_dso_data(struct dso_data *data)
 {
-	free(data->dso_name);
-	free(data);
+	dm_free(data->dso_name);
+	dm_free(data);
 }
 
 static struct dso_data *_alloc_dso_data(struct message_data *data)
 {
-	struct dso_data *ret = (__typeof__(ret)) zalloc(sizeof(*ret));
+	struct dso_data *ret = (typeof(ret)) dm_zalloc(sizeof(*ret));
 
 	if (!ret)
 		return_NULL;
 
-	if (!(ret->dso_name = strdup(data->dso_name))) {
-		free(ret);
+	if (!(ret->dso_name = dm_strdup(data->dso_name))) {
+		dm_free(ret);
 		return_NULL;
 	}
 
@@ -395,9 +397,9 @@ static void _free_thread_status(struct thread_status *thread)
 	_lib_put(thread->dso_data);
 	if (thread->wait_task)
 		dm_task_destroy(thread->wait_task);
-	free(thread->device.uuid);
-	free(thread->device.name);
-	free(thread);
+	dm_free(thread->device.uuid);
+	dm_free(thread->device.name);
+	dm_free(thread);
 }
 
 /* Note: events_field must not be 0, ensured by caller */
@@ -406,7 +408,7 @@ static struct thread_status *_alloc_thread_status(const struct message_data *dat
 {
 	struct thread_status *thread;
 
-	if (!(thread = zalloc(sizeof(*thread)))) {
+	if (!(thread = dm_zalloc(sizeof(*thread)))) {
 		log_error("Cannot create new thread, out of memory.");
 		return NULL;
 	}
@@ -420,14 +422,14 @@ static struct thread_status *_alloc_thread_status(const struct message_data *dat
 	if (!dm_task_set_uuid(thread->wait_task, data->device_uuid))
 		goto_out;
 
-	if (!(thread->device.uuid = strdup(data->device_uuid)))
+	if (!(thread->device.uuid = dm_strdup(data->device_uuid)))
 		goto_out;
 
 	/* Until real name resolved, use UUID */
-	if (!(thread->device.name = strdup(data->device_uuid)))
+	if (!(thread->device.name = dm_strdup(data->device_uuid)))
 		goto_out;
 
-	/* runs ioctl and may register lvm2 plugin */
+	/* runs ioctl and may register lvm2 pluging */
 	thread->processing = 1;
 	thread->status = DM_THREAD_REGISTERING;
 
@@ -513,17 +515,17 @@ static int _fetch_string(char **ptr, char **src, const int delimiter)
 	if ((p = strchr(*src, delimiter))) {
 		if (*src < p) {
 			*p = 0; /* Temporary exit with \0 */
-			if (!(*ptr = strdup(*src))) {
+			if (!(*ptr = dm_strdup(*src))) {
 				log_error("Failed to fetch item %s.", *src);
 				ret = 0; /* Allocation fail */
 			}
 			*p = delimiter;
 			*src = p;
 		}
-		(*src)++; /* Skip delimiter, next field */
+		(*src)++; /* Skip delmiter, next field */
 	} else if ((len = strlen(*src))) {
 		/* No delimiter, item ends with '\0' */
-		if (!(*ptr = strdup(*src))) {
+		if (!(*ptr = dm_strdup(*src))) {
 			log_error("Failed to fetch last item %s.", *src);
 			ret = 0; /* Fail */
 		}
@@ -536,11 +538,11 @@ out:
 /* Free message memory. */
 static void _free_message(struct message_data *message_data)
 {
-	free(message_data->id);
-	free(message_data->dso_name);
-	free(message_data->device_uuid);
-	free(message_data->events_str);
-	free(message_data->timeout_str);
+	dm_free(message_data->id);
+	dm_free(message_data->dso_name);
+	dm_free(message_data->device_uuid);
+	dm_free(message_data->events_str);
+	dm_free(message_data->timeout_str);
 }
 
 /* Parse a register message from the client. */
@@ -572,7 +574,7 @@ static int _parse_message(struct message_data *message_data)
 		ret = 1;
 	}
 
-	free(msg->data);
+	dm_free(msg->data);
 	msg->data = NULL;
 
 	return ret;
@@ -606,8 +608,8 @@ static int _fill_device_data(struct thread_status *ts)
 	if (!dm_task_run(dmt))
 		goto fail;
 
-	free(ts->device.name);
-	if (!(ts->device.name = strdup(dm_task_get_name(dmt))))
+	dm_free(ts->device.name);
+	if (!(ts->device.name = dm_strdup(dm_task_get_name(dmt))))
 		goto fail;
 
 	if (!dm_task_get_info(dmt, &dmi))
@@ -676,9 +678,6 @@ static int _get_status(struct message_data *message_data)
 	char **buffers;
 	char *message;
 
-	if (!message_data->id)
-		return -EINVAL;
-
 	_lock_mutex();
 	count = dm_list_size(&_thread_registry);
 	buffers = alloca(sizeof(char*) * count);
@@ -697,8 +696,8 @@ static int _get_status(struct message_data *message_data)
 
 	len = strlen(message_data->id);
 	msg->size = size + len + 1;
-	free(msg->data);
-	if (!(msg->data = malloc(msg->size)))
+	dm_free(msg->data);
+	if (!(msg->data = dm_malloc(msg->size)))
 		goto out;
 
 	memcpy(msg->data, message_data->id, len);
@@ -713,7 +712,7 @@ static int _get_status(struct message_data *message_data)
 	ret = 0;
  out:
 	for (j = 0; j < i; ++j)
-		free(buffers[j]);
+		dm_free(buffers[j]);
 
 	return ret;
 }
@@ -721,18 +720,12 @@ static int _get_status(struct message_data *message_data)
 static int _get_parameters(struct message_data *message_data) {
 	struct dm_event_daemon_message *msg = message_data->msg;
 	int size;
-	char idle_buf[32] = "";
 
-	if (_idle_since)
-		(void)dm_snprintf(idle_buf, sizeof(idle_buf), " idle=%lu", (long unsigned) (time(NULL) - _idle_since));
-
-	free(msg->data);
-	if ((size = dm_asprintf(&msg->data, "%s pid=%d daemon=%s exec_method=%s exit_on=\"%s\"%s",
+	dm_free(msg->data);
+	if ((size = dm_asprintf(&msg->data, "%s pid=%d daemon=%s exec_method=%s",
 				message_data->id, getpid(),
 				_foreground ? "no" : "yes",
-				_systemd_activation ? "systemd" : "direct",
-				_exit_on,
-				idle_buf)) < 0) {
+				_systemd_activation ? "systemd" : "direct")) < 0) {
 		stack;
 		return -ENOMEM;
 	}
@@ -759,7 +752,7 @@ static void _exit_timeout(void *unused __attribute__((unused)))
 static void *_timeout_thread(void *unused __attribute__((unused)))
 {
 	struct thread_status *thread;
-	struct timespec timeout, real_time;
+	struct timespec timeout;
 	time_t curr_time;
 	int ret;
 
@@ -770,16 +763,7 @@ static void *_timeout_thread(void *unused __attribute__((unused)))
 	while (!dm_list_empty(&_timeout_registry)) {
 		timeout.tv_sec = 0;
 		timeout.tv_nsec = 0;
-#ifndef HAVE_REALTIME
 		curr_time = time(NULL);
-#else
-		if (clock_gettime(CLOCK_REALTIME, &real_time)) {
-			log_error("Failed to read clock_gettime().");
-			break;
-		}
-		/* 10ms back to the future */
-		curr_time = real_time.tv_sec + ((real_time.tv_nsec > (1000000000 - 10000000)) ? 1 : 0);
-#endif
 
 		dm_list_iterate_items_gen(thread, &_timeout_registry, timeout_list) {
 			if (thread->next_time <= curr_time) {
@@ -991,7 +975,6 @@ static void _monitor_unregister(void *arg)
 	DEBUGLOG("Unregistering monitor for %s.", thread->device.name);
 	_unregister_for_timeout(thread);
 
-	/* coverity[missing_lock] no missing lock here */
 	if ((thread->status != DM_THREAD_REGISTERING) &&
 	    !_do_unregister_device(thread))
 		log_error("%s: %s unregister failed.", __func__,
@@ -1002,8 +985,6 @@ static void _monitor_unregister(void *arg)
 	_lock_mutex();
 	thread->status = DM_THREAD_DONE; /* Last access to thread memory! */
 	_unlock_mutex();
-	if (_exit_now)  /* Exit is already in-progress, wake-up sleeping select() */
-		kill(getpid(), SIGINT);
 }
 
 /* Device monitoring thread. */
@@ -1050,9 +1031,9 @@ static void *_monitor_thread(void *arg)
 			_unlock_mutex();
 
 			_do_process_event(thread);
+			thread->current_events = 0; /* Current events processed */
 
 			_lock_mutex();
-			thread->current_events = 0; /* Current events processed */
 			thread->processing = 0;
 
 			/*
@@ -1082,7 +1063,6 @@ out:
 	 * "label at end of compound statement" */
 	;
 
-	/* coverity[lock_order] _global_mutex is kept locked */
 	pthread_cleanup_pop(1);
 
 	return NULL;
@@ -1168,36 +1148,6 @@ static int _unregister_for_event(struct message_data *message_data)
 	return ret;
 }
 
-static void _unregister_all_threads(void)
-{
-	struct thread_status *thread, *tmp;
-
-	_lock_mutex();
-
-	dm_list_iterate_items_safe(thread, tmp, &_thread_registry)
-		_update_events(thread, 0);
-
-	_unlock_mutex();
-}
-
-static void _wait_for_new_pid(void)
-{
-	unsigned long st_ino = 0;
-	struct stat st;
-	int i;
-
-	for (i = 0; i < 400000; ++i) {
-		if (lstat(DMEVENTD_PIDFILE, &st) == 0) {
-			if (!st_ino)
-				st_ino = st.st_ino;
-			else if (st_ino != st.st_ino)
-				break; /* different pidfile */
-		} else if (errno == ENOENT)
-			break; /* pidfile is removed */
-		usleep(100);
-	}
-}
-
 /*
  * Register for an event.
  *
@@ -1275,7 +1225,7 @@ static int _registered_device(struct message_data *message_data,
 	int r;
 	struct dm_event_daemon_message *msg = message_data->msg;
 
-	free(msg->data);
+	dm_free(msg->data);
 
 	if ((r = dm_asprintf(&(msg->data), "%s %s %s %u",
 			     message_data->id,
@@ -1415,7 +1365,7 @@ static int _get_timeout(struct message_data *message_data)
 	if (!thread)
 		return -ENODEV;
 
-	free(msg->data);
+	dm_free(msg->data);
 	msg->size = dm_asprintf(&(msg->data), "%s %" PRIu32,
 				message_data->id, thread->timeout);
 
@@ -1441,8 +1391,7 @@ static int _open_fifo(const char *path)
 	} else if (!S_ISFIFO(st.st_mode) || st.st_uid ||
 		   (st.st_mode & (S_IEXEC | S_IRWXG | S_IRWXO))) {
 		log_warn("WARNING: %s has wrong attributes: Replacing.", path);
-		/* coverity[toctou]  don't care, path is going to be recreated */
-		if (unlink(path) && (errno != ENOENT)) {
+		if (unlink(path)) {
 			log_sys_error("unlink", path);
 			return -1;
 		}
@@ -1450,7 +1399,6 @@ static int _open_fifo(const char *path)
 
 	/* Create fifo. */
 	(void) dm_prepare_selinux_context(path, S_IFIFO);
-	/* coverity[toctou]  revalidating things again */
 	if ((mkfifo(path, 0600) == -1) && errno != EEXIST) {
 		log_sys_error("mkfifo", path);
 		(void) dm_prepare_selinux_context(NULL, 0);
@@ -1537,34 +1485,37 @@ static int _client_read(struct dm_event_fifos *fifos,
 		t.tv_usec = 0;
 		ret = select(fifos->client + 1, &fds, NULL, NULL, &t);
 
-		if (!ret && bytes)
-			continue; /* trying to finish read */
+		if (!ret && !bytes)	/* nothing to read */
+			return 0;
 
-		if (ret <= 0)	/* nothing to read */
-			goto bad;
+		if (!ret)	/* trying to finish read */
+			continue;
+
+		if (ret < 0)	/* error */
+			return 0;
 
 		ret = read(fifos->client, buf + bytes, size - bytes);
 		bytes += ret > 0 ? ret : 0;
-		if (!msg->data && (bytes == 2 * sizeof(uint32_t))) {
+		if (header && (bytes == 2 * sizeof(uint32_t))) {
 			msg->cmd = ntohl(header[0]);
+			size = msg->size = ntohl(header[1]);
 			bytes = 0;
-
-			if (!(size = msg->size = ntohl(header[1])))
-				break;
-
-			if (!(buf = msg->data = malloc(msg->size)))
-				goto bad;
+			if (!size)
+				break; /* No data -> error */
+			buf = msg->data = dm_malloc(msg->size);
+			if (!buf)
+				break; /* No mem -> error */
+			header = 0;
 		}
 	}
 
-	if (bytes == size)
-		return 1;
+	if (bytes != size) {
+		dm_free(msg->data);
+		msg->data = NULL;
+		return 0;
+	}
 
-bad:
-	free(msg->data);
-	msg->data = NULL;
-
-	return 0;
+	return 1;
 }
 
 /*
@@ -1579,7 +1530,7 @@ static int _client_write(struct dm_event_fifos *fifos,
 	fd_set fds;
 
 	size_t size = 2 * sizeof(uint32_t) + ((msg->data) ? msg->size : 0);
-	uint32_t *header = malloc(size);
+	uint32_t *header = dm_malloc(size);
 	char *buf = (char *)header;
 
 	if (!header) {
@@ -1609,7 +1560,7 @@ static int _client_write(struct dm_event_fifos *fifos,
 	}
 
 	if (header != temp)
-		free(header);
+		dm_free(header);
 
 	return (bytes == size);
 }
@@ -1671,7 +1622,7 @@ static int _do_process_request(struct dm_event_daemon_message *msg)
 			msg->size = dm_asprintf(&(msg->data), "%s %s %d", answer,
 						(msg->cmd == DM_EVENT_CMD_DIE) ? "DYING" : "HELLO",
 						DM_EVENT_PROTOCOL_VERSION);
-			free(answer);
+			dm_free(answer);
 		}
 	} else if (msg->cmd != DM_EVENT_CMD_ACTIVE && !_parse_message(&message_data)) {
 		stack;
@@ -1679,7 +1630,7 @@ static int _do_process_request(struct dm_event_daemon_message *msg)
 	} else
 		ret = _handle_request(msg, &message_data);
 
-	msg->cmd = (uint32_t)ret;
+	msg->cmd = ret;
 	if (!msg->data)
 		msg->size = dm_asprintf(&(msg->data), "%s %s", message_data.id, strerror(-ret));
 
@@ -1713,12 +1664,12 @@ static void _process_request(struct dm_event_fifos *fifos)
 
 	DEBUGLOG("<<< CMD:%s (0x%x) completed (result %d).", decode_cmd(cmd), cmd, msg.cmd);
 
-	free(msg.data);
+	dm_free(msg.data);
 
 	if (cmd == DM_EVENT_CMD_DIE) {
-		_unregister_all_threads();
-		_exit_now = DM_SCHEDULED_EXIT;
-		log_info("dmeventd exiting for restart.");
+		if (unlink(DMEVENTD_PIDFILE))
+			log_sys_error("unlink", DMEVENTD_PIDFILE);
+		_exit(0);
 	}
 }
 
@@ -1765,7 +1716,7 @@ static void _cleanup_unused_threads(void)
 		DEBUGLOG("Destroying Thr %x.", (int)thread->thread);
 
 		if (pthread_join(thread->thread, NULL))
-			log_sys_debug("pthread_join", "");
+			log_sys_error("pthread_join", "");
 
 		_free_thread_status(thread);
 		_lock_mutex();
@@ -1785,8 +1736,7 @@ static void _init_thread_signals(void)
 	sigset_t my_sigset;
 	struct sigaction act = { .sa_handler = _sig_alarm };
 
-	if (sigaction(SIGALRM, &act, NULL))
-		log_sys_debug("sigaction", "SIGLARM");
+	sigaction(SIGALRM, &act, NULL);
 	sigfillset(&my_sigset);
 
 	/* These are used for exiting */
@@ -1795,8 +1745,7 @@ static void _init_thread_signals(void)
 	sigdelset(&my_sigset, SIGHUP);
 	sigdelset(&my_sigset, SIGQUIT);
 
-	if (pthread_sigmask(SIG_BLOCK, &my_sigset, NULL))
-		log_sys_debug("pthread_sigmask", "SIG_BLOCK");
+	pthread_sigmask(SIG_BLOCK, &my_sigset, NULL);
 }
 
 /*
@@ -1808,8 +1757,7 @@ static void _init_thread_signals(void)
  */
 static void _exit_handler(int sig __attribute__((unused)))
 {
-	if (!_exit_now)
-		_exit_now = DM_SIGNALED_EXIT;
+	_exit_now = DM_SIGNALED_EXIT;
 }
 
 #ifdef __linux__
@@ -1825,7 +1773,7 @@ static int _set_oom_adj(const char *oom_adj_path, int val)
 	fprintf(fp, "%i", val);
 
 	if (dm_fclose(fp))
-		log_sys_debug("fclose", oom_adj_path);
+		log_sys_error("fclose", oom_adj_path);
 
 	return 1;
 }
@@ -1839,11 +1787,11 @@ static int _protect_against_oom_killer(void)
 
 	if (stat(OOM_ADJ_FILE, &st) == -1) {
 		if (errno != ENOENT)
-			log_sys_debug("stat", OOM_ADJ_FILE);
+			log_sys_error("stat", OOM_ADJ_FILE);
 
 		/* Try old oom_adj interface as a fallback */
 		if (stat(OOM_ADJ_FILE_OLD, &st) == -1) {
-			log_sys_debug("stat", OOM_ADJ_FILE_OLD);
+			log_sys_error("stat", OOM_ADJ_FILE_OLD);
 			return 1;
 		}
 
@@ -1931,30 +1879,26 @@ out:
 
 static void _remove_files_on_exit(void)
 {
-	if (unlink(DMEVENTD_PIDFILE) && (errno != ENOENT))
-		log_sys_debug("unlink", DMEVENTD_PIDFILE);
+	if (unlink(DMEVENTD_PIDFILE))
+		log_sys_error("unlink", DMEVENTD_PIDFILE);
 
 	if (!_systemd_activation) {
-		if (unlink(DM_EVENT_FIFO_CLIENT) && (errno != ENOENT))
-			log_sys_debug("unlink", DM_EVENT_FIFO_CLIENT);
+		if (unlink(DM_EVENT_FIFO_CLIENT))
+			log_sys_error("unlink", DM_EVENT_FIFO_CLIENT);
 
-		if (unlink(DM_EVENT_FIFO_SERVER) && (errno != ENOENT))
-			log_sys_debug("unlink", DM_EVENT_FIFO_SERVER);
+		if (unlink(DM_EVENT_FIFO_SERVER))
+			log_sys_error("unlink", DM_EVENT_FIFO_SERVER);
 	}
 }
 
 static void _daemonize(void)
 {
-	int child_status, null_fd;
+	int child_status;
+	int fd;
 	pid_t pid;
+	struct rlimit rlim;
 	struct timeval tval;
 	sigset_t my_sigset;
-	struct custom_fds custom_fds = {
-		/* Do not close fds preloaded by systemd! */
-		.out = (_systemd_activation) ? SD_FD_FIFO_SERVER : -1,
-		.err = -1,
-		.report = (_systemd_activation) ? SD_FD_FIFO_CLIENT : -1,
-	};
 
 	sigemptyset(&my_sigset);
 	if (sigprocmask(SIG_SETMASK, &my_sigset, NULL) < 0) {
@@ -1998,35 +1942,40 @@ static void _daemonize(void)
 	if (chdir("/"))
 		exit(EXIT_CHDIR_FAILURE);
 
-	daemon_close_stray_fds("dmeventd", 0, -1, &custom_fds);
+	if (getrlimit(RLIMIT_NOFILE, &rlim) < 0)
+		fd = 256;	/* just have to guess */
+	else
+		fd = rlim.rlim_cur;
 
-	if ((null_fd = open("/dev/null", O_RDWR)) < 0)
+	for (--fd; fd >= 0; fd--) {
+#ifdef __linux__
+		/* Do not close fds preloaded by systemd! */
+		if (_systemd_activation &&
+		    (fd == SD_FD_FIFO_SERVER || fd == SD_FD_FIFO_CLIENT))
+			continue;
+#endif
+		(void) close(fd);
+	}
+
+	if ((open("/dev/null", O_RDONLY) < 0) ||
+	    (open("/dev/null", O_WRONLY) < 0) ||
+	    (open("/dev/null", O_WRONLY) < 0))
 		exit(EXIT_DESC_OPEN_FAILURE);
 
-	if ((dup2(null_fd, STDIN_FILENO) == -1) ||
-	    (dup2(null_fd, STDOUT_FILENO) == -1) ||
-	    (dup2(null_fd, STDERR_FILENO) == -1))
-		exit(EXIT_DESC_OPEN_FAILURE);
-
-	if ((null_fd > STDERR_FILENO) && close(null_fd))
-		exit(EXIT_DESC_CLOSE_FAILURE);
-
 	setsid();
-
-	/* coverity[leaked_handle] 'null_fd' handle is not leaking */
 }
 
 static int _reinstate_registrations(struct dm_event_fifos *fifos)
 {
 	static const char _failed_parsing_msg[] = "Failed to parse existing event registration.\n";
-	static const char _delim[] = " ";
+	static const char *_delim = " ";
 	struct dm_event_daemon_message msg = { 0 };
 	char *endp, *dso_name, *dev_name, *mask, *timeout;
 	unsigned long mask_value, timeout_value;
 	int i, ret;
 
 	ret = daemon_talk(fifos, &msg, DM_EVENT_CMD_HELLO, NULL, NULL, 0, 0);
-	free(msg.data);
+	dm_free(msg.data);
 	msg.data = NULL;
 
 	if (ret) {
@@ -2069,94 +2018,28 @@ static int _reinstate_registrations(struct dm_event_fifos *fifos)
 	return 1;
 }
 
-static int _info_dmeventd(const char *name, struct dm_event_fifos *fifos)
-{
-	struct dm_event_daemon_message msg = { 0 };
-	int i, count = 0;
-	char *line;
-	int version;
-	int ret = 0;
-
-	if (!dm_daemon_is_running(DMEVENTD_PIDFILE)) {
-		fprintf(stderr, "No running dmeventd instance for status query.\n");
-		return 0;
-	}
-
-	/* Get the list of registrations from the running daemon. */
-	if (!init_fifos(fifos)) {
-		fprintf(stderr, "Could not initiate communication with existing dmeventd.\n");
-		return 0;
-	}
-
-	if (!dm_event_get_version(fifos, &version)) {
-		fprintf(stderr, "Could not communicate with existing dmeventd.\n");
-		goto out;
-	}
-
-	if (version < 1) {
-		fprintf(stderr, "The running dmeventd instance is too old.\n"
-			"Protocol version %d (required: 1). Action cancelled.\n", version);
-		goto out;
-	}
-
-	if (daemon_talk(fifos, &msg, DM_EVENT_CMD_GET_STATUS, "-", "-", 0, 0)) {
-		fprintf(stderr, "Failed to acquire status from existing dmeventd.\n");
-		goto out;
-	}
-
-	line = strchr(msg.data, ' ') + 1;
-	for (i = 0; msg.data[i]; ++i)
-		if (msg.data[i] == ';') {
-			msg.data[i] = 0;
-			if (!count)
-				printf("%s is monitoring:\n", name);
-			printf("%s\n", line);
-			line = msg.data + i + 1;
-			++count;
-		}
-
-	free(msg.data);
-
-	if (!count)
-		printf("%s does not monitor any device.\n", name);
-
-	if (version >= 2) {
-		if (daemon_talk(fifos, &msg, DM_EVENT_CMD_GET_PARAMETERS, "-", "-", 0, 0)) {
-			fprintf(stderr, "Failed to acquire parameters from existing dmeventd.\n");
-			goto out;
-		}
-		printf("%s internal status: %s\n", name, msg.data);
-		free(msg.data);
-	}
-
-	ret = 1;
-out:
-	fini_fifos(fifos);
-
-	return ret;
-}
-
-/* Return   0 - fail, 1 - success, 2 - continue */
-static int _restart_dmeventd(struct dm_event_fifos *fifos)
+static void _restart_dmeventd(void)
 {
+	struct dm_event_fifos fifos = {
+		.server = -1,
+		.client = -1,
+		/* FIXME Make these either configurable or depend directly on dmeventd_path */
+		.client_path = DM_EVENT_FIFO_CLIENT,
+		.server_path = DM_EVENT_FIFO_SERVER
+	};
 	struct dm_event_daemon_message msg = { 0 };
 	int i, count = 0;
 	char *message;
 	int version;
 	const char *e;
 
-	if (!dm_daemon_is_running(DMEVENTD_PIDFILE)) {
-		fprintf(stderr, "WARNING: Could not find running dmeventd associated with pid file %s.\n", DMEVENTD_PIDFILE);
-		return 0;
-	}
-
 	/* Get the list of registrations from the running daemon. */
-	if (!init_fifos(fifos)) {
+	if (!init_fifos(&fifos)) {
 		fprintf(stderr, "WARNING: Could not initiate communication with existing dmeventd.\n");
-		return 0;
+		exit(EXIT_FAILURE);
 	}
 
-	if (!dm_event_get_version(fifos, &version)) {
+	if (!dm_event_get_version(&fifos, &version)) {
 		fprintf(stderr, "WARNING: Could not communicate with existing dmeventd.\n");
 		goto bad;
 	}
@@ -2168,7 +2051,7 @@ static int _restart_dmeventd(struct dm_event_fifos *fifos)
 		goto bad;
 	}
 
-	if (daemon_talk(fifos, &msg, DM_EVENT_CMD_GET_STATUS, "-", "-", 0, 0))
+	if (daemon_talk(&fifos, &msg, DM_EVENT_CMD_GET_STATUS, "-", "-", 0, 0))
 		goto bad;
 
 	message = strchr(msg.data, ' ') + 1;
@@ -2178,21 +2061,22 @@ static int _restart_dmeventd(struct dm_event_fifos *fifos)
 			++count;
 		}
 
-	if (!(_initial_registrations = zalloc(sizeof(char*) * (count + 1)))) {
+	if (!(_initial_registrations = dm_malloc(sizeof(char*) * (count + 1)))) {
 		fprintf(stderr, "Memory allocation registration failed.\n");
 		goto bad;
 	}
 
 	for (i = 0; i < count; ++i) {
-		if (!(_initial_registrations[i] = strdup(message))) {
+		if (!(_initial_registrations[i] = dm_strdup(message))) {
 			fprintf(stderr, "Memory allocation for message failed.\n");
 			goto bad;
 		}
 		message += strlen(message) + 1;
 	}
+	_initial_registrations[count] = NULL;
 
 	if (version >= 2) {
-		if (daemon_talk(fifos, &msg, DM_EVENT_CMD_GET_PARAMETERS, "-", "-", 0, 0)) {
+		if (daemon_talk(&fifos, &msg, DM_EVENT_CMD_GET_PARAMETERS, "-", "-", 0, 0)) {
 			fprintf(stderr, "Failed to acquire parameters from old dmeventd.\n");
 			goto bad;
 		}
@@ -2212,7 +2096,7 @@ static int _restart_dmeventd(struct dm_event_fifos *fifos)
 	}
 #endif
 
-	if (daemon_talk(fifos, &msg, DM_EVENT_CMD_DIE, "-", "-", 0, 0)) {
+	if (daemon_talk(&fifos, &msg, DM_EVENT_CMD_DIE, "-", "-", 0, 0)) {
 		fprintf(stderr, "Old dmeventd refused to die.\n");
 		goto bad;
 	}
@@ -2221,41 +2105,43 @@ static int _restart_dmeventd(struct dm_event_fifos *fifos)
 	    ((e = getenv(SD_ACTIVATION_ENV_VAR_NAME)) && strcmp(e, "1")))
 		_systemd_activation = 1;
 
-	fini_fifos(fifos);
-
-	/* Give a few seconds dmeventd to finish */
-	_wait_for_new_pid();
-
-	if (!_systemd_activation)
-		return 2; // continue with dmeventd start up
-
-	/* Reopen fifos. */
-	if (!init_fifos(fifos)) {
-		fprintf(stderr, "Could not initiate communication with new instance of dmeventd.\n");
-		return 0;
+	for (i = 0; i < 10; ++i) {
+		if ((access(DMEVENTD_PIDFILE, F_OK) == -1) && (errno == ENOENT))
+			break;
+		usleep(10);
 	}
 
-	if (!_reinstate_registrations(fifos)) {
+	if (!_systemd_activation) {
+		fini_fifos(&fifos);
+		return;
+	}
+
+	/* Reopen fifos. */
+	fini_fifos(&fifos);
+	if (!init_fifos(&fifos)) {
+		fprintf(stderr, "Could not initiate communication with new instance of dmeventd.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	if (!_reinstate_registrations(&fifos)) {
 		fprintf(stderr, "Failed to reinstate monitoring with new instance of dmeventd.\n");
 		goto bad;
 	}
 
-	fini_fifos(fifos);
-	return 1;
+	fini_fifos(&fifos);
+	exit(EXIT_SUCCESS);
 bad:
-	fini_fifos(fifos);
-	return 0;
+	fini_fifos(&fifos);
+	exit(EXIT_FAILURE);
 }
 
 static void _usage(char *prog, FILE *file)
 {
 	fprintf(file, "Usage:\n"
-		"%s [-d [-d [-d]]] [-e path] [-f] [-h] [i] [-l] [-R] [-V] [-?]\n\n"
+		"%s [-d [-d [-d]]] [-f] [-h] [-l] [-R] [-V] [-?]\n\n"
 		"   -d       Log debug messages to syslog (-d, -dd, -ddd)\n"
-		"   -e       Select a file path checked on exit\n"
 		"   -f       Don't fork, run in the foreground\n"
 		"   -h       Show this help information\n"
-		"   -i       Query running instance of dmeventd for info\n"
 		"   -l       Log to stdout,stderr instead of syslog\n"
 		"   -?       Show this help information on stderr\n"
 		"   -R       Restart dmeventd\n"
@@ -2265,10 +2151,6 @@ static void _usage(char *prog, FILE *file)
 int main(int argc, char *argv[])
 {
 	signed char opt;
-	int debug_level = 0;
-	int info = 0;
-	int restart = 0;
-	int use_syslog = 1;
 	struct dm_event_fifos fifos = {
 		.client = -1,
 		.server = -1,
@@ -2276,58 +2158,39 @@ int main(int argc, char *argv[])
 		.server_path = DM_EVENT_FIFO_SERVER
 	};
 	time_t now, idle_exit_timeout = DMEVENTD_IDLE_EXIT_TIMEOUT;
+	opterr = 0;
+	optind = 0;
 
-	optopt = optind = opterr = 0;
-	optarg = (char*) "";
-	while ((opt = getopt(argc, argv, ":?e:fhiVdlR")) != EOF) {
+	while ((opt = getopt(argc, argv, "?fhVdlR")) != EOF) {
 		switch (opt) {
 		case 'h':
 			_usage(argv[0], stdout);
-			return EXIT_SUCCESS;
+			exit(EXIT_SUCCESS);
 		case '?':
 			_usage(argv[0], stderr);
-			return EXIT_SUCCESS;
-		case 'i':
-			info++;
-			break;
+			exit(EXIT_SUCCESS);
 		case 'R':
-			restart++;
-			break;
-		case 'e':
-			if (strchr(optarg, '"')) {
-				fprintf(stderr, "dmeventd: option -e does not accept path \"%s\" with '\"' character.\n", optarg);
-				return EXIT_FAILURE;
-			}
-			_exit_on=optarg;
+			_restart++;
 			break;
 		case 'f':
 			_foreground++;
 			break;
 		case 'd':
-			debug_level++;
+			_debug_level++;
 			break;
 		case 'l':
-			use_syslog = 0;
+			_use_syslog = 0;
 			break;
 		case 'V':
 			printf("dmeventd version: %s\n", DM_LIB_VERSION);
-			return EXIT_SUCCESS;
-		case ':':
-			fprintf(stderr, "dmeventd: option -%c requires an argument.\n", optopt);
-			return EXIT_FAILURE;
+			exit(EXIT_SUCCESS);
 		}
 	}
 
-	if (info) {
-		_foreground = 1;
-		use_syslog = 0;
-	}
-
-	if (!_foreground && !use_syslog) {
+	if (!_foreground && !_use_syslog) {
 		printf("WARNING: Ignoring logging to stdout, needs options -f\n");
-		use_syslog = 1;
+		_use_syslog = 1;
 	}
-
 	/*
 	 * Switch to C locale to avoid reading large locale-archive file
 	 * used by some glibc (on some distributions it takes over 100MB).
@@ -2336,29 +2199,21 @@ int main(int argc, char *argv[])
 	if (setenv("LC_ALL", "C", 1))
 		perror("Cannot set LC_ALL to C");
 
-	if (info)
-		return _info_dmeventd(argv[0], &fifos) ? EXIT_SUCCESS : EXIT_FAILURE;
+	if (_restart)
+		_restart_dmeventd();
 
 #ifdef __linux__
 	_systemd_activation = _systemd_handover(&fifos);
 #endif
 
-	dm_log_with_errno_init(_libdm_log);
-
-	if (restart) {
-		dm_event_log_set(debug_level, 0);
-
-		if ((restart = _restart_dmeventd(&fifos)) < 2)
-			return restart ? EXIT_SUCCESS : EXIT_FAILURE;
-	}
-
 	if (!_foreground)
 		_daemonize();
 
-	if (use_syslog)
+	if (_use_syslog)
 		openlog("dmeventd", LOG_PID, LOG_DAEMON);
 
-	dm_event_log_set(debug_level, use_syslog);
+	dm_event_log_set(_debug_level, _use_syslog);
+	dm_log_with_errno_init(_libdm_log);
 
 	(void) dm_prepare_selinux_context(DMEVENTD_PIDFILE, S_IFREG);
 	if (dm_create_lockfile(DMEVENTD_PIDFILE) == 0)
@@ -2381,8 +2236,7 @@ int main(int argc, char *argv[])
 
 	_init_thread_signals();
 
-	if (pthread_mutex_init(&_global_mutex, NULL))
-		exit(EXIT_FAILURE);
+	pthread_mutex_init(&_global_mutex, NULL);
 
 	if (!_systemd_activation && !_open_fifos(&fifos))
 		exit(EXIT_FIFO_FAILURE);
@@ -2419,28 +2273,15 @@ int main(int argc, char *argv[])
 					break;
 				}
 			}
-		} else
-			switch (_exit_now) {
-			case DM_SIGNALED_EXIT:
-				_exit_now = DM_SCHEDULED_EXIT;
-				/*
-				 * When '_exit_now' is set, signal has been received,
-				 * but can not simply exit unless all
-				 * threads are done processing.
-				 */
-				log_info("dmeventd received break, scheduling exit.");
-				/* fall through */
-			case DM_SCHEDULED_EXIT:
-				/* While exit is scheduled, check for exit_on file */
-				DEBUGLOG("Checking exit on file \"%s\".", _exit_on);
-				if (_exit_on[0] && (access(_exit_on, F_OK) == 0)) {
-					log_info("dmeventd detected exit on file %s, unregistering all monitored devices.",
-						 _exit_on);
-					_unregister_all_threads();
-				}
-				break;
-			}
-
+		} else if (_exit_now == DM_SIGNALED_EXIT) {
+			_exit_now = DM_SCHEDULED_EXIT;
+			/*
+			 * When '_exit_now' is set, signal has been received,
+			 * but can not simply exit unless all
+			 * threads are done processing.
+			 */
+			log_info("dmeventd received break, scheduling exit.");
+		}
 		_process_request(&fifos);
 		_cleanup_unused_threads();
 	}
@@ -2450,11 +2291,11 @@ int main(int argc, char *argv[])
 	log_notice("dmeventd shutting down.");
 
 	if (fifos.client >= 0 && close(fifos.client))
-		log_sys_debug("client close", fifos.client_path);
+		log_sys_error("client close", fifos.client_path);
 	if (fifos.server >= 0 && close(fifos.server))
-		log_sys_debug("server close", fifos.server_path);
+		log_sys_error("server close", fifos.server_path);
 
-	if (use_syslog)
+	if (_use_syslog)
 		closelog();
 
 	_exit_dm_lib();

daemons/dmeventd/dmeventd.h

@@ -15,8 +15,6 @@
 #ifndef __DMEVENTD_DOT_H__
 #define __DMEVENTD_DOT_H__
 
-#include <stdint.h>
-
 /* FIXME This stuff must be configurable. */
 
 #define	DM_EVENT_FIFO_CLIENT	DEFAULT_DM_RUN_DIR "/dmeventd-client"
@@ -70,7 +68,7 @@ struct dm_event_fifos {
 int daemon_talk(struct dm_event_fifos *fifos,
 		struct dm_event_daemon_message *msg, int cmd,
 		const char *dso_name, const char *dev_name,
-		unsigned evmask, uint32_t timeout);
+		enum dm_event_mask evmask, uint32_t timeout);
 int init_fifos(struct dm_event_fifos *fifos);
 void fini_fifos(struct dm_event_fifos *fifos);
 int dm_event_get_version(struct dm_event_fifos *fifos, int *version);

daemons/dmeventd/libdevmapper-event.c

@@ -12,12 +12,10 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "dm-logging.h"
+#include "dmlib.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>
 #include <sys/file.h>
@@ -27,7 +25,6 @@
 #include <arpa/inet.h>		/* for htonl, ntohl */
 #include <pthread.h>
 #include <syslog.h>
-#include <unistd.h>
 
 static int _debug_level = 0;
 static int _use_syslog = 0;
@@ -50,8 +47,8 @@ struct dm_event_handler {
 
 static void _dm_event_handler_clear_dev_info(struct dm_event_handler *dmevh)
 {
-	free(dmevh->dev_name);
-	free(dmevh->uuid);
+	dm_free(dmevh->dev_name);
+	dm_free(dmevh->uuid);
 	dmevh->dev_name = dmevh->uuid = NULL;
 	dmevh->major = dmevh->minor = 0;
 }
@@ -60,7 +57,7 @@ struct dm_event_handler *dm_event_handler_create(void)
 {
 	struct dm_event_handler *dmevh;
 
-	if (!(dmevh = zalloc(sizeof(*dmevh)))) {
+	if (!(dmevh = dm_zalloc(sizeof(*dmevh)))) {
 		log_error("Failed to allocate event handler.");
 		return NULL;
 	}
@@ -71,9 +68,9 @@ struct dm_event_handler *dm_event_handler_create(void)
 void dm_event_handler_destroy(struct dm_event_handler *dmevh)
 {
 	_dm_event_handler_clear_dev_info(dmevh);
-	free(dmevh->dso);
-	free(dmevh->dmeventd_path);
-	free(dmevh);
+	dm_free(dmevh->dso);
+	dm_free(dmevh->dmeventd_path);
+	dm_free(dmevh);
 }
 
 int dm_event_handler_set_dmeventd_path(struct dm_event_handler *dmevh, const char *dmeventd_path)
@@ -81,9 +78,9 @@ int dm_event_handler_set_dmeventd_path(struct dm_event_handler *dmevh, const cha
 	if (!dmeventd_path) /* noop */
 		return 0;
 
-	free(dmevh->dmeventd_path);
+	dm_free(dmevh->dmeventd_path);
 
-	if (!(dmevh->dmeventd_path = strdup(dmeventd_path)))
+	if (!(dmevh->dmeventd_path = dm_strdup(dmeventd_path)))
 		return -ENOMEM;
 
 	return 0;
@@ -94,9 +91,9 @@ int dm_event_handler_set_dso(struct dm_event_handler *dmevh, const char *path)
 	if (!path) /* noop */
 		return 0;
 
-	free(dmevh->dso);
+	dm_free(dmevh->dso);
 
-	if (!(dmevh->dso = strdup(path)))
+	if (!(dmevh->dso = dm_strdup(path)))
 		return -ENOMEM;
 
 	return 0;
@@ -109,7 +106,7 @@ int dm_event_handler_set_dev_name(struct dm_event_handler *dmevh, const char *de
 
 	_dm_event_handler_clear_dev_info(dmevh);
 
-	if (!(dmevh->dev_name = strdup(dev_name)))
+	if (!(dmevh->dev_name = dm_strdup(dev_name)))
 		return -ENOMEM;
 
 	return 0;
@@ -122,7 +119,7 @@ int dm_event_handler_set_uuid(struct dm_event_handler *dmevh, const char *uuid)
 
 	_dm_event_handler_clear_dev_info(dmevh);
 
-	if (!(dmevh->uuid = strdup(uuid)))
+	if (!(dmevh->uuid = dm_strdup(uuid)))
 		return -ENOMEM;
 
 	return 0;
@@ -237,16 +234,16 @@ static int _daemon_read(struct dm_event_fifos *fifos,
 			ret = select(fifos->server + 1, &fds, NULL, NULL, &tval);
 			if (ret < 0 && errno != EINTR) {
 				log_error("Unable to read from event server.");
-				goto bad;
+				return 0;
 			}
 			if ((ret == 0) && (i > 4) && !bytes) {
 				log_error("No input from event server.");
-				goto bad;
+				return 0;
 			}
 		}
 		if (ret < 1) {
 			log_error("Unable to read from event server.");
-			goto bad;
+			return 0;
 		}
 
 		ret = read(fifos->server, buf + bytes, size);
@@ -255,32 +252,25 @@ static int _daemon_read(struct dm_event_fifos *fifos,
 				continue;
 
 			log_error("Unable to read from event server.");
-			goto bad;
+			return 0;
 		}
 
 		bytes += ret;
-		if (!msg->data && (bytes == 2 * sizeof(uint32_t))) {
+		if (header && (bytes == 2 * sizeof(uint32_t))) {
 			msg->cmd = ntohl(header[0]);
+			msg->size = ntohl(header[1]);
+			buf = msg->data = dm_malloc(msg->size);
+			size = msg->size;
 			bytes = 0;
-
-			if (!(size = msg->size = ntohl(header[1])))
-				break;
-
-			if (!(buf = msg->data = malloc(msg->size))) {
-				log_error("Unable to allocate message data.");
-				return 0;
-			}
+			header = 0;
 		}
 	}
 
-	if (bytes == size)
-		return 1;
-
-bad:
-	free(msg->data);
-	msg->data = NULL;
-
-	return 0;
+	if (bytes != size) {
+		dm_free(msg->data);
+		msg->data = NULL;
+	}
+	return bytes == size;
 }
 
 /* Write message to daemon. */
@@ -352,7 +342,7 @@ static int _daemon_write(struct dm_event_fifos *fifos,
 int daemon_talk(struct dm_event_fifos *fifos,
 		struct dm_event_daemon_message *msg, int cmd,
 		const char *dso_name, const char *dev_name,
-		unsigned evmask, uint32_t timeout)
+		enum dm_event_mask evmask, uint32_t timeout)
 {
 	int msg_size;
 	memset(msg, 0, sizeof(*msg));
@@ -380,13 +370,13 @@ int daemon_talk(struct dm_event_fifos *fifos,
 	 */
 	if (!_daemon_write(fifos, msg)) {
 		stack;
-		free(msg->data);
+		dm_free(msg->data);
 		msg->data = NULL;
 		return -EIO;
 	}
 
 	do {
-		free(msg->data);
+		dm_free(msg->data);
 		msg->data = NULL;
 
 		if (!_daemon_read(fifos, msg)) {
@@ -400,16 +390,25 @@ int daemon_talk(struct dm_event_fifos *fifos,
 	return (int32_t) msg->cmd;
 }
 
-
 /*
- * Check for usable client fifo file
+ * start_daemon
  *
- * Returns: 2 client path does not exists, dmeventd should be restarted
- *          1 on success, 0 otherwise
+ * This function forks off a process (dmeventd) that will handle
+ * the events.  I am currently test opening one of the fifos to
+ * ensure that the daemon is running and listening...  I thought
+ * this would be less expensive than fork/exec'ing every time.
+ * Perhaps there is an even quicker/better way (no, checking the
+ * lock file is _not_ a better way).
+ *
+ * Returns: 1 on success, 0 otherwise
  */
-static int _check_for_usable_fifos(char *dmeventd_path, struct dm_event_fifos *fifos)
+static int _start_daemon(char *dmeventd_path, struct dm_event_fifos *fifos)
 {
+	int pid, ret = 0;
+	int status;
 	struct stat statbuf;
+	char default_dmeventd_path[] = DMEVENTD_PATH;
+	char *args[] = { dmeventd_path ? : default_dmeventd_path, NULL };
 
 	/*
 	 * FIXME Explicitly verify the code's requirement that client_path is secure:
@@ -420,7 +419,7 @@ static int _check_for_usable_fifos(char *dmeventd_path, struct dm_event_fifos *f
 	if ((lstat(fifos->client_path, &statbuf) < 0)) {
 		if (errno == ENOENT)
 			/* Jump ahead if fifo does not already exist. */
-			return 2;
+			goto start_server;
 		else {
 			log_sys_error("stat", fifos->client_path);
 			return 0;
@@ -446,14 +445,12 @@ static int _check_for_usable_fifos(char *dmeventd_path, struct dm_event_fifos *f
 			log_error("%s is no longer a secure root-owned fifo with mode 0600.", fifos->client_path);
 			if (close(fifos->client))
 				log_sys_debug("close", fifos->client_path);
-			fifos->client = -1;
 			return 0;
 		}
 
 		/* server is running and listening */
 		if (close(fifos->client))
 			log_sys_debug("close", fifos->client_path);
-		fifos->client = -1;
 		return 1;
 	}
 	if (errno != ENXIO && errno != ENOENT)  {
@@ -462,36 +459,9 @@ static int _check_for_usable_fifos(char *dmeventd_path, struct dm_event_fifos *f
 		return 0;
 	}
 
-	return 2;
-}
-
-
-/*
- * start_daemon
- *
- * This function forks off a process (dmeventd) that will handle
- * the events.  I am currently test opening one of the fifos to
- * ensure that the daemon is running and listening...  I thought
- * this would be less expensive than fork/exec'ing every time.
- * Perhaps there is an even quicker/better way (no, checking the
- * lock file is _not_ a better way).
- *
- * Returns: 1 on success, 0 otherwise
- */
-static int _start_daemon(char *dmeventd_path, struct dm_event_fifos *fifos)
-{
-	struct stat statbuf;
-	char default_dmeventd_path[] = DMEVENTD_PATH;
-	char *args[] = { dmeventd_path ? : default_dmeventd_path, NULL };
-	int pid, ret = 0;
-	int status;
-
-	switch (_check_for_usable_fifos(dmeventd_path, fifos)) {
-	case 0: return_0;
-	case 1: return 1; /* Already running dmeventd */
-	}
-
+start_server:
 	/* server is not running */
+
 	if ((args[0][0] == '/') && stat(args[0], &statbuf)) {
 		log_sys_error("stat", args[0]);
 		return 0;
@@ -512,17 +482,8 @@ static int _start_daemon(char *dmeventd_path, struct dm_event_fifos *fifos)
 				  strerror(errno));
 		else if (WEXITSTATUS(status))
 			log_error("Unable to start dmeventd.");
-		else {
-			/* Loop here till forked dmeventd is serving fifos */
-			for (ret = 100; ret > 0; --ret)
-				switch (_check_for_usable_fifos(dmeventd_path, fifos)) {
-				case 0: return_0;
-				case 1: return 1;
-				case 2: usleep(1000); break;
-				}
-			/* ret == 0 */
-			log_error("Dmeventd is not serving fifos.");
-		}
+		else
+			ret = 1;
 	}
 
 	return ret;
@@ -542,7 +503,7 @@ int init_fifos(struct dm_event_fifos *fifos)
 	/* Lock out anyone else trying to do communication with the daemon. */
 	if (flock(fifos->server, LOCK_EX) < 0) {
 		log_sys_error("flock", fifos->server_path);
-		goto bad_no_unlock;
+		goto bad;
 	}
 
 /*	if ((fifos->client = open(fifos->client_path, O_WRONLY | O_NONBLOCK)) < 0) {*/
@@ -553,9 +514,6 @@ int init_fifos(struct dm_event_fifos *fifos)
 
 	return 1;
 bad:
-	if (flock(fifos->server, LOCK_UN))
-		log_sys_debug("flock unlock", fifos->server_path);
-bad_no_unlock:
 	if (close(fifos->server))
 		log_sys_debug("close", fifos->server_path);
 	fifos->server = -1;
@@ -584,8 +542,6 @@ void fini_fifos(struct dm_event_fifos *fifos)
 		if (close(fifos->server))
 			log_sys_debug("close", fifos->server_path);
 	}
-
-	fifos->client = fifos->server = -1;
 }
 
 /* Get uuid of a device */
@@ -649,8 +605,8 @@ static int _do_event(int cmd, char *dmeventd_path, struct dm_event_daemon_messag
 {
 	int ret;
 	struct dm_event_fifos fifos = {
-		.client = -1,
 		.server = -1,
+		.client = -1,
 		/* FIXME Make these either configurable or depend directly on dmeventd_path */
 		.client_path = DM_EVENT_FIFO_CLIENT,
 		.server_path = DM_EVENT_FIFO_SERVER
@@ -663,7 +619,7 @@ static int _do_event(int cmd, char *dmeventd_path, struct dm_event_daemon_messag
 
 	ret = daemon_talk(&fifos, msg, DM_EVENT_CMD_HELLO, NULL, NULL, 0, 0);
 
-	free(msg->data);
+	dm_free(msg->data);
 	msg->data = 0;
 
 	if (!ret)
@@ -704,7 +660,7 @@ int dm_event_register_handler(const struct dm_event_handler *dmevh)
 		ret = 0;
 	}
 
-	free(msg.data);
+	dm_free(msg.data);
 
 	dm_task_destroy(dmt);
 
@@ -731,7 +687,7 @@ int dm_event_unregister_handler(const struct dm_event_handler *dmevh)
 		ret = 0;
 	}
 
-	free(msg.data);
+	dm_free(msg.data);
 
 	dm_task_destroy(dmt);
 
@@ -743,18 +699,22 @@ int dm_event_unregister_handler(const struct dm_event_handler *dmevh)
 static char *_fetch_string(char **src, const int delimiter)
 {
 	char *p, *ret;
-	size_t len = (p = strchr(*src, delimiter)) ?
-		(size_t)(p - *src) : strlen(*src);
 
-	if ((ret = strndup(*src, len)))
-		*src += len + 1;
+	if ((p = strchr(*src, delimiter)))
+		*p = 0;
+
+	if ((ret = dm_strdup(*src)))
+		*src += strlen(ret) + 1;
+
+	if (p)
+		*p = delimiter;
 
 	return ret;
 }
 
 /* Parse a device message from the daemon. */
 static int _parse_message(struct dm_event_daemon_message *msg, char **dso_name,
-			 char **uuid, unsigned *evmask)
+			 char **uuid, enum dm_event_mask *evmask)
 {
 	char *id;
 	char *p = msg->data;
@@ -763,11 +723,11 @@ static int _parse_message(struct dm_event_daemon_message *msg, char **dso_name,
 	    (*dso_name = _fetch_string(&p, ' ')) &&
 	    (*uuid = _fetch_string(&p, ' '))) {
 		*evmask = atoi(p);
-		free(id);
+		dm_free(id);
 		return 0;
 	}
 
-	free(id);
+	dm_free(id);
 	return -ENOMEM;
 }
 
@@ -779,7 +739,7 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 	int ret = 0;
 	const char *uuid = NULL;
 	char *reply_dso = NULL, *reply_uuid = NULL;
-	unsigned reply_mask = 0;
+	enum dm_event_mask reply_mask = 0;
 	struct dm_task *dmt = NULL;
 	struct dm_event_daemon_message msg = { 0 };
 	struct dm_info info;
@@ -809,7 +769,7 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 	dm_task_destroy(dmt);
 	dmt = NULL;
 
-	free(msg.data);
+	dm_free(msg.data);
 	msg.data = NULL;
 
 	_dm_event_handler_clear_dev_info(dmevh);
@@ -818,7 +778,7 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 		goto fail;
 	}
 
-	if (!(dmevh->uuid = strdup(reply_uuid))) {
+	if (!(dmevh->uuid = dm_strdup(reply_uuid))) {
 		ret = -ENOMEM;
 		goto fail;
 	}
@@ -831,13 +791,13 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 	dm_event_handler_set_dso(dmevh, reply_dso);
 	dm_event_handler_set_event_mask(dmevh, reply_mask);
 
-	free(reply_dso);
+	dm_free(reply_dso);
 	reply_dso = NULL;
 
-	free(reply_uuid);
+	dm_free(reply_uuid);
 	reply_uuid = NULL;
 
-	if (!(dmevh->dev_name = strdup(dm_task_get_name(dmt)))) {
+	if (!(dmevh->dev_name = dm_strdup(dm_task_get_name(dmt)))) {
 		ret = -ENOMEM;
 		goto fail;
 	}
@@ -855,9 +815,9 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 	return ret;
 
  fail:
-	free(msg.data);
-	free(reply_dso);
-	free(reply_uuid);
+	dm_free(msg.data);
+	dm_free(reply_dso);
+	dm_free(reply_uuid);
 	_dm_event_handler_clear_dev_info(dmevh);
 	if (dmt)
 		dm_task_destroy(dmt);
@@ -878,7 +838,6 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 int dm_event_get_version(struct dm_event_fifos *fifos, int *version) {
 	char *p;
 	struct dm_event_daemon_message msg = { 0 };
-	int ret = 0;
 
 	if (daemon_talk(fifos, &msg, DM_EVENT_CMD_HELLO, NULL, NULL, 0, 0))
 		return 0;
@@ -886,17 +845,13 @@ int dm_event_get_version(struct dm_event_fifos *fifos, int *version) {
 	*version = 0;
 
 	if (!p || !(p = strchr(p, ' '))) /* Message ID */
-		goto out;
+		return 0;
 	if (!(p = strchr(p + 1, ' '))) /* HELLO */
-		goto out;
+		return 0;
 	if ((p = strchr(p + 1, ' '))) /* HELLO, once more */
 		*version = atoi(p);
 
-	ret = 1;
-out:
-	free(msg.data);
-
-	return ret;
+	return 1;
 }
 
 void dm_event_log_set(int debug_log_level, int use_syslog)
@@ -911,11 +866,11 @@ void dm_event_log(const char *subsys, int level, const char *file,
 {
 	static int _abort_on_internal_errors = -1;
 	static pthread_mutex_t _log_mutex = PTHREAD_MUTEX_INITIALIZER;
-	static long long _start = 0;
+	static time_t start = 0;
 	const char *indent = "";
 	FILE *stream = log_stderr(level) ? stderr : stdout;
 	int prio;
-	long long now, now_nsec;
+	time_t now;
 	int log_with_debug = 0;
 
 	if (subsys[0] == '#') {
@@ -962,28 +917,17 @@ void dm_event_log(const char *subsys, int level, const char *file,
 	if (_use_syslog) {
 		vsyslog(prio, format, ap);
 	} else {
-		if (_debug_level) {
-#define _NSEC_PER_SEC (1000000000LL)
-#ifdef HAVE_REALTIME
-			struct timespec mono_time = { 0 };
-			if (clock_gettime(CLOCK_MONOTONIC, &mono_time) == 0)
-				now = mono_time.tv_sec * _NSEC_PER_SEC + mono_time.tv_nsec;
-			else
-#endif
-				now = time(NULL) * _NSEC_PER_SEC;
-
-			if (!_start)
-				_start = now;
-			now -= _start;
-			now_nsec = now %_NSEC_PER_SEC;
-			now /= _NSEC_PER_SEC;
-			fprintf(stream, "[%2lld:%02lld.%06lld] %8x:%-6s%s",
-				now / 60, now % 60, now_nsec / 1000,
+		now = time(NULL);
+		if (!start)
+			start = now;
+		now -= start;
+		if (_debug_level)
+			fprintf(stream, "[%2d:%02d] %8x:%-6s%s",
+				(int)now / 60, (int)now % 60,
 				// TODO: Maybe use shorter ID
 				// ((int)(pthread_self()) >> 6) & 0xffff,
 				(int)pthread_self(), subsys,
 				(_debug_level > 3) ? "" : indent);
-		}
 		if (_debug_level > 3)
 			fprintf(stream, "%28s:%4d %s", file, line, indent);
 		vfprintf(stream, _(format), ap);
@@ -1007,7 +951,7 @@ void dm_event_log(const char *subsys, int level, const char *file,
 
 static char *_skip_string(char *src, const int delimiter)
 {
-	src = strchr(src, delimiter);
+	src = srtchr(src, delimiter);
 	if (src && *(src + 1))
 		return src + 1;
 	return NULL;
@@ -1038,12 +982,12 @@ int dm_event_get_timeout(const char *device_path, uint32_t *timeout)
 		if (!p) {
 			log_error("Malformed reply from dmeventd '%s'.",
 				  msg.data);
-			free(msg.data);
+			dm_free(msg.data);
 			return -EIO;
 		}
 		*timeout = atoi(p);
 	}
-	free(msg.data);
+	dm_free(msg.data);
 
 	return ret;
 }

daemons/dmeventd/libdevmapper-event.h

@@ -21,7 +21,6 @@
 #ifndef LIB_DMEVENT_H
 #define LIB_DMEVENT_H
 
-#include <stdarg.h>
 #include <stdint.h>
 
 /*
@@ -29,22 +28,19 @@
  */
 
 enum dm_event_mask {
+	DM_EVENT_SETTINGS_MASK  = 0x0000FF,
 	DM_EVENT_SINGLE		= 0x000001, /* Report multiple errors just once. */
 	DM_EVENT_MULTI		= 0x000002, /* Report all of them. */
-	DM_EVENT_SETTINGS_MASK  = 0x0000FF,
 
+	DM_EVENT_ERROR_MASK     = 0x00FF00,
 	DM_EVENT_SECTOR_ERROR	= 0x000100, /* Failure on a particular sector. */
 	DM_EVENT_DEVICE_ERROR	= 0x000200, /* Device failure. */
 	DM_EVENT_PATH_ERROR	= 0x000400, /* Failure on an io path. */
 	DM_EVENT_ADAPTOR_ERROR	= 0x000800, /* Failure of a host adaptor. */
-	DM_EVENT_ERROR_MASK     = 0x00FF00,
-
-	DM_EVENT_SYNC_STATUS	= 0x010000, /* Mirror synchronization completed/failed. */
-	DM_EVENT_TIMEOUT	= 0x020000, /* Timeout has occurred */
-
-	DM_EVENT_ERROR_AND_TIMEOUT_MASK = 0x02FF00,
 
 	DM_EVENT_STATUS_MASK    = 0xFF0000,
+	DM_EVENT_SYNC_STATUS	= 0x010000, /* Mirror synchronization completed/failed. */
+	DM_EVENT_TIMEOUT	= 0x020000, /* Timeout has occured */
 
 	DM_EVENT_REGISTRATION_PENDING = 0x1000000, /* Monitor thread is setting-up/shutting-down */
 };
@@ -73,10 +69,10 @@ int dm_event_handler_set_dso(struct dm_event_handler *dmevh, const char *path);
 int dm_event_handler_set_dmeventd_path(struct dm_event_handler *dmevh, const char *dmeventd_path);
 
 /*
- * Identify the device to monitor by exactly one of dev_name, uuid or
+ * Identify the device to monitor by exactly one of device_name, uuid or
  * device number. String arguments are duplicated, see above.
  */
-int dm_event_handler_set_dev_name(struct dm_event_handler *dmevh, const char *dev_name);
+int dm_event_handler_set_dev_name(struct dm_event_handler *dmevh, const char *device_name);
 
 int dm_event_handler_set_uuid(struct dm_event_handler *dmevh, const char *uuid);
 
@@ -112,7 +108,7 @@ int dm_event_unregister_handler(const struct dm_event_handler *dmevh);
 /* Set debug level for logging, and whether to log on stdout/stderr or syslog */
 void dm_event_log_set(int debug_log_level, int use_syslog);
 
-/* Log messages according to current debug level  */
+/* Log messages acroding to current debug level  */
 __attribute__((format(printf, 6, 0)))
 void dm_event_log(const char *subsys, int level, const char *file,
 		  int line, int dm_errno_or_class,

daemons/dmeventd/libdevmapper-event.pc.in

@@ -8,3 +8,4 @@ Description: device-mapper event library
 Version: @DM_LIB_PATCHLEVEL@
 Cflags: -I${includedir}
 Libs: -L${libdir} -ldevmapper-event
+Requires.private: devmapper

daemons/dmeventd/plugins/lvm2/Makefile.in

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

daemons/dmeventd/plugins/lvm2/dmeventd_lvm.c

@@ -12,10 +12,10 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "lib/misc/lib.h"
+#include "lib.h"
 #include "dmeventd_lvm.h"
-#include "daemons/dmeventd/libdevmapper-event.h"
-#include "tools/lvm2cmd.h"
+#include "libdevmapper-event.h"
+#include "lvm2cmd.h"
 
 #include <pthread.h>
 
@@ -71,7 +71,7 @@ int dmeventd_lvm2_init(void)
 	if (!_lvm_handle) {
 		lvm2_log_fn(_lvm2_print_log);
 
-		if (!(_lvm_handle = lvm2_init_threaded()))
+		if (!(_lvm_handle = lvm2_init()))
 			goto out;
 
 		/*
@@ -87,7 +87,7 @@ int dmeventd_lvm2_init(void)
 		lvm2_disable_dmeventd_monitoring(_lvm_handle);
 		/* FIXME Temporary: move to dmeventd core */
 		lvm2_run(_lvm_handle, "_memlock_inc");
-		log_debug("lvm plugin initialized.");
+		log_debug("lvm plugin initilized.");
 	}
 
 	_register_count++;
@@ -103,7 +103,7 @@ void dmeventd_lvm2_exit(void)
 	pthread_mutex_lock(&_register_mutex);
 
 	if (!--_register_count) {
-		log_debug("lvm plugin shutting down.");
+		log_debug("lvm plugin shuting down.");
 		lvm2_run(_lvm_handle, "_memlock_dec");
 		dm_pool_destroy(_mem_pool);
 		_mem_pool = NULL;
@@ -123,7 +123,6 @@ struct dm_pool *dmeventd_lvm2_pool(void)
 
 int dmeventd_lvm2_run(const char *cmdline)
 {
-	/* coverity[missing_lock] no locking for run part */
 	return (lvm2_run(_lvm_handle, cmdline) == LVM2_COMMAND_SUCCEEDED);
 }
 

daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h

@@ -25,8 +25,6 @@
 #ifndef _DMEVENTD_LVMWRAP_H
 #define _DMEVENTD_LVMWRAP_H
 
-#include <stddef.h>
-
 struct dm_pool;
 
 int dmeventd_lvm2_init(void);

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
 
@@ -25,8 +25,13 @@ LIB_NAME = libdevmapper-event-lvm2mirror
 LIB_SHARED = $(LIB_NAME).$(LIB_SUFFIX)
 LIB_VERSION = $(LIB_VERSION_LVM)
 
+CFLOW_LIST = $(SOURCES)
+CFLOW_LIST_TARGET = $(LIB_NAME).cflow
+
 include $(top_builddir)/make.tmpl
 
+LIBS += -ldevmapper-event-lvm2 -ldevmapper
+
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -12,10 +12,10 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "lib/misc/lib.h"
-#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
-#include "daemons/dmeventd/libdevmapper-event.h"
-#include "lib/activate/activate.h"
+#include "lib.h"
+#include "libdevmapper-event.h"
+#include "dmeventd_lvm.h"
+#include "activate.h"	/* For TARGET_NAME* */
 
 /* FIXME Reformat to 80 char lines. */
 
@@ -38,7 +38,7 @@ static void _process_status_code(dm_status_mirror_health_t health,
 	 *    A => Alive - No failures
 	 *    D => Dead - A write failure occurred leaving mirror out-of-sync
 	 *    F => Flush failed.
-	 *    S => Sync - A synchronization failure occurred, mirror out-of-sync
+	 *    S => Sync - A sychronization failure occurred, mirror out-of-sync
 	 *    R => Read - A read failure occurred, mirror data unaffected
 	 *    U => Unclassified failure (bug)
 	 */ 
@@ -112,7 +112,7 @@ static int _remove_failed_devices(const char *cmd_lvconvert, const char *device)
 }
 
 void process_event(struct dm_task *dmt,
-		   enum dm_event_mask evmask __attribute__((unused)),
+		   enum dm_event_mask event __attribute__((unused)),
 		   void **user)
 {
 	struct dso_state *state = *user;

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
 
@@ -24,8 +24,13 @@ LIB_NAME = libdevmapper-event-lvm2raid
 LIB_SHARED = $(LIB_NAME).$(LIB_SUFFIX)
 LIB_VERSION = $(LIB_VERSION_LVM)
 
+CFLOW_LIST = $(SOURCES)
+CFLOW_LIST_TARGET = $(LIB_NAME).cflow
+
 include $(top_builddir)/make.tmpl
 
+LIBS += -ldevmapper-event-lvm2 -ldevmapper
+
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/raid/dmeventd_raid.c

@@ -12,12 +12,12 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "lib/misc/lib.h"
-#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
-#include "daemons/dmeventd/libdevmapper-event.h"
-#include "lib/config/defaults.h"
+#include "lib.h"
+#include "defaults.h"
+#include "dmeventd_lvm.h"
+#include "libdevmapper-event.h"
 
-/* Hold enough elements for the maximum number of RAID images */
+/* Hold enough elements for the mximum number of RAID images */
 #define	RAID_DEVS_ELEMS	((DEFAULT_RAID_MAX_IMAGES + 63) / 64)
 
 struct dso_state {
@@ -77,7 +77,7 @@ static int _process_raid_event(struct dso_state *state, char *params, const char
 
 	if (dead) {
 		/*
-		 * Use the first event to run a repair ignoring any additional ones.
+		 * 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.
@@ -114,7 +114,7 @@ out:
 }
 
 void process_event(struct dm_task *dmt,
-		   enum dm_event_mask evmask __attribute__((unused)),
+		   enum dm_event_mask event __attribute__((unused)),
 		   void **user)
 {
 	struct dso_state *state = *user;

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,6 +26,8 @@ LIB_VERSION = $(LIB_VERSION_LVM)
 
 include $(top_builddir)/make.tmpl
 
+LIBS += -ldevmapper-event-lvm2 -ldevmapper
+
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/snapshot/dmeventd_snapshot.c

@@ -12,9 +12,9 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "lib/misc/lib.h"
-#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
-#include "daemons/dmeventd/libdevmapper-event.h"
+#include "lib.h"
+#include "dmeventd_lvm.h"
+#include "libdevmapper-event.h"
 
 #include <sys/sysmacros.h>
 #include <sys/wait.h>
@@ -163,7 +163,7 @@ static void _umount(const char *device, int major, int minor)
 }
 
 void process_event(struct dm_task *dmt,
-		   enum dm_event_mask evmask __attribute__((unused)),
+		   enum dm_event_mask event __attribute__((unused)),
 		   void **user)
 {
 	struct dso_state *state = *user;
@@ -175,7 +175,6 @@ 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)
@@ -206,8 +205,7 @@ void process_event(struct dm_task *dmt,
 		/* Maybe configurable ? */
 		_remove(dm_task_get_uuid(dmt));
 #endif
-		if ((ret = pthread_kill(pthread_self(), SIGALRM)) && (ret != ESRCH))
-			log_sys_error("pthread_kill", "self");
+		pthread_kill(pthread_self(), SIGALRM);
 		goto out;
 	}
 
@@ -215,8 +213,7 @@ 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);
-		if ((ret = pthread_kill(pthread_self(), SIGALRM)) && (ret != ESRCH))
-			log_sys_error("pthread_kill", "self");
+		pthread_kill(pthread_self(), SIGALRM);
 		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
 
@@ -24,8 +24,13 @@ LIB_NAME = libdevmapper-event-lvm2thin
 LIB_SHARED = $(LIB_NAME).$(LIB_SUFFIX)
 LIB_VERSION = $(LIB_VERSION_LVM)
 
+CFLOW_LIST = $(SOURCES)
+CFLOW_LIST_TARGET = $(LIB_NAME).cflow
+
 include $(top_builddir)/make.tmpl
 
+LIBS += -ldevmapper-event-lvm2 -ldevmapper
+
 install_lvm2: install_dm_plugin
 
 install: install_lvm2

daemons/dmeventd/plugins/thin/dmeventd_thin.c

@@ -12,16 +12,16 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "lib/misc/lib.h"
-#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
-#include "daemons/dmeventd/libdevmapper-event.h"
+#include "lib.h"	/* using here lvm log */
+#include "dmeventd_lvm.h"
+#include "libdevmapper-event.h"
 
 #include <sys/wait.h>
 #include <stdarg.h>
 
 /* TODO - move this mountinfo code into library to be reusable */
 #ifdef __linux__
-#  include "libdm/misc/kdev_t.h"
+#  include "kdev_t.h"
 #else
 #  define MAJOR(x) major((x))
 #  define MINOR(x) minor((x))
@@ -87,7 +87,7 @@ static int _run_command(struct dso_state *state)
 	log_verbose("Executing command: %s", state->cmd_str);
 
 	/* TODO:
-	 *   Support parallel run of 'task' and it's waitpid maintenance
+	 *   Support parallel run of 'task' and it's waitpid maintainence
 	 *   ATM we can't handle signaling of  SIGALRM
 	 *   as signalling is not allowed while 'process_event()' is running
 	 */
@@ -155,7 +155,7 @@ static int _wait_for_pid(struct dso_state *state)
 }
 
 void process_event(struct dm_task *dmt,
-		   enum dm_event_mask evmask,
+		   enum dm_event_mask event __attribute__((unused)),
 		   void **user)
 {
 	const char *device = dm_task_get_name(dmt);
@@ -179,7 +179,7 @@ void process_event(struct dm_task *dmt,
 		return;
 	}
 
-	if (evmask & DM_EVENT_DEVICE_ERROR) {
+	if (event & DM_EVENT_DEVICE_ERROR) {
 		/* Error -> no need to check and do instant resize */
 		state->data_percent = state->metadata_percent = 0;
 		if (_use_policy(dmt, state))
@@ -245,7 +245,7 @@ void process_event(struct dm_task *dmt,
 	/*
 	 * Trigger action when threshold boundary is exceeded.
 	 * Report 80% threshold warning when it's used above 80%.
-	 * Only 100% is exception as it cannot be surpassed so policy
+	 * Only 100% is exception as it cannot be surpased so policy
 	 * action is called for:  >50%, >55% ... >95%, 100%
 	 */
 	state->metadata_percent = dm_make_percent(tps->used_metadata_blocks, tps->total_metadata_blocks);
@@ -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);
-			goto out;
+			return;
 		}
 		if (state->max_fails < MAX_FAILS)
 			state->max_fails <<= 1;
@@ -379,7 +379,7 @@ int register_device(const char *device,
 
 		state->argv[1] = str + 1;  /* 1 argument - vg/lv */
 		_init_thread_signals(state);
-	} else /* Unsupported command format */
+	} else /* Unuspported command format */
 		goto inval;
 
 	state->pid = -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
 
@@ -24,8 +24,13 @@ LIB_NAME = libdevmapper-event-lvm2vdo
 LIB_SHARED = $(LIB_NAME).$(LIB_SUFFIX)
 LIB_VERSION = $(LIB_VERSION_LVM)
 
+CFLOW_LIST = $(SOURCES)
+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

@@ -12,18 +12,9 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "lib/misc/lib.h"
-#include "daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h"
-#include "daemons/dmeventd/libdevmapper-event.h"
-
-/*
- * Use parser from new device_mapper library.
- * Although during compilation we can see dm_vdo_status_parse()
- * in runtime we are linked against systems libdm 'older' library
- * which does not provide this symbol and plugin fails to load
- */
-/* coverity[unnecessary_header] used for parsing */
-#include "device_mapper/vdo/status.c"
+#include "lib.h"
+#include "dmeventd_lvm.h"
+#include "libdevmapper-event.h"
 
 #include <sys/wait.h>
 #include <stdarg.h>
@@ -54,6 +45,23 @@ struct dso_state {
 	const char *name;
 };
 
+struct vdo_status {
+	uint64_t used_blocks;
+	uint64_t total_blocks;
+};
+
+static int _vdo_status_parse(const char *params, struct vdo_status *status)
+{
+	if (sscanf(params, "%*s %*s %*s %*s %*s %" PRIu64 " %" PRIu64,
+		   &status->used_blocks,
+		   &status->total_blocks) < 2) {
+		log_error("Failed to parse vdo params: %s.", params);
+		return 0;
+	}
+
+	return 1;
+}
+
 DM_EVENT_LOG_FN("vdo")
 
 static int _run_command(struct dso_state *state)
@@ -78,7 +86,7 @@ static int _run_command(struct dso_state *state)
 	log_verbose("Executing command: %s", state->cmd_str);
 
 	/* TODO:
-	 *   Support parallel run of 'task' and it's waitpid maintenance
+	 *   Support parallel run of 'task' and it's waitpid maintainence
 	 *   ATM we can't handle signaling of  SIGALRM
 	 *   as signalling is not allowed while 'process_event()' is running
 	 */
@@ -146,7 +154,7 @@ static int _wait_for_pid(struct dso_state *state)
 }
 
 void process_event(struct dm_task *dmt,
-		   enum dm_event_mask evmask __attribute__((unused)),
+		   enum dm_event_mask event __attribute__((unused)),
 		   void **user)
 {
 	const char *device = dm_task_get_name(dmt);
@@ -157,7 +165,7 @@ void process_event(struct dm_task *dmt,
 	char *params;
 	int needs_policy = 0;
 	struct dm_task *new_dmt = NULL;
-	struct dm_vdo_status_parse_result vdop = { .status = NULL };
+	struct vdo_status status;
 
 #if VDO_DEBUG
 	log_debug("Watch for VDO %s:%.2f%%.", state->name,
@@ -169,7 +177,7 @@ void process_event(struct dm_task *dmt,
 		return;
 	}
 
-	if (evmask & DM_EVENT_DEVICE_ERROR) {
+	if (event & DM_EVENT_DEVICE_ERROR) {
 #if VDO_DEBUG
 		log_debug("VDO event error.");
 #endif
@@ -203,31 +211,31 @@ void process_event(struct dm_task *dmt,
 		goto out;
 	}
 
-	if (!dm_vdo_status_parse(state->mem, params, &vdop)) {
+	if (!_vdo_status_parse(params, &status)) {
 		log_error("Failed to parse status.");
 		goto out;
 	}
 
-	state->percent = dm_make_percent(vdop.status->used_blocks,
-					 vdop.status->total_blocks);
+	state->percent = dm_make_percent(status.used_blocks,
+					 status.total_blocks);
 
 #if VDO_DEBUG
 	log_debug("VDO %s status  %.2f%% " FMTu64 "/" FMTu64 ".",
 		  state->name, dm_percent_to_round_float(state->percent, 2),
-		  vdop.status->used_blocks, vdop.status->total_blocks);
+		  status.used_blocks, status.total_blocks);
 #endif
 
 	/* VDO pool size had changed. Clear the threshold. */
-	if (state->known_data_size != vdop.status->total_blocks) {
+	if (state->known_data_size != status.total_blocks) {
 		state->percent_check = CHECK_MINIMUM;
-		state->known_data_size = vdop.status->total_blocks;
+		state->known_data_size = status.total_blocks;
 		state->fails = 0;
 	}
 
 	/*
 	 * Trigger action when threshold boundary is exceeded.
 	 * Report 80% threshold warning when it's used above 80%.
-	 * Only 100% is exception as it cannot be surpassed so policy
+	 * Only 100% is exception as it cannot be surpased so policy
 	 * action is called for:  >50%, >55% ... >95%, 100%
 	 */
 	if ((state->percent > WARNING_THRESH) &&
@@ -253,7 +261,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);
-			goto out;
+			return;
 		}
 		if (state->max_fails < MAX_FAILS)
 			state->max_fails <<= 1;
@@ -261,12 +269,10 @@ void process_event(struct dm_task *dmt,
 	} else
 		state->max_fails = 1; /* Reset on success */
 
-	if (needs_policy)
+	/* FIXME: ATM nothing can be done, drop 0, once it becomes useful */
+	if (0 && needs_policy)
 		_use_policy(dmt, state);
 out:
-	if (vdop.status)
-		dm_pool_free(state->mem, vdop.status);
-
 	if (new_dmt)
 		dm_task_destroy(new_dmt);
 }
@@ -354,7 +360,7 @@ int register_device(const char *device,
 		_init_thread_signals(state);
 	} else if (cmd[0] == 0) {
 		state->name = "volume"; /* What to use with 'others?' */
-	} else/* Unsupported command format */
+	} else/* Unuspported command format */
 		goto inval;
 
 	state->pid = -1;

daemons/dmfilemapd/.gitignore

@@ -1,2 +1 @@
-dmsetup
 dmfilemapd

daemons/dmfilemapd/Makefile.in

@@ -0,0 +1,66 @@
+#
+# Copyright (C) 2016 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
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+top_builddir = @top_builddir@
+
+SOURCES = dmfilemapd.c
+
+TARGETS = dmfilemapd
+
+.PHONY: install_dmfilemapd install_dmfilemapd_static
+
+INSTALL_DMFILEMAPD_TARGETS = install_dmfilemapd_dynamic
+
+CLEAN_TARGETS = dmfilemapd.static
+
+CFLOW_LIST = $(SOURCES)
+CFLOW_LIST_TARGET = $(LIB_NAME).cflow
+CFLOW_TARGET = dmfilemapd
+
+include $(top_builddir)/make.tmpl
+
+all: device-mapper
+device-mapper: $(TARGETS)
+
+CFLAGS_dmfilemapd.o += $(EXTRA_EXEC_CFLAGS)
+LIBS += -ldevmapper
+
+dmfilemapd: $(LIB_SHARED) dmfilemapd.o
+	$(CC) $(CFLAGS) $(LDFLAGS) $(EXTRA_EXEC_LDFLAGS) $(ELDFLAGS) \
+		-o $@ dmfilemapd.o $(DL_LIBS) $(LIBS)
+
+dmfilemapd.static: $(LIB_STATIC) dmfilemapd.o $(interfacebuilddir)/libdevmapper.a
+	$(CC) $(CFLAGS) $(LDFLAGS) $(ELDFLAGS) -static -L$(interfacebuilddir) \
+		-o $@ dmfilemapd.o $(DL_LIBS) $(LIBS) $(STATIC_LIBS)
+
+ifneq ("$(CFLOW_CMD)", "")
+CFLOW_SOURCES = $(addprefix $(srcdir)/, $(SOURCES))
+-include $(top_builddir)/libdm/libdevmapper.cflow
+-include $(top_builddir)/lib/liblvm-internal.cflow
+-include $(top_builddir)/lib/liblvm2cmd.cflow
+-include $(top_builddir)/daemons/dmfilemapd/$(LIB_NAME).cflow
+endif
+
+install_dmfilemapd_dynamic: dmfilemapd
+	$(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
+
+install_dmfilemapd_static: dmfilemapd.static
+	$(INSTALL_PROGRAM) -D $< $(staticdir)/$(<F)
+
+install_dmfilemapd: $(INSTALL_DMFILEMAPD_TARGETS)
+
+install: install_dmfilemapd
+
+install_device-mapper: install_dmfilemapd

daemons/dmfilemapd/dmfilemapd.c

@@ -14,16 +14,11 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libdm/misc/dm-logging.h"
-#include "util.h"
+#include "tool.h"
 
-#ifdef __linux__
-#  include "libdm/misc/kdev_t.h"
-#else
-#  define MAJOR(x) major((x))
-#  define MINOR(x) minor((x))
-#  define MKDEV(x,y) makedev((x),(y))
-#endif
+#include "dm-logging.h"
+
+#include "defaults.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -33,6 +28,14 @@
 #include <dirent.h>
 #include <ctype.h>
 
+#ifdef __linux__
+#  include "kdev_t.h"
+#else
+#  define MAJOR(x) major((x))
+#  define MINOR(x) minor((x))
+#  define MKDEV(x,y) makedev((dev_t)(x),(dev_t)(y))
+#endif
+
 /* limit to two updates/sec */
 #define FILEMAPD_WAIT_USECS 500000
 
@@ -59,8 +62,8 @@ struct filemap_monitor {
 static int _foreground;
 static int _verbose;
 
-const char _usage[] = "dmfilemapd <fd> <group_id> <abs_path> <mode> "
-	"[<foreground>[<log_level>]]";
+const char *const _usage = "dmfilemapd <fd> <group_id> <abs_path> <mode> "
+			   "[<foreground>[<log_level>]]";
 
 /*
  * Daemon logging. By default, all messages are thrown away: messages
@@ -109,7 +112,7 @@ static void _dmfilemapd_log_with_errno(int level,
 }
 
 /*
- * Only used for reporting errors before daemonize().
+ * Only used for reporting errors before daemonise().
  */
 __attribute__((format(printf, 1, 2)))
 static void _early_log(const char *fmt, ...)
@@ -141,7 +144,6 @@ static int _is_open_in_pid(pid_t pid, const char *path)
 	char link_buf[PATH_MAX];
 	DIR *pid_d = NULL;
 	ssize_t len;
-	int df;
 
 	if (pid == getpid())
 		return 0;
@@ -170,9 +172,8 @@ static int _is_open_in_pid(pid_t pid, const char *path)
 	while ((pid_dp = readdir(pid_d)) != NULL) {
 		if (pid_dp->d_name[0] == '.')
 			continue;
-		if (((df = dirfd(pid_d)) < 0) ||
-		    (len = readlinkat(df, pid_dp->d_name, link_buf,
-				      (sizeof(link_buf) - 1))) < 0) {
+		if ((len = readlinkat(dirfd(pid_d), pid_dp->d_name, link_buf,
+				      sizeof(link_buf))) < 0) {
 			log_error("readlink failed for " DEFAULT_PROC_DIR
 				  "/%d/fd/.", pid);
 			goto bad;
@@ -180,14 +181,14 @@ static int _is_open_in_pid(pid_t pid, const char *path)
 		link_buf[len] = '\0';
 		if (!strcmp(deleted_path, link_buf)) {
 			if (closedir(pid_d))
-				log_sys_debug("closedir", path_buf);
+				log_sys_error("closedir", path_buf);
 			return 1;
 		}
 	}
 
 bad:
 	if (closedir(pid_d))
-		log_sys_debug("closedir", path_buf);
+		log_sys_error("closedir", path_buf);
 
 	return 0;
 }
@@ -230,13 +231,13 @@ static int _is_open(const char *path)
 			continue;
 		if (_is_open_in_pid(pid, path)) {
 			if (closedir(proc_d))
-				log_sys_debug("closedir", DEFAULT_PROC_DIR);
+				log_sys_error("closedir", DEFAULT_PROC_DIR);
 			return 1;
 		}
 	}
 
 	if (closedir(proc_d))
-		log_sys_debug("closedir", DEFAULT_PROC_DIR);
+		log_sys_error("closedir", DEFAULT_PROC_DIR);
 
 	return 0;
 }
@@ -310,7 +311,7 @@ static int _parse_args(int argc, char **argv, struct filemap_monitor *fm)
 		return 0;
 	}
 
-	fm->path = strdup(argv[0]);
+	fm->path = dm_strdup(argv[0]);
 	if (!fm->path) {
 		_early_log("Could not allocate memory for path argument.");
 		return 0;
@@ -537,8 +538,8 @@ static void _filemap_monitor_destroy(struct filemap_monitor *fm)
 		_filemap_monitor_end_notify(fm);
 		_filemap_monitor_close_fd(fm);
 	}
-	free((void *) fm->program_id);
-	free(fm->path);
+	dm_free((void *) fm->program_id);
+	dm_free(fm->path);
 }
 
 static int _filemap_monitor_check_same_file(int fd1, int fd2)
@@ -626,10 +627,10 @@ check_unlinked:
 	return 1;
 }
 
-static int _daemonize(struct filemap_monitor *fm)
+static int _daemonise(struct filemap_monitor *fm)
 {
 	pid_t pid = 0;
-	int fd, ffd;
+	int fd;
 
 	if (!setsid()) {
 		_early_log("setsid failed.");
@@ -653,29 +654,26 @@ static int _daemonize(struct filemap_monitor *fm)
 	}
 
 	if (!_verbose) {
-		if ((fd = open("/dev/null", O_RDWR)) == -1) {
-			_early_log("Error opening /dev/null.");
+		if (close(STDIN_FILENO))
+			_early_log("Error closing stdin");
+		if (close(STDOUT_FILENO))
+			_early_log("Error closing stdout");
+		if (close(STDERR_FILENO))
+			_early_log("Error closing stderr");
+		if ((open("/dev/null", O_RDONLY) < 0) ||
+	            (open("/dev/null", O_WRONLY) < 0) ||
+		    (open("/dev/null", O_WRONLY) < 0)) {
+			_early_log("Error opening stdio streams.");
 			return 0;
 		}
-
-		if ((dup2(fd, STDIN_FILENO) == -1) ||
-		    (dup2(fd, STDOUT_FILENO) == -1) ||
-		    (dup2(fd, STDERR_FILENO) == -1)) {
-			if (fd > STDERR_FILENO)
-				(void) close(fd);
-			_early_log("Error redirecting stdin/out/err to null.");
-			/* coverity[leaked_handle] no leak */
-			return 0;
-		}
-		if (fd > STDERR_FILENO)
-			(void) close(fd);
 	}
-	/* TODO: Use libdaemon/server/daemon-server.c _daemonize() */
-	for (ffd = (int) sysconf(_SC_OPEN_MAX) - 1; ffd > STDERR_FILENO; --ffd)
-		if (ffd != fm->fd)
-			(void) close(ffd);
+	/* TODO: Use libdaemon/server/daemon-server.c _daemonise() */
+	for (fd = (int) sysconf(_SC_OPEN_MAX) - 1; fd > STDERR_FILENO; fd--) {
+		if (fd == fm->fd)
+			continue;
+		(void) close(fd);
+	}
 
-	/* coverity[leaked_handle] no leak */
 	return 1;
 }
 
@@ -701,7 +699,7 @@ static int _update_regions(struct dm_stats *dms, struct filemap_monitor *fm)
 			 fm->group_id, regions[0]);
 		fm->group_id = regions[0];
 	}
-	free(regions);
+	dm_free(regions);
 	fm->nr_regions = nr_regions;
 	return 1;
 }
@@ -743,7 +741,7 @@ static int _dmfilemapd(struct filemap_monitor *fm)
 	 */
 	program_id = dm_stats_get_region_program_id(dms, fm->group_id);
 	if (program_id)
-		fm->program_id = strdup(program_id);
+		fm->program_id = dm_strdup(program_id);
 	else
 		fm->program_id = NULL;
 	dm_stats_set_program_id(dms, 1, program_id);
@@ -774,7 +772,7 @@ static int _dmfilemapd(struct filemap_monitor *fm)
 wait:
 		_filemap_monitor_wait(FILEMAPD_WAIT_USECS);
 
-		/* mode=inode termination conditions */
+		/* mode=inode termination condions */
 		if (fm->mode == DM_FILEMAPD_FOLLOW_INODE) {
 			if (!_filemap_monitor_check_file_unlinked(fm))
 				goto bad;
@@ -804,7 +802,7 @@ bad:
 	return 1;
 }
 
-static const char _mode_names[][8] = {
+static const char * const _mode_names[] = {
 	"inode",
 	"path"
 };
@@ -814,21 +812,23 @@ static const char _mode_names[][8] = {
  */
 int main(int argc, char **argv)
 {
-	struct filemap_monitor fm = { .fd = 0 };
+	struct filemap_monitor fm;
+
+	memset(&fm, 0, sizeof(fm));
 
 	if (!_parse_args(argc, argv, &fm)) {
-		free(fm.path);
+		dm_free(fm.path);
 		return 1;
 	}
 
 	_setup_logging();
 
 	log_info("Starting dmfilemapd with fd=%d, group_id=" FMTu64 " "
-		 "mode=%s, path=\"%s\"", fm.fd, fm.group_id,
+		 "mode=%s, path=%s", fm.fd, fm.group_id,
 		 _mode_names[fm.mode], fm.path);
 
-	if (!_foreground && !_daemonize(&fm)) {
-		free(fm.path);
+	if (!_foreground && !_daemonise(&fm)) {
+		dm_free(fm.path);
 		return 1;
 	}
 

daemons/lvmdbusd/Makefile.in

@@ -15,8 +15,7 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-lvmdbuspydir = $(python3dir)/lvmdbusd
-lvmdbusdir = $(DESTDIR)$(lvmdbuspydir)
+lvmdbusdir = $(python3dir)/lvmdbusd
 
 LVMDBUS_SRCDIR_FILES = \
 	automatedproperties.py \
@@ -24,10 +23,11 @@ LVMDBUS_SRCDIR_FILES = \
 	cfg.py \
 	cmdhandler.py \
 	fetch.py \
+	__init__.py \
 	job.py \
 	loader.py \
-	lv.py \
 	main.py \
+	lv.py \
 	manager.py \
 	objectmanager.py \
 	pv.py \
@@ -35,8 +35,7 @@ LVMDBUS_SRCDIR_FILES = \
 	state.py \
 	udevwatch.py \
 	utils.py \
-	vg.py \
-	__init__.py
+	vg.py
 
 LVMDBUS_BUILDDIR_FILES = \
 	lvmdb.py \
@@ -51,15 +50,18 @@ include $(top_builddir)/make.tmpl
 
 .PHONY: install_lvmdbusd
 
-install_lvmdbusd: $(LVMDBUSD)
-	$(SHOW) "    [INSTALL] $<"
-	$(Q) $(INSTALL_DIR) $(sbindir)
-	$(Q) $(INSTALL_SCRIPT) $(LVMDBUSD) $(sbindir)
-	$(Q) $(INSTALL_DIR) $(lvmdbusdir) $(lvmdbusdir)/__pycache__
-	$(Q) (cd $(srcdir); $(INSTALL_DATA) $(LVMDBUS_SRCDIR_FILES) $(lvmdbusdir))
-	$(Q) $(INSTALL_DATA) $(LVMDBUS_BUILDDIR_FILES) $(lvmdbusdir)
-	$(Q) PYTHON=$(PYTHON3) $(PYCOMPILE) --destdir "$(DESTDIR)" --basedir "$(lvmdbuspydir)" $(LVMDBUS_SRCDIR_FILES) $(LVMDBUS_BUILDDIR_FILES)
-	$(Q) $(CHMOD) 444 $(lvmdbusdir)/__pycache__/*.py[co]
+all:
+	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]
 
 install_lvm2: install_lvmdbusd
 

daemons/lvmdbusd/automatedproperties.py

@@ -44,10 +44,10 @@ class AutomatedProperties(dbus.service.Object):
 
 	def set_interface(self, interface):
 		"""
-		With inheritance, we can't easily tell what interfaces a class provides,
+		With inheritance we can't easily tell what interfaces a class provides
 		so we will have each class that implements an interface tell the
 		base AutomatedProperties what it is they do provide.  This is kind of
-		clunky, and perhaps we can figure out a better way to do this later.
+		clunky and perhaps we can figure out a better way to do this later.
 		:param interface:       An interface the object supports
 		:return:
 		"""
@@ -88,6 +88,7 @@ class AutomatedProperties(dbus.service.Object):
 			cb, cbe, False)
 		cfg.worker_q.put(r)
 
+
 	@staticmethod
 	def _get_all_prop(obj, interface_name):
 		if interface_name in obj.interface(True):
@@ -154,17 +155,16 @@ 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 0
+			return
+
+		search = self.lvm_id
+		if search_key:
+			search = search_key
 
 		# Either we have the new object state or we need to go fetch it
 		if object_state:
 			new_state = object_state
 		else:
-			if search_key:
-				search = search_key
-			else:
-				search = self.lvm_id
-
 			new_state = self._ap_search_method([search])[0]
 			assert isinstance(new_state, State)
 

daemons/lvmdbusd/background.py

@@ -7,11 +7,13 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
+import subprocess
 from . import cfg
-from .cmdhandler import options_to_cli_args, LvmExecutionMeta, call_lvm
+from .cmdhandler import options_to_cli_args, LvmExecutionMeta
 import dbus
-from .utils import pv_range_append, pv_dest_ranges, log_error, log_debug
-from .request import RequestEntry
+from .utils import pv_range_append, pv_dest_ranges, log_error, log_debug,\
+	add_no_notify
+import os
 import threading
 import time
 
@@ -37,47 +39,58 @@ def lv_merge_cmd(merge_options, lv_full_name):
 	return cmd
 
 
-def _load_wrapper(ignored):
-	cfg.load()
-
-
-def _move_callback(job_state, line_str):
-	try:
-		if line_str.count(':') == 2:
-			(device, ignore, percentage) = line_str.split(':')
-
-			job_state.Percent = int(round(
-				float(percentage.strip()[:-1]), 1))
-
-			# While the move is in progress we need to periodically update
-			# the state to reflect where everything is at.  we will do this
-			# by scheduling the load to occur in the main work queue.
-			r = RequestEntry(
-				-1, _load_wrapper, ("_move_callback: load",), None, None, False)
-			cfg.worker_q.put(r)
-	except ValueError:
-		log_error("Trying to parse percentage which failed for %s" % line_str)
-
-
 def _move_merge(interface_name, command, job_state):
 	# We need to execute these command stand alone by forking & exec'ing
 	# the command always as we will be getting periodic output from them on
-	# the status of the long-running operation.
+	# the status of the long running operation.
+	command.insert(0, cfg.LVM_CMD)
 
-	meta = LvmExecutionMeta(time.time(), 0, command)
-	cfg.flightrecorder.add(meta)
+	# Instruct lvm to not register an event with us
+	command = add_no_notify(command)
 
-	ec, stdout, stderr = call_lvm(command, line_cb=_move_callback,
-									cb_data=job_state)
-	ended = time.time()
-	meta.completed(ended, ec, stdout, stderr)
+	#(self, start, ended, cmd, ec, stdout_txt, stderr_txt)
+	meta = LvmExecutionMeta(time.time(), 0, command, -1000, None, None)
 
-	if ec == 0:
+	cfg.blackbox.add(meta)
+
+	process = subprocess.Popen(command, stdout=subprocess.PIPE,
+								env=os.environ,
+								stderr=subprocess.PIPE, close_fds=True)
+
+	log_debug("Background process for %s is %d" %
+				(str(command), process.pid))
+
+	lines_iterator = iter(process.stdout.readline, b"")
+	for line in lines_iterator:
+		line_str = line.decode("utf-8")
+
+		# Check to see if the line has the correct number of separators
+		try:
+			if line_str.count(':') == 2:
+				(device, ignore, percentage) = line_str.split(':')
+				job_state.Percent = round(
+					float(percentage.strip()[:-1]), 1)
+
+				# While the move is in progress we need to periodically update
+				# the state to reflect where everything is at.
+				cfg.load()
+		except ValueError:
+			log_error("Trying to parse percentage which failed for %s" %
+				line_str)
+
+	out = process.communicate()
+
+	with meta.lock:
+		meta.ended = time.time()
+		meta.ec = process.returncode
+		meta.stderr_txt = out[1]
+
+	if process.returncode == 0:
 		job_state.Percent = 100
 	else:
 		raise dbus.exceptions.DBusException(
 			interface_name,
-			'Exit code %s, stderr = %s' % (str(ec), stderr))
+			'Exit code %s, stderr = %s' % (str(process.returncode), out[1]))
 
 	cfg.load()
 	return '/'

daemons/lvmdbusd/cfg.py

@@ -11,18 +11,11 @@ import os
 import multiprocessing
 import queue
 import itertools
-from lvmdbusd.utils import LvmDebugData
 
 from lvmdbusd import path
 
 LVM_CMD = os.getenv('LVM_BINARY', path.LVM_BINARY)
 
-LOCK_FILE = os.getenv("LVM_DBUSD_LOCKFILE", "/var/lock/lvm/lvmdbusd")
-
-# Save off the debug data needed for lvm team to debug issues
-# only used for 'fullreport' at this time.
-lvmdebug = LvmDebugData(os.getenv('LVM_DBUSD_COLLECT_LVM_DEBUG', False))
-
 # This is the global object manager
 om = None
 
@@ -32,13 +25,13 @@ bus = None
 # Command line args
 args = None
 
-# Set to true if we depend on external events for updates
+# Set to true if we are depending on external events for updates
 got_external_event = False
 
 # Shared state variable across all processes
 run = multiprocessing.Value('i', 1)
 
-# If this is set to true, the current setup support lvm shell, and we are
+# If this is set to true, the current setup support lvm shell and we are
 # running in that mode of operation
 SHELL_IN_USE = None
 
@@ -50,20 +43,13 @@ worker_q = queue.Queue()
 # Main event loop
 loop = None
 
-G_LOOP_TMO = 0.5
-
-# Used to instruct the daemon if we should ignore SIGTERM
-ignore_sigterm = False
-
 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'
@@ -75,7 +61,6 @@ 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'
@@ -86,7 +71,6 @@ 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()
@@ -95,30 +79,11 @@ hidden_lv = itertools.count()
 load = None
 event = None
 
-# Boolean to denote if lvm supports VDO integration
-vdo_support = False
-
 # Global cached state
 db = None
 
 # lvm flight recorder
-flightrecorder = None
+blackbox = None
 
 # RequestEntry ctor
 create_request_entry = None
-
-# Circular debug log
-debug = None
-
-
-def exit_daemon():
-    """
-    Exit the daemon cleanly
-    :return:
-    """
-    if run and loop:
-        run.value = 0
-        loop.quit()
-
-
-systemd = False

daemons/lvmdbusd/cmdhandler.py

@@ -6,18 +6,17 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
-import errno
+
 from subprocess import Popen, PIPE
-import select
 import time
 import threading
 from itertools import chain
 import collections
+import traceback
 import os
 
 from lvmdbusd import cfg
-from lvmdbusd.utils import pv_dest_ranges, log_debug, log_error, add_no_notify,\
-			make_non_block, read_decoded, extract_stack_trace, LvmBug, add_config_option, get_error_msg
+from lvmdbusd.utils import pv_dest_ranges, log_debug, log_error, add_no_notify
 from lvmdbusd.lvm_shell_proxy import LVMShellProxy
 
 try:
@@ -25,6 +24,7 @@ try:
 except ImportError:
 	import json
 
+SEP = '{|}'
 
 total_time = 0.0
 total_count = 0
@@ -36,7 +36,7 @@ cmd_lock = threading.RLock()
 
 class LvmExecutionMeta(object):
 
-	def __init__(self, start, ended, cmd, ec=-1000, stdout_txt=None, stderr_txt=None):
+	def __init__(self, start, ended, cmd, ec, stdout_txt, stderr_txt):
 		self.lock = threading.RLock()
 		self.start = start
 		self.ended = ended
@@ -47,49 +47,32 @@ class LvmExecutionMeta(object):
 
 	def __str__(self):
 		with self.lock:
-			if self.ended == 0:
-				ended_txt = "still running"
-				self.ended = time.time()
-			else:
-				ended_txt = str(time.ctime(self.ended))
-
-			return 'EC= %d for "%s"\n' \
-				"STARTED: %s, ENDED: %s, DURATION: %f\n" \
+			return "EC= %d for %s\n" \
+				"STARTED: %f, ENDED: %f\n" \
 				"STDOUT=%s\n" \
 				"STDERR=%s\n" % \
-				(self.ec, " ".join(self.cmd), time.ctime(self.start), ended_txt, float(self.ended) - self.start,
-					self.stdout_txt,
-					self.stderr_txt)
-
-	def completed(self, end_time, ec, stdout_txt, stderr_txt):
-		with self.lock:
-			self.ended = end_time
-			self.ec = ec
-			self.stdout_txt = stdout_txt
-			self.stderr_txt = stderr_txt
+				(self.ec, str(self.cmd), self.start, self.ended, self.stdout_txt,
+				self.stderr_txt)
 
 
 class LvmFlightRecorder(object):
 
 	def __init__(self, size=16):
 		self.queue = collections.deque(maxlen=size)
-		self.lock = threading.RLock()
 
 	def add(self, lvm_exec_meta):
-		with self.lock:
-			self.queue.append(lvm_exec_meta)
+		self.queue.append(lvm_exec_meta)
 
 	def dump(self):
-		with self.lock:
+		with cmd_lock:
 			if len(self.queue):
-				log_error("LVM dbus flight recorder START (in order of newest to oldest)")
-				for c in reversed(self.queue):
+				log_error("LVM dbus flight recorder START")
+				for c in self.queue:
 					log_error(str(c))
 				log_error("LVM dbus flight recorder END")
-				self.queue.clear()
 
 
-cfg.flightrecorder = LvmFlightRecorder()
+cfg.blackbox = LvmFlightRecorder()
 
 
 def _debug_c(cmd, exit_code, out):
@@ -99,95 +82,32 @@ def _debug_c(cmd, exit_code, out):
 	log_error(("STDERR=\n %s\n" % out[1]))
 
 
-def call_lvm(command, debug=False, line_cb=None,
-			 cb_data=None):
+def call_lvm(command, debug=False):
 	"""
 	Call an executable and return a tuple of exitcode, stdout, stderr
-	:param command: Command to execute
-	:param debug:   Dump debug to stdout
-	:param line_cb:	Call the supplied function for each line read from
-					stdin, CALL MUST EXECUTE QUICKLY and not *block*
-					otherwise call_lvm function will fail to read
-					stdin/stdout.  Return value of call back is ignored
-	:param cb_data: Supplied to call back to allow caller access to
-								its own data
-
-	# Callback signature
-	def my_callback(my_context, line_read_stdin)
-		pass
+	:param command:     Command to execute
+	:param debug:       Dump debug to stdout
 	"""
+	# print 'STACK:'
+	# for line in traceback.format_stack():
+	#    print line.strip()
+
 	# Prepend the full lvm executable so that we can run different versions
 	# in different locations on the same box
 	command.insert(0, cfg.LVM_CMD)
 	command = add_no_notify(command)
 
-	# Ensure we get an error message when we fork & exec the lvm command line
-	command = add_config_option(command, "--config", 'log/command_log_selection="log_context!=''"')
-
 	process = Popen(command, stdout=PIPE, stderr=PIPE, close_fds=True,
 					env=os.environ)
+	out = process.communicate()
 
-	stdout_text = ""
-	stderr_text = ""
-	stdout_index = 0
-	make_non_block(process.stdout)
-	make_non_block(process.stderr)
+	stdout_text = bytes(out[0]).decode("utf-8")
+	stderr_text = bytes(out[1]).decode("utf-8")
 
-	while True and cfg.run.value != 0:
-		try:
-			rd_fd = [process.stdout.fileno(), process.stderr.fileno()]
-			ready = select.select(rd_fd, [], [], cfg.G_LOOP_TMO)
-
-			for r in ready[0]:
-				if r == process.stdout.fileno():
-					stdout_text += read_decoded(process.stdout)
-				elif r == process.stderr.fileno():
-					stderr_text += read_decoded(process.stderr)
-
-			if line_cb is not None:
-				# Process the callback for each line read!
-				while True:
-					i = stdout_text.find("\n", stdout_index)
-					if i != -1:
-						try:
-							line_cb(cb_data, stdout_text[stdout_index:i])
-						except BaseException as be:
-							st = extract_stack_trace(be)
-							log_error("call_lvm: line_cb exception: \n %s" % st)
-						stdout_index = i + 1
-					else:
-						break
-
-			# Check to see if process has terminated, None when running
-			if process.poll() is not None:
-				break
-		except IOError as ioe:
-			log_debug("call_lvm:" + str(ioe))
-			break
-
-	if process.returncode is not None:
-		cfg.lvmdebug.lvm_complete()
-		if debug or (process.returncode != 0 and (process.returncode != 5 and "fullreport" in command)):
-			_debug_c(command, process.returncode, (stdout_text, stderr_text))
-
-		try:
-			report_json = json.loads(stdout_text)
-		except json.decoder.JSONDecodeError:
-			# Some lvm commands don't return json even though we are asking for it to do so.
-			return process.returncode, stdout_text, stderr_text
-
-		error_msg = get_error_msg(report_json)
-		if error_msg:
-			stderr_text += error_msg
-
-		return process.returncode, report_json, stderr_text
-	else:
-		if cfg.run.value == 0:
-			raise SystemExit
-		# We can bail out before the lvm command finished when we get a signal
-		# which is requesting we exit
-		return -errno.EINTR, "", "operation interrupted"
+	if debug or process.returncode != 0:
+		_debug_c(command, process.returncode, (stdout_text, stderr_text))
 
+	return process.returncode, stdout_text, stderr_text
 
 # The actual method which gets called to invoke the lvm command, can vary
 # from forking a new process to using lvm shell
@@ -202,18 +122,18 @@ def _shell_cfg():
 		_t_call = lvm_shell.call_lvm
 		cfg.SHELL_IN_USE = lvm_shell
 		return True
-	except Exception as e:
+	except Exception:
 		_t_call = call_lvm
 		cfg.SHELL_IN_USE = None
-		log_error("Unable to utilize lvm shell, dropping "
-				  "back to fork & exec\n%s" % extract_stack_trace(e))
+		log_error(traceback.format_exc())
+		log_error("Unable to utilize lvm shell, dropping back to fork & exec")
 		return False
 
 
 def set_execution(shell):
 	global _t_call
 	with cmd_lock:
-		# If the user requested lvm shell, and we are currently setup that
+		# If the user requested lvm shell and we are currently setup that
 		# way, just return
 		if cfg.SHELL_IN_USE and shell:
 			return True
@@ -237,15 +157,11 @@ def time_wrapper(command, debug=False):
 
 	with cmd_lock:
 		start = time.time()
-		meta = LvmExecutionMeta(start, 0, command)
-		# Add the partial metadata to flight recorder, so if the command hangs
-		# we will see what it was.
-		cfg.flightrecorder.add(meta)
 		results = _t_call(command, debug)
 		ended = time.time()
 		total_time += (ended - start)
 		total_count += 1
-		meta.completed(ended, *results)
+		cfg.blackbox.add(LvmExecutionMeta(start, ended, command, *results))
 	return results
 
 
@@ -255,11 +171,44 @@ call = time_wrapper
 # Default cmd
 # Place default arguments for every command here.
 def _dc(cmd, args):
-	c = [cmd, '--nosuffix', '--unbuffered', '--units', 'b']
+	c = [cmd, '--noheading', '--separator', '%s' % SEP, '--nosuffix',
+		'--unbuffered', '--units', 'b']
 	c.extend(args)
 	return c
 
 
+def parse(out):
+	rc = []
+
+	for line in out.split('\n'):
+		# This line includes separators, so process them
+		if SEP in line:
+			elem = line.split(SEP)
+			cleaned_elem = []
+			for e in elem:
+				e = e.strip()
+				cleaned_elem.append(e)
+
+			if len(cleaned_elem) > 1:
+				rc.append(cleaned_elem)
+		else:
+			t = line.strip()
+			if len(t) > 0:
+				rc.append(t)
+	return rc
+
+
+def parse_column_names(out, column_names):
+	lines = parse(out)
+	rc = []
+
+	for i in range(0, len(lines)):
+		d = dict(list(zip(column_names, lines[i])))
+		rc.append(d)
+
+	return rc
+
+
 def options_to_cli_args(options):
 	rc = []
 	for k, v in list(dict(options).items()):
@@ -268,10 +217,7 @@ def options_to_cli_args(options):
 		else:
 			rc.append("--%s" % k)
 		if v != "":
-			if isinstance(v, int):
-				rc.append(str(int(v)))
-			else:
-				rc.append(str(v))
+			rc.append(str(v))
 	return rc
 
 
@@ -317,26 +263,24 @@ def lv_tag(lv_name, add, rm, tag_options):
 	return _tag('lvchange', lv_name, add, rm, tag_options)
 
 
-def vg_rename(vg_uuid, new_name, rename_options):
+def vg_rename(vg, new_name, rename_options):
 	cmd = ['vgrename']
 	cmd.extend(options_to_cli_args(rename_options))
-	cmd.extend([vg_uuid, new_name])
+	cmd.extend([vg, new_name])
 	return call(cmd)
 
 
-def vg_remove(vg_id, remove_options):
+def vg_remove(vg_name, remove_options):
 	cmd = ['vgremove']
 	cmd.extend(options_to_cli_args(remove_options))
-	cmd.extend(['-f', vg_id])
-	# https://bugzilla.redhat.com/show_bug.cgi?id=2175220 is preventing us from doing the following
-	# cmd.extend(['-f', "--select", "vg_uuid=%s" % vg_id])
+	cmd.extend(['-f', vg_name])
 	return call(cmd)
 
 
 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', '%dB' % size_bytes])
+	cmd.extend(['--size', str(size_bytes) + 'B'])
 	cmd.extend(['--name', name, vg_name, '--yes'])
 	pv_dest_ranges(cmd, pv_dests)
 	return call(cmd)
@@ -348,7 +292,7 @@ def vg_lv_snapshot(vg_name, snapshot_options, name, size_bytes):
 	cmd.extend(["-s"])
 
 	if size_bytes != 0:
-		cmd.extend(['--size', '%dB' % size_bytes])
+		cmd.extend(['--size', str(size_bytes) + 'B'])
 
 	cmd.extend(['--name', name, vg_name])
 	return call(cmd)
@@ -359,9 +303,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', '%dB' % size_bytes])
+		cmd.extend(['--size', str(size_bytes) + 'B'])
 	else:
-		cmd.extend(['--thin', '--size', '%dB' % size_bytes])
+		cmd.extend(['--thin', '--size', str(size_bytes) + 'B'])
 
 	cmd.extend(['--yes'])
 	return cmd
@@ -376,10 +320,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(int(num_stripes))])
+	cmd.extend(['--stripes', str(num_stripes)])
 
 	if stripe_size_kb != 0:
-		cmd.extend(['--stripesize', str(int(stripe_size_kb))])
+		cmd.extend(['--stripesize', str(stripe_size_kb)])
 
 	cmd.extend(['--name', name, vg_name])
 	return call(cmd)
@@ -392,13 +336,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', '%dB' % size_bytes])
+	cmd.extend(['--size', str(size_bytes) + 'B'])
 
 	if num_stripes != 0:
-		cmd.extend(['--stripes', str(int(num_stripes))])
+		cmd.extend(['--stripes', str(num_stripes)])
 
 	if stripe_size_kb != 0:
-		cmd.extend(['--stripesize', str(int(stripe_size_kb))])
+		cmd.extend(['--stripesize', str(stripe_size_kb)])
 
 	cmd.extend(['--name', name, vg_name, '--yes'])
 	return call(cmd)
@@ -419,8 +363,8 @@ def vg_lv_create_mirror(
 	cmd.extend(options_to_cli_args(create_options))
 
 	cmd.extend(['--type', 'mirror'])
-	cmd.extend(['--mirrors', str(int(num_copies))])
-	cmd.extend(['--size', '%dB' % size_bytes])
+	cmd.extend(['--mirrors', str(num_copies)])
+	cmd.extend(['--size', str(size_bytes) + 'B'])
 	cmd.extend(['--name', name, vg_name, '--yes'])
 	return call(cmd)
 
@@ -441,24 +385,6 @@ 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 vg_create_vdo_pool(pool_full_name, lv_name, virtual_size, create_options):
-	cmd = ['lvconvert']
-	cmd.extend(options_to_cli_args(create_options))
-	cmd.extend(['--type', 'vdo-pool', '-n', lv_name, '--force', '-y',
-				'-V', '%dB' % virtual_size, pool_full_name])
-	return call(cmd)
-
-
 def lv_remove(lv_path, remove_options):
 	cmd = ['lvremove']
 	cmd.extend(options_to_cli_args(remove_options))
@@ -492,7 +418,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', '%dB' % size_bytes, '-T'])
+	cmd.extend(['--virtualsize', str(size_bytes) + 'B', '-T'])
 	cmd.extend(['--name', name, lv_full_name, '--yes'])
 	return call(cmd)
 
@@ -506,15 +432,6 @@ def lv_cache_lv(cache_pool_full_name, lv_full_name, cache_options):
 	return call(cmd)
 
 
-def lv_writecache_lv(cache_lv_full_name, lv_full_name, cache_options):
-	# lvconvert --type writecache --cachevol VG/CacheLV VG/OriginLV
-	cmd = ['lvconvert']
-	cmd.extend(options_to_cli_args(cache_options))
-	cmd.extend(['-y', '--type', 'writecache', '--cachevol',
-				cache_lv_full_name, lv_full_name])
-	return call(cmd)
-
-
 def lv_detach_cache(lv_full_name, detach_options, destroy_cache):
 	cmd = ['lvconvert']
 	if destroy_cache:
@@ -530,36 +447,6 @@ def lv_detach_cache(lv_full_name, detach_options, destroy_cache):
 	return call(cmd)
 
 
-def lv_vdo_compression(lv_path, enable, comp_options):
-	cmd = ['lvchange', '--compression']
-	if enable:
-		cmd.append('y')
-	else:
-		cmd.append('n')
-	cmd.extend(options_to_cli_args(comp_options))
-	cmd.append(lv_path)
-	return call(cmd)
-
-
-def lv_vdo_deduplication(lv_path, enable, dedup_options):
-	cmd = ['lvchange', '--deduplication']
-	if enable:
-		cmd.append('y')
-	else:
-		cmd.append('n')
-	cmd.extend(options_to_cli_args(dedup_options))
-	cmd.append(lv_path)
-	return call(cmd)
-
-
-def lv_raid_repair(lv_path, new_pvs, repair_options):
-	cmd = ['lvconvert', '-y', '--repair']
-	cmd.append(lv_path)
-	cmd.extend(new_pvs)
-	cmd.extend(options_to_cli_args(repair_options))
-	return call(cmd)
-
-
 def supports_json():
 	cmd = ['help']
 	rc, out, err = call(cmd)
@@ -572,16 +459,6 @@ 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',
@@ -609,47 +486,67 @@ 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),
 		'--configreport', 'vg', '-o', ','.join(vg_columns),
 		'--configreport', 'lv', '-o', ','.join(lv_columns),
 		'--configreport', 'seg', '-o', ','.join(lv_seg_columns),
-		'--configreport', 'pvseg', '-o', ','.join(pv_seg_columns)
+		'--configreport', 'pvseg', '-o', ','.join(pv_seg_columns),
+		'--reportformat', 'json'
 	])
 
-	# We are running the fullreport command, we will ask lvm to output the debug
-	# data, so we can have the required information for lvm to debug the fullreport failures.
-	# Note: this is disabled by default and can be enabled with env. var.
-	# LVM_DBUSD_COLLECT_LVM_DEBUG=True
-	fn = cfg.lvmdebug.setup()
-	if fn is not None:
-		add_config_option(cmd, "--config", "log {level=7 file=%s syslog=0}" % fn)
-
 	rc, out, err = call(cmd)
-	# When we have an exported vg the exit code of lvs or fullreport will be 5
-	if rc == 0 or rc == 5:
-		if type(out) != dict:
-			raise LvmBug("lvm likely returned invalid JSON, lvm exit code = %d, output = %s, err= %s" %
-						 (rc, str(out), str(err)))
-		return out
-	raise LvmBug("'fullreport' exited with code '%d'" % rc)
+	if rc == 0:
+		# With the current implementation, if we are using the shell then we
+		# are using JSON and JSON is returned back to us as it was parsed to
+		# figure out if we completed OK or not
+		if cfg.SHELL_IN_USE:
+			assert(type(out) == dict)
+			return out
+		else:
+			return json.loads(out)
+	return None
+
+
+def pv_retrieve_with_segs(device=None):
+	d = []
+	err = ""
+	out = ""
+	rc = 0
+
+	columns = ['pv_name', 'pv_uuid', 'pv_fmt', 'pv_size', 'pv_free',
+				'pv_used', 'dev_size', 'pv_mda_size', 'pv_mda_free',
+				'pv_ba_start', 'pv_ba_size', 'pe_start', 'pv_pe_count',
+				'pv_pe_alloc_count', 'pv_attr', 'pv_tags', 'vg_name',
+				'vg_uuid', 'pvseg_start', 'pvseg_size', 'segtype', 'pv_missing']
+
+	# Lvm has some issues where it returns failure when querying pvs when other
+	# operations are in process, see:
+	# https://bugzilla.redhat.com/show_bug.cgi?id=1274085
+	for i in range(0, 10):
+		cmd = _dc('pvs', ['-o', ','.join(columns)])
+
+		if device:
+			cmd.extend(device)
+
+		rc, out, err = call(cmd)
+
+		if rc == 0:
+			d = parse_column_names(out, columns)
+			break
+		else:
+			time.sleep(0.2)
+			log_debug("LVM Bug workaround, retrying pvs command...")
+
+	if rc != 0:
+		msg = "We were unable to get pvs to return without error after " \
+			"trying 10 times, RC=%d, STDERR=(%s), STDOUT=(%s)" % \
+			(rc, err, out)
+		log_error(msg)
+		raise RuntimeError(msg)
+
+	return d
 
 
 def pv_resize(device, size_bytes, create_options):
@@ -658,7 +555,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', '%dB' % size_bytes])
+		cmd.extend(['--yes', '--setphysicalvolumesize', str(size_bytes) + 'B'])
 
 	cmd.extend([device])
 	return call(cmd)
@@ -754,12 +651,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(int(number))],
+	return _vg_value_set(vg_name, ['--maxphysicalvolumes', str(number)],
 							max_options)
 
 
 def vg_max_lv(vg_name, number, max_options):
-	return _vg_value_set(vg_name, ['-l', str(int(number))], max_options)
+	return _vg_value_set(vg_name, ['-l', str(number)], max_options)
 
 
 def vg_uuid_gen(vg_name, ignore, options):
@@ -795,21 +692,63 @@ def activate_deactivate(op, name, activate, control_flags, options):
 		if (1 << 5) & control_flags:
 			cmd.append('--ignoreactivationskip')
 
-		# Shared locking (Cluster)
-		if (1 << 6) & control_flags:
-			op += 's'
-
 	if activate:
 		op += 'y'
 	else:
 		op += 'n'
 
 	cmd.append(op)
-	cmd.append("-y")
 	cmd.append(name)
 	return call(cmd)
 
 
+def vg_retrieve(vg_specific):
+	if vg_specific:
+		assert isinstance(vg_specific, list)
+
+	columns = ['vg_name', 'vg_uuid', 'vg_fmt', 'vg_size', 'vg_free',
+				'vg_sysid', 'vg_extent_size', 'vg_extent_count',
+				'vg_free_count', 'vg_profile', 'max_lv', 'max_pv',
+				'pv_count', 'lv_count', 'snap_count', 'vg_seqno',
+				'vg_mda_count', 'vg_mda_free', 'vg_mda_size',
+				'vg_mda_used_count', 'vg_attr', 'vg_tags']
+
+	cmd = _dc('vgs', ['-o', ','.join(columns)])
+
+	if vg_specific:
+		cmd.extend(vg_specific)
+
+	d = []
+	rc, out, err = call(cmd)
+	if rc == 0:
+		d = parse_column_names(out, columns)
+
+	return d
+
+
+def lv_retrieve_with_segments():
+	columns = ['lv_uuid', 'lv_name', 'lv_path', 'lv_size',
+				'vg_name', 'pool_lv_uuid', 'pool_lv', 'origin_uuid',
+				'origin', 'data_percent',
+				'lv_attr', 'lv_tags', 'vg_uuid', 'lv_active', 'data_lv',
+				'metadata_lv', 'seg_pe_ranges', 'segtype', 'lv_parent',
+				'lv_role', 'lv_layout',
+				'snap_percent', 'metadata_percent', 'copy_percent',
+				'sync_percent', 'lv_metadata_size', 'move_pv', 'move_pv_uuid']
+
+	cmd = _dc('lvs', ['-a', '-o', ','.join(columns)])
+	rc, out, err = call(cmd)
+
+	d = []
+
+	if rc == 0:
+		d = parse_column_names(out, columns)
+
+	return d
+
+
 if __name__ == '__main__':
-	# Leave this for future debug as needed
-	pass
+	pv_data = pv_retrieve_with_segs()
+
+	for p in pv_data:
+		print(str(p))

daemons/lvmdbusd/fetch.py

@@ -6,69 +6,32 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
-import errno
 
 from .pv import load_pvs
 from .vg import load_vgs
 from .lv import load_lvs
 from . import cfg
-from .utils import MThreadRunner, log_debug, log_error, LvmBug, extract_stack_trace
+from .utils import MThreadRunner, log_debug, log_error
 import threading
 import queue
-import time
+import traceback
 
 
 def _main_thread_load(refresh=True, emit_signal=True):
 	num_total_changes = 0
-	to_remove = []
 
-	(changes, remove) = load_pvs(
+	num_total_changes += load_pvs(
 		refresh=refresh,
 		emit_signal=emit_signal,
-		cache_refresh=False)[1:]
-	num_total_changes += changes
-	to_remove.extend(remove)
-
-	(changes, remove) = load_vgs(
+		cache_refresh=False)[1]
+	num_total_changes += load_vgs(
 		refresh=refresh,
 		emit_signal=emit_signal,
-		cache_refresh=False)[1:]
-
-	num_total_changes += changes
-	to_remove.extend(remove)
-
-	(lv_changes, remove) = load_lvs(
+		cache_refresh=False)[1]
+	num_total_changes += load_lvs(
 		refresh=refresh,
 		emit_signal=emit_signal,
-		cache_refresh=False)[1:]
-
-	num_total_changes += lv_changes
-	to_remove.extend(remove)
-
-	# 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:
-		(changes, remove) = load_vgs(
-			refresh=refresh,
-			emit_signal=emit_signal,
-			cache_refresh=False)[1:]
-
-	num_total_changes += changes
-	to_remove.extend(remove)
-
-	# Remove any objects that are no longer needed.  We do this after we process
-	# all the objects to ensure that references still exist for objects that
-	# are processed after them.
-	to_remove.reverse()
-	for i in to_remove:
-		dbus_obj = cfg.om.get_object_by_path(i)
-		if dbus_obj:
-			cfg.om.remove_object(dbus_obj, True)
-			num_total_changes += 1
+		cache_refresh=False)[1]
 
 	return num_total_changes
 
@@ -119,126 +82,74 @@ class StateUpdate(object):
 
 	@staticmethod
 	def update_thread(obj):
-		exception_count = 0
 		queued_requests = []
-
-		def set_results(val):
-			nonlocal queued_requests
-			for idx in queued_requests:
-				idx.set_result(val)
-				# Only clear out the requests after we have given them a result
-				# otherwise we can orphan the waiting threads, and they never
-				# wake up if we get an exception
-				queued_requests = []
-
-		def bailing(rv):
-			set_results(rv)
-			try:
-				while True:
-					item = obj.queue.get(False)
-					item.set_result(rv)
-			except queue.Empty:
-				pass
-
-		def _load_args(requests):
-			"""
-			If we have multiple requests in the queue, they might not all have the same options.  If any of the requests
-			have an option set we need to honor it.
-			"""
-			refresh = any([r.refresh for r in requests])
-			emit_signal = any([r.emit_signal for r in requests])
-			cache_refresh = any([r.cache_refresh for r in requests])
-			log = any([r.log for r in requests])
-			need_main_thread = any([r.need_main_thread for r in requests])
-
-			return refresh, emit_signal, cache_refresh, log, need_main_thread
-
-		def _drain_queue(queued, incoming):
-			try:
-				while True:
-					queued.append(incoming.get(block=False))
-			except queue.Empty:
-				pass
-
-		def _handle_error():
-			nonlocal exception_count
-			exception_count += 1
-
-			if exception_count >= 5:
-				log_error("Too many errors in update_thread, exiting daemon")
-				cfg.debug.dump()
-				cfg.flightrecorder.dump()
-				bailing(errno.EFAULT)
-				cfg.exit_daemon()
-			else:
-				# Slow things down when encountering errors
-				cfg.lvmdebug.complete()
-				time.sleep(1)
-
 		while cfg.run.value != 0:
 			# noinspection PyBroadException
 			try:
+				refresh = True
+				emit_signal = True
+				cache_refresh = True
+				log = True
+				need_main_thread = True
+
 				with obj.lock:
 					wait = not obj.deferred
 					obj.deferred = False
 
 				if len(queued_requests) == 0 and wait:
-					# Note: If we don't have anything for N seconds we will
-					# get a queue.Empty exception raised here
-					queued_requests.append(obj.queue.get(block=True, timeout=cfg.G_LOOP_TMO))
+					queued_requests.append(obj.queue.get(True, 2))
 
 				# Ok we have one or the deferred queue has some,
-				# check if any others and grab them too
-				_drain_queue(queued_requests, obj.queue)
+				# check if any others
+				try:
+					while True:
+						queued_requests.append(obj.queue.get(False))
+
+				except queue.Empty:
+					pass
 
 				if len(queued_requests) > 1:
 					log_debug("Processing %d updates!" % len(queued_requests),
 							'bg_black', 'fg_light_green')
 
-				num_changes = load(*_load_args(queued_requests))
-				# Update is done, let everyone know!
-				set_results(num_changes)
+				# We have what we can, run the update with the needed options
+				for i in queued_requests:
+					if not i.refresh:
+						refresh = False
+					if not i.emit_signal:
+						emit_signal = False
+					if not i.cache_refresh:
+						cache_refresh = False
+					if not i.log:
+						log = False
+					if not i.need_main_thread:
+						need_main_thread = False
 
-				# We retrieved OK, clear exception count
-				exception_count = 0
+				num_changes = load(refresh, emit_signal, cache_refresh, log,
+									need_main_thread)
+				# Update is done, let everyone know!
+				for i in queued_requests:
+					i.set_result(num_changes)
+
+				# Only clear out the requests after we have given them a result
+				# otherwise we can orphan the waiting threads and they never
+				# wake up if we get an exception
+				queued_requests = []
 
 			except queue.Empty:
 				pass
-			except SystemExit:
-				break
-			except LvmBug as bug:
-				# If a lvm bug occurred, we will dump the lvm debug data if
-				# we have it.
-				cfg.lvmdebug.dump()
-				log_error(str(bug))
-				_handle_error()
-			except Exception as e:
-				log_error("update_thread: \n%s" % extract_stack_trace(e))
-				_handle_error()
-			finally:
-				cfg.lvmdebug.complete()
-
-		# Make sure to unblock any that may be waiting before we exit this thread
-		# otherwise they hang forever ...
-		bailing(Exception("update thread exiting"))
-		log_debug("update thread exiting!")
+			except Exception:
+				st = traceback.format_exc()
+				log_error("update_thread exception: \n%s" % st)
+				cfg.blackbox.dump()
 
 	def __init__(self):
 		self.lock = threading.RLock()
 		self.queue = queue.Queue()
 		self.deferred = False
 
-		# Do initial load, with retries.  During error injection testing we can and do fail here.
-		count = 0
-		need_refresh = False  # First attempt we are building from new, any subsequent will be true
-		while count < 5:
-			try:
-				load(refresh=need_refresh, emit_signal=False, need_main_thread=False)
-				break
-			except LvmBug as bug:
-				count += 1
-				need_refresh = True
-				log_error("We encountered an lvm bug on initial load, trying again %s" % str(bug))
+		# Do initial load
+		load(refresh=False, emit_signal=False, need_main_thread=False)
 
 		self.thread = threading.Thread(target=StateUpdate.update_thread,
 										args=(self,),

daemons/lvmdbusd/job.py

@@ -44,7 +44,7 @@ class WaitingClient(object):
 			self.timer_id = GLib.timeout_add_seconds(
 				tmo, WaitingClient._timeout, self)
 
-	# The job finished before the timer popped, and we are being notified that
+	# The job finished before the timer popped and we are being notified that
 	# it's done
 	def notify(self):
 		with self.rlock:
@@ -71,7 +71,7 @@ class JobState(object):
 		self._stderr = ''
 		self._waiting_clients = []
 
-		# This is a lvm command that is just taking too long and doesn't
+		# This is an lvm command that is just taking too long and doesn't
 		# support background operation
 		if self._request:
 			# Faking the percentage when we don't have one
@@ -138,7 +138,7 @@ class JobState(object):
 		# If a waiting client timer pops before the job is done we will allow
 		# the client to remove themselves from the list.  As we have a lock
 		# here and a lock in the waiting client too, and they can be obtained
-		# in different orders, a deadlock can occur.
+		# in different orders, a dead lock can occur.
 		# As this remove is really optional, we will try to acquire the lock
 		# and remove.  If we are unsuccessful it's not fatal, we just delay
 		# the time when the objects can be garbage collected by python
@@ -226,21 +226,3 @@ class Job(AutomatedProperties):
 	def Uuid(self):
 		import uuid
 		return uuid.uuid1()
-
-	# Override the property "getters" implementation for the job interface, so a user can query a job while the queue
-	# is processing items.  Originally all the property get methods were this way, but we changed this in
-	# e53454d6de07de56736303dd2157c3859f6fa848
-
-	# Properties
-	# noinspection PyUnusedLocal
-	@dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE,
-						 in_signature='ss', out_signature='v')
-	def Get(self, interface_name, property_name):
-		# Note: If we get an exception in this handler we won't know about it,
-		# only the side effect of no returned value!
-		return AutomatedProperties._get_prop(self, interface_name, property_name)
-
-	@dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE,
-						 in_signature='s', out_signature='a{sv}')
-	def GetAll(self, interface_name):
-		return AutomatedProperties._get_all_prop(self, interface_name)

daemons/lvmdbusd/loader.py

@@ -42,7 +42,7 @@ def common(retrieve, o_type, search_keys,
 		existing_paths = cfg.om.object_paths_by_type(o_type)
 
 	for o in objects:
-		# Assume we need to add this one to dbus, unless we are refreshing,
+		# Assume we need to add this one to dbus, unless we are refreshing
 		# and it's already present
 		return_object = True
 
@@ -75,10 +75,11 @@ def common(retrieve, o_type, search_keys,
 
 		object_path = None
 
-	to_remove = []
 	if refresh:
-		to_remove = list(existing_paths.keys())
+		for k in list(existing_paths.keys()):
+			cfg.om.remove_object(cfg.om.get_object_by_path(k), True)
+			num_changes += 1
 
 	num_changes += len(rc)
 
-	return rc, num_changes, to_remove
+	return rc, num_changes

daemons/lvmdbusd/lv.py

@@ -10,23 +10,23 @@
 from .automatedproperties import AutomatedProperties
 
 from . import utils
-from .utils import vg_obj_path_generate, log_error, _handle_execute, LvmBug
+from .utils import vg_obj_path_generate
 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, VDO_POOL_INTERFACE
+	LV_COMMON_INTERFACE, CACHE_POOL_INTERFACE, LV_CACHED
 from .request import RequestEntry
-from .utils import n, n32, d
+from .utils import n, n32
 from .loader import common
 from .state import State
 from . import background
-from .utils import round_size, mt_remove_dbus_objects, lvm_column_key
+from .utils import round_size, mt_remove_dbus_objects
 from .job import JobState
 
 
-# Try and build a key for a LV, so that we sort the LVs with the least dependencies
-# first.  This may be error-prone because of the flexibility LVM
+# Try and build a key for a LV, so that we sort the LVs with least dependencies
+# first.  This may be error prone because of the flexibility LVM
 # provides and what you can stack.
 def get_key(i):
 
@@ -65,80 +65,30 @@ def lvs_state_retrieve(selection, cache_refresh=True):
 	if cache_refresh:
 		cfg.db.refresh()
 
-	try:
-		# When building up the model, it's best to process LVs with the least
-		# dependencies to those that are dependent upon other LVs.  Otherwise, when
-		# we are trying to gather information we could be in a position where we
-		# don't have information available yet.
-		lvs = sorted(cfg.db.fetch_lvs(selection), key=get_key)
+	# When building up the model, it's best to process LVs with the least
+	# dependencies to those that are dependant upon other LVs.  Otherwise, when
+	# we are trying to gather information we could be in a position where we
+	# don't have information available yet.
+	lvs = sorted(cfg.db.fetch_lvs(selection), key=get_key)
 
-		for l in lvs:
-			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']))
-	except KeyError as ke:
-		# Sometimes lvm omits returning one of the keys we requested.
-		key = ke.args[0]
-		if lvm_column_key(key):
-			raise LvmBug("missing JSON key: '%s'" % key)
-		raise ke
+	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']))
 	return rc
 
 
@@ -242,8 +192,6 @@ 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
@@ -270,34 +218,6 @@ 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')
@@ -353,7 +273,13 @@ class LvCommon(AutomatedProperties):
 
 	@staticmethod
 	def handle_execute(rc, out, err):
-		_handle_execute(rc, out, err, LV_INTERFACE)
+		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))
 
 	@staticmethod
 	def validate_dbus_object(lv_uuid, lv_name):
@@ -365,22 +291,6 @@ 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 as b:
-			st = utils.extract_stack_trace(b)
-			log_error("attr_struct: \n%s" % st)
-			return dbus.Struct(('?', 'Unavailable'), signature="(ss)")
-
 	@property
 	def VolumeType(self):
 		type_map = {'C': 'Cache', 'm': 'mirrored',
@@ -393,16 +303,17 @@ 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', 'g': 'integrity',
 					'-': 'Unspecified'}
-		return self.attr_struct(0, type_map)
+		return dbus.Struct((self.state.Attr[0], type_map[self.state.Attr[0]]),
+						signature="as")
 
 	@property
 	def Permissions(self):
 		type_map = {'w': 'writable', 'r': 'read-only',
 					'R': 'Read-only activation of non-read-only volume',
 					'-': 'Unspecified'}
-		return self.attr_struct(1, type_map)
+		return dbus.Struct((self.state.Attr[1], type_map[self.state.Attr[1]]),
+						signature="(ss)")
 
 	@property
 	def AllocationPolicy(self):
@@ -411,7 +322,8 @@ class LvCommon(AutomatedProperties):
 					'i': 'inherited', 'I': 'inherited locked',
 					'l': 'cling', 'L': 'cling locked',
 					'n': 'normal', 'N': 'normal locked', '-': 'Unspecified'}
-		return self.attr_struct(2, type_map)
+		return dbus.Struct((self.state.Attr[2], type_map[self.state.Attr[2]]),
+						signature="(ss)")
 
 	@property
 	def FixedMinor(self):
@@ -419,20 +331,15 @@ 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',
-					'h': 'historical',
-					'c': 'check needed suspended thin-pool',
-					'C': 'check needed',
-					'X': 'unknown',
-					'-': 'Unspecified'}
-		return self.attr_struct(4, type_map)
+					'X': 'unknown', '-': 'Unspecified'}
+		return dbus.Struct((self.state.Attr[4], type_map[self.state.Attr[4]]),
+						signature="(ss)")
 
 	@property
 	def TargetType(self):
@@ -448,18 +355,11 @@ class LvCommon(AutomatedProperties):
 
 	@property
 	def Health(self):
-		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)
+		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)")
 
 	@property
 	def SkipActivation(self):
@@ -529,7 +429,8 @@ 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
-		LvCommon.handle_execute(*cmdhandler.lv_remove(lv_name, remove_options))
+		rc, out, err = cmdhandler.lv_remove(lv_name, remove_options)
+		LvCommon.handle_execute(rc, out, err)
 		return '/'
 
 	@dbus.service.method(
@@ -549,8 +450,9 @@ class Lv(LvCommon):
 		# Make sure we have a dbus object representing it
 		LvCommon.validate_dbus_object(lv_uuid, lv_name)
 		# Rename the logical volume
-		LvCommon.handle_execute(*cmdhandler.lv_rename(lv_name, new_name,
-												rename_options))
+		rc, out, err = cmdhandler.lv_rename(lv_name, new_name,
+											rename_options)
+		LvCommon.handle_execute(rc, out, err)
 		return '/'
 
 	@dbus.service.method(
@@ -599,11 +501,13 @@ class Lv(LvCommon):
 				remainder = space % 512
 				optional_size = space + 512 - remainder
 
-		LvCommon.handle_execute(*cmdhandler.vg_lv_snapshot(
-			lv_name, snapshot_options, name, optional_size))
+		rc, out, err = cmdhandler.vg_lv_snapshot(
+			lv_name, snapshot_options, name, optional_size)
+		LvCommon.handle_execute(rc, out, err)
 		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}',
@@ -639,8 +543,9 @@ class Lv(LvCommon):
 				pv_dests.append((pv_dbus_obj.lvm_id, pr[1], pr[2]))
 
 		size_change = new_size_bytes - dbo.SizeBytes
-		LvCommon.handle_execute(*cmdhandler.lv_resize(
-			dbo.lvm_id, size_change, pv_dests, resize_options))
+		rc, out, err = cmdhandler.lv_resize(dbo.lvm_id, size_change,
+											pv_dests, resize_options)
+		LvCommon.handle_execute(rc, out, err)
 		return "/"
 
 	@dbus.service.method(
@@ -675,8 +580,9 @@ class Lv(LvCommon):
 								options):
 		# Make sure we have a dbus object representing it
 		LvCommon.validate_dbus_object(uuid, lv_name)
-		LvCommon.handle_execute(*cmdhandler.activate_deactivate(
-			'lvchange', lv_name, activate, control_flags, options))
+		rc, out, err = cmdhandler.activate_deactivate(
+			'lvchange', lv_name, activate, control_flags, options)
+		LvCommon.handle_execute(rc, out, err)
 		return '/'
 
 	@dbus.service.method(
@@ -710,8 +616,9 @@ 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)
-		LvCommon.handle_execute(*cmdhandler.lv_tag(
-			lv_name, tags_add, tags_del, tag_options))
+		rc, out, err = cmdhandler.lv_tag(
+			lv_name, tags_add, tags_del, tag_options)
+		LvCommon.handle_execute(rc, out, err)
 		return '/'
 
 	@dbus.service.method(
@@ -748,190 +655,6 @@ class Lv(LvCommon):
 			cb, cbe, return_tuple=False)
 		cfg.worker_q.put(r)
 
-	@staticmethod
-	def _caching_common(method, lv_uuid, lv_name, lv_object_path, cache_options):
-		# Make sure we have a dbus object representing it
-		dbo = LvCommon.validate_dbus_object(lv_uuid, lv_name)
-
-		# Make sure we have dbus object representing lv to cache
-		lv_to_cache = cfg.om.get_object_by_path(lv_object_path)
-
-		if lv_to_cache:
-			fcn = lv_to_cache.lv_full_name()
-			rc, out, err = method(
-				dbo.lv_full_name(), fcn, cache_options)
-			if rc == 0:
-				# When we cache an LV, the cache pool and the lv that is getting
-				# cached need to be removed from the object manager and
-				# re-created as their interfaces have changed!
-				mt_remove_dbus_objects((dbo, lv_to_cache))
-				cfg.load()
-
-				lv_converted = cfg.om.get_object_path_by_lvm_id(fcn)
-			else:
-				raise dbus.exceptions.DBusException(
-					LV_INTERFACE,
-					'Exit code %s, stderr = %s' % (str(rc), err))
-		else:
-			raise dbus.exceptions.DBusException(
-				LV_INTERFACE, 'LV to cache with object path %s not present!' %
-							  lv_object_path)
-		return lv_converted
-
-	@staticmethod
-	def _writecache_lv(lv_uuid, lv_name, lv_object_path, cache_options):
-		return Lv._caching_common(cmdhandler.lv_writecache_lv, lv_uuid,
-									lv_name, lv_object_path, cache_options)
-
-	@dbus.service.method(
-		dbus_interface=LV_INTERFACE,
-		in_signature='oia{sv}',
-		out_signature='(oo)',
-		async_callbacks=('cb', 'cbe'))
-	def WriteCacheLv(self, lv_object, tmo, cache_options, cb, cbe):
-		r = RequestEntry(
-			tmo, Lv._writecache_lv,
-			(self.Uuid, self.lvm_id, lv_object,
-			cache_options), cb, cbe)
-		cfg.worker_q.put(r)
-
-	@staticmethod
-	def _repair_raid_lv(lv_uuid, lv_name, new_pvs, repair_options):
-		# Make sure we have a dbus object representing it
-		pv_dests = []
-		dbo = LvCommon.validate_dbus_object(lv_uuid, lv_name)
-
-		# If we have PVs, verify them
-		if len(new_pvs):
-			for pv in new_pvs:
-				pv_dbus_obj = cfg.om.get_object_by_path(pv)
-				if not pv_dbus_obj:
-					raise dbus.exceptions.DBusException(
-						LV_INTERFACE,
-						'PV Destination (%s) not found' % pv)
-
-				pv_dests.append(pv_dbus_obj.lvm_id)
-
-		LvCommon.handle_execute(*cmdhandler.lv_raid_repair(
-			dbo.lvm_id, pv_dests, repair_options))
-		return "/"
-
-	@dbus.service.method(
-		dbus_interface=LV_INTERFACE,
-		in_signature='aoia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
-	def RepairRaidLv(self, new_pvs, tmo, repair_options, cb, cbe):
-		r = RequestEntry(
-			tmo, Lv._repair_raid_lv,
-			(self.Uuid, self.lvm_id, new_pvs,
-			repair_options), 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)
-
-	@staticmethod
-	def _enable_disable_compression(pool_uuid, pool_name, enable, comp_options):
-		# Make sure we have a dbus object representing it
-		LvCommon.validate_dbus_object(pool_uuid, pool_name)
-		# Rename the logical volume
-		LvCommon.handle_execute(*cmdhandler.lv_vdo_compression(
-			pool_name, enable, comp_options))
-		return '/'
-
-	@dbus.service.method(
-		dbus_interface=VDO_POOL_INTERFACE,
-		in_signature='ia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
-	def EnableCompression(self, tmo, comp_options, cb, cbe):
-		r = RequestEntry(
-			tmo, LvVdoPool._enable_disable_compression,
-			(self.Uuid, self.lvm_id, True, comp_options),
-			cb, cbe, False)
-		cfg.worker_q.put(r)
-
-	@dbus.service.method(
-		dbus_interface=VDO_POOL_INTERFACE,
-		in_signature='ia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
-	def DisableCompression(self, tmo, comp_options, cb, cbe):
-		r = RequestEntry(
-			tmo, LvVdoPool._enable_disable_compression,
-			(self.Uuid, self.lvm_id, False, comp_options),
-			cb, cbe, False)
-		cfg.worker_q.put(r)
-
-	@staticmethod
-	def _enable_disable_deduplication(pool_uuid, pool_name, enable, dedup_options):
-		# Make sure we have a dbus object representing it
-		LvCommon.validate_dbus_object(pool_uuid, pool_name)
-		# Rename the logical volume
-		LvCommon.handle_execute(*cmdhandler.lv_vdo_deduplication(
-			pool_name, enable, dedup_options))
-		return '/'
-
-	@dbus.service.method(
-		dbus_interface=VDO_POOL_INTERFACE,
-		in_signature='ia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
-	def EnableDeduplication(self, tmo, dedup_options, cb, cbe):
-		r = RequestEntry(
-			tmo, LvVdoPool._enable_disable_deduplication,
-			(self.Uuid, self.lvm_id, True, dedup_options),
-			cb, cbe, False)
-		cfg.worker_q.put(r)
-
-	@dbus.service.method(
-		dbus_interface=VDO_POOL_INTERFACE,
-		in_signature='ia{sv}',
-		out_signature='o',
-		async_callbacks=('cb', 'cbe'))
-	def DisableDeduplication(self, tmo, dedup_options, cb, cbe):
-		r = RequestEntry(
-			tmo, LvVdoPool._enable_disable_deduplication,
-			(self.Uuid, self.lvm_id, False, dedup_options),
-			cb, cbe, False)
-		cfg.worker_q.put(r)
-
 
 # noinspection PyPep8Naming
 class LvThinPool(Lv):
@@ -955,8 +678,10 @@ 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)
-		LvCommon.handle_execute(*cmdhandler.lv_lv_create(
-			lv_name, create_options, name, size_bytes))
+
+		rc, out, err = cmdhandler.lv_lv_create(
+			lv_name, create_options, name, size_bytes)
+		LvCommon.handle_execute(rc, out, err)
 		full_name = "%s/%s" % (dbo.vg_name_lookup(), name)
 		return cfg.om.get_object_path_by_lvm_id(full_name)
 
@@ -995,8 +720,33 @@ class LvCachePool(Lv):
 
 	@staticmethod
 	def _cache_lv(lv_uuid, lv_name, lv_object_path, cache_options):
-		return Lv._caching_common(cmdhandler.lv_cache_lv, lv_uuid, lv_name,
-									lv_object_path, cache_options)
+		# Make sure we have a dbus object representing cache pool
+		dbo = LvCommon.validate_dbus_object(lv_uuid, lv_name)
+
+		# Make sure we have dbus object representing lv to cache
+		lv_to_cache = cfg.om.get_object_by_path(lv_object_path)
+
+		if lv_to_cache:
+			fcn = lv_to_cache.lv_full_name()
+			rc, out, err = cmdhandler.lv_cache_lv(
+				dbo.lv_full_name(), fcn, cache_options)
+			if rc == 0:
+				# When we cache an LV, the cache pool and the lv that is getting
+				# cached need to be removed from the object manager and
+				# re-created as their interfaces have changed!
+				mt_remove_dbus_objects((dbo, lv_to_cache))
+				cfg.load()
+
+				lv_converted = cfg.om.get_object_path_by_lvm_id(fcn)
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE, 'LV to cache with object path %s not present!' %
+				lv_object_path)
+		return lv_converted
 
 	@dbus.service.method(
 		dbus_interface=CACHE_POOL_INTERFACE,

daemons/lvmdbusd/lvm_shell_proxy.py.in

@@ -13,13 +13,14 @@
 
 import subprocess
 import shlex
+from fcntl import fcntl, F_GETFL, F_SETFL
 import os
-import pty
+import traceback
 import sys
 import tempfile
 import time
-import threading
 import select
+import copy
 
 try:
 	import simplejson as json
@@ -27,9 +28,8 @@ except ImportError:
 	import json
 
 
-import lvmdbusd.cfg as cfg
-from lvmdbusd.utils import log_debug, log_error, add_no_notify, make_non_block,\
-			read_decoded, extract_stack_trace, LvmBug, get_error_msg
+from lvmdbusd.cfg import LVM_CMD
+from lvmdbusd.utils import log_debug, log_error, add_no_notify
 
 SHELL_PROMPT = "lvm> "
 
@@ -43,11 +43,17 @@ def _quote_arg(arg):
 
 class LVMShellProxy(object):
 
-	# Read REPORT FD until we have a complete and valid JSON record or give
-	# up trying to get one.
-	#
-	# Returns stdout, report (JSON), stderr
-	def _read_response(self, no_output=False):
+	@staticmethod
+	def _read(stream):
+		tmp = stream.read()
+		if tmp:
+			return tmp.decode("utf-8")
+		return ''
+
+	# Read until we get prompt back and a result
+	# @param: no_output	Caller expects no output to report FD
+	# Returns stdout, report, stderr (report is JSON!)
+	def _read_until_prompt(self, no_output=False):
 		stdout = ""
 		report = ""
 		stderr = ""
@@ -59,27 +65,24 @@ class LVMShellProxy(object):
 		# Try reading from all FDs to prevent one from filling up and causing
 		# a hang.  Keep reading until we get the prompt back and the report
 		# FD does not contain valid JSON
-
-		while keep_reading and cfg.run.value != 0:
+		while keep_reading:
 			try:
 				rd_fd = [
-					self.parent_stdout_fd,
+					self.lvm_shell.stdout.fileno(),
 					self.report_stream.fileno(),
-					self.parent_stderr_fd]
-				ready = select.select(rd_fd, [], [], cfg.G_LOOP_TMO)
+					self.lvm_shell.stderr.fileno()]
+				ready = select.select(rd_fd, [], [], 2)
 
 				for r in ready[0]:
-					if r == self.parent_stdout_fd:
-						for line in self.parent_stdout.readlines():
-							stdout += line
+					if r == self.lvm_shell.stdout.fileno():
+						stdout += LVMShellProxy._read(self.lvm_shell.stdout)
 					elif r == self.report_stream.fileno():
-						report += read_decoded(self.report_stream)
-					elif r == self.parent_stderr_fd:
-						for line in self.parent_stderr.readlines():
-							stderr += line
+						report += LVMShellProxy._read(self.report_stream)
+					elif r == self.lvm_shell.stderr.fileno():
+						stderr += LVMShellProxy._read(self.lvm_shell.stderr)
 
 				# Check to see if the lvm process died on us
-				if self.lvm_shell.poll() is not None:
+				if self.lvm_shell.poll():
 					raise Exception(self.lvm_shell.returncode, "%s" % stderr)
 
 				if stdout.endswith(SHELL_PROMPT):
@@ -103,106 +106,96 @@ class LVMShellProxy(object):
 							extra_passes -= 1
 							if extra_passes <= 0:
 								if len(report):
-									raise LvmBug("Invalid json: %s" %
+									raise ValueError("Invalid json: %s" %
 														report)
 								else:
-									raise LvmBug(
+									raise ValueError(
 										"lvm returned no JSON output!")
-			except Exception as e:
-				log_error("While reading from lvm shell we encountered an error %s" % str(e))
-				log_error("stdout= %s\nstderr= %s\n" % (stdout, stderr))
-				if self.lvm_shell.poll() is not None:
-					log_error("Underlying lvm shell process unexpectedly exited: %d" % self.lvm_shell.returncode)
-				else:
-					log_error("Underlying lvm shell process is still present!")
-				raise e
 
-		if keep_reading and cfg.run.value == 0:
-			# We didn't complete as we are shutting down
-			# Try to clean up lvm shell process
-			log_debug("exiting lvm shell as we are shutting down")
-			self.exit_shell()
-			raise SystemExit
+			except IOError as ioe:
+				log_debug(str(ioe))
+				pass
 
 		return stdout, report_json, stderr
 
 	def _write_cmd(self, cmd):
-		self.parent_stdin.write(cmd)
-		self.parent_stdin.flush()
+		cmd_bytes = bytes(cmd, "utf-8")
+		num_written = self.lvm_shell.stdin.write(cmd_bytes)
+		assert (num_written == len(cmd_bytes))
+		self.lvm_shell.stdin.flush()
+
+	@staticmethod
+	def _make_non_block(stream):
+		flags = fcntl(stream, F_GETFL)
+		fcntl(stream, F_SETFL, flags | os.O_NONBLOCK)
 
 	def __init__(self):
+
 		# Create a temp directory
 		tmp_dir = tempfile.mkdtemp(prefix="lvmdbus_")
 		tmp_file = "%s/lvmdbus_report" % (tmp_dir)
 
-		# Create a lock so that we don't step on each other when we are waiting for a command
-		# to finish and some other request comes in concurrently, like to exit the shell.
-		self.shell_lock = threading.RLock()
+		try:
+			# Lets create fifo for the report output
+			os.mkfifo(tmp_file, 0o600)
+		except FileExistsError:
+			pass
 
-		# Create a fifo for the report output
-		os.mkfifo(tmp_file, 0o600)
-
-		# Open the fifo for use to read and for lvm child process to write to.
+		# We have to open non-blocking as the other side isn't open until
+		# we actually fork the process.
 		self.report_fd = os.open(tmp_file, os.O_NONBLOCK)
 		self.report_stream = os.fdopen(self.report_fd, 'rb', 0)
-		lvm_fd = os.open(tmp_file, os.O_WRONLY)
 
-		# Set up the environment for using our own socket for reporting and disable the abort
-		# logic if lvm logs too much, which easily happens when utilizing the lvm shell.
-		local_env = {"LC_ALL": "C", "LVM_REPORT_FD": "%s" % lvm_fd, "LVM_COMMAND_PROFILE": "lvmdbusd",
-					 "LVM_LOG_FILE_MAX_LINES": "0"}
+		# Setup the environment for using our own socket for reporting
+		local_env = copy.deepcopy(os.environ)
+		local_env["LVM_REPORT_FD"] = "32"
+		local_env["LVM_COMMAND_PROFILE"] = "lvmdbusd"
 
-		# If any env variables contain LVM we will propagate them too
-		for k, v in os.environ.items():
-			if "PATH" in k:
-				local_env[k] = v
-			if "LVM" in k:
-				local_env[k] = v
-
-		self.parent_stdin_fd, child_stdin_fd = pty.openpty()
-		self.parent_stdout_fd, child_stdout_fd = pty.openpty()
-		self.parent_stderr_fd, child_stderr_fd = pty.openpty()
-		self.parent_stdin = os.fdopen(self.parent_stdin_fd, "w")
-		self.parent_stdout = os.fdopen(self.parent_stdout_fd, "r")
-		self.parent_stderr = os.fdopen(self.parent_stderr_fd, "r")
+		# Disable the abort logic if lvm logs too much, which easily happens
+		# when utilizing the lvm shell.
+		local_env["LVM_LOG_FILE_MAX_LINES"] = "0"
 
 		# run the lvm shell
 		self.lvm_shell = subprocess.Popen(
-			[cfg.LVM_CMD],
-			stdin=child_stdin_fd,
-			stdout=child_stdout_fd, env=local_env,
-			stderr=child_stderr_fd, close_fds=True,
-			pass_fds=(lvm_fd,), shell=False)
+			[LVM_CMD + " 32>%s" % tmp_file],
+			stdin=subprocess.PIPE, stdout=subprocess.PIPE, env=local_env,
+			stderr=subprocess.PIPE, close_fds=True, shell=True)
 
 		try:
-			make_non_block(self.parent_stdout_fd)
-			make_non_block(self.parent_stderr_fd)
-
-			# Close our copies of the child FDs there were created with the fork, we don't need them open.
-			os.close(lvm_fd)
-			os.close(child_stdin_fd)
-			os.close(child_stdout_fd)
-			os.close(child_stderr_fd)
+			LVMShellProxy._make_non_block(self.lvm_shell.stdout)
+			LVMShellProxy._make_non_block(self.lvm_shell.stderr)
 
 			# wait for the first prompt
-			log_debug("waiting for first prompt...")
-			errors = self._read_response(no_output=True)[2]
+			errors = self._read_until_prompt(no_output=True)[2]
 			if errors and len(errors):
-				raise LvmBug(errors)
-			log_debug("lvm prompt read!!!")
+				raise RuntimeError(errors)
 		except:
 			raise
 		finally:
-			# These will get deleted when the FD count goes to zero, so we
+			# These will get deleted when the FD count goes to zero so we
 			# can be sure to clean up correctly no matter how we finish
 			os.unlink(tmp_file)
 			os.rmdir(tmp_dir)
 
-	def _get_last_log(self):
-		# Precondition, lock is held
+	def get_error_msg(self):
+		# We got an error, lets go fetch the error message
 		self._write_cmd('lastlog\n')
-		report_json = self._read_response()[1]
-		return get_error_msg(report_json)
+
+		# read everything from the STDOUT to the next prompt
+		stdout, report_json, stderr = self._read_until_prompt()
+		if 'log' in report_json:
+			error_msg = ""
+			# Walk the entire log array and build an error string
+			for log_entry in report_json['log']:
+				if log_entry['log_type'] == "error":
+					if error_msg:
+						error_msg += ', ' + log_entry['log_message']
+					else:
+						error_msg = log_entry['log_message']
+
+			return error_msg
+
+		return 'No error reason provided! (missing "log" section)'
 
 	def call_lvm(self, argv, debug=False):
 		rc = 1
@@ -220,94 +213,57 @@ class LVMShellProxy(object):
 		cmd += "\n"
 
 		# run the command by writing it to the shell's STDIN
-		with self.shell_lock:
-			self._write_cmd(cmd)
+		self._write_cmd(cmd)
 
-			# read everything from the STDOUT to the next prompt
-			stdout, report_json, stderr = self._read_response()
+		# read everything from the STDOUT to the next prompt
+		stdout, report_json, stderr = self._read_until_prompt()
 
-			# Parse the report to see what happened
-			if 'log' in report_json:
-				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'
-				# Note: 0 == error
-				if (ret_code == 1) or (ret_code == 5 and argv[0] == 'fullreport'):
-					rc = 0
-				else:
-					# Depending on where lvm fails the command, it may not have anything
-					# to report for "lastlog", so we need to check for a message in the
-					# report json too.
-					error_msg = self._get_last_log()
-					if error_msg is None:
-						error_msg = get_error_msg(report_json)
-						if error_msg is None:
-							error_msg = 'No error reason provided! (missing "log" section)'
+		# Parse the report to see what happened
+		if 'log' in report_json:
+			if report_json['log'][-1:][0]['log_ret_code'] == '1':
+				rc = 0
+			else:
+				error_msg = self.get_error_msg()
 
 		if debug or rc != 0:
-			log_error(("CMD= %s" % cmd))
-			log_error(("EC= %d" % rc))
+			log_error(('CMD: %s' % cmd))
+			log_error(("EC = %d" % rc))
 			log_error(("ERROR_MSG=\n %s\n" % error_msg))
 
 		return rc, report_json, error_msg
 
 	def exit_shell(self):
-		with self.shell_lock:
-			try:
-				if self.lvm_shell is not None:
-					self._write_cmd('exit\n')
-					self.lvm_shell.wait(1)
-					self.lvm_shell = None
-			except Exception as _e:
-				log_error("exit_shell: %s" % (str(_e)))
+		try:
+			self._write_cmd('exit\n')
+		except Exception as e:
+			log_error(str(e))
 
 	def __del__(self):
-		# Note: When we are shutting down the daemon and the main process has already exited
-		# and this gets called we have a limited set of things we can do, like we cannot call
-		# log_error as _common_log is None!!!
-		if self.lvm_shell is not None:
-			try:
-				self.lvm_shell.wait(1)
-			except subprocess.TimeoutExpired:
-				print("lvm shell child process did not exit as instructed, sending SIGTERM")
-				cfg.ignore_sigterm = True
-				self.lvm_shell.terminate()
-				child_exit_code = self.lvm_shell.wait(1)
-				print("lvm shell process exited with %d" % child_exit_code)
+		try:
+			self.lvm_shell.terminate()
+		except:
+			pass
 
 
 if __name__ == "__main__":
-	print("USING LVM BINARY: %s " % cfg.LVM_CMD)
-
+	shell = LVMShellProxy()
+	in_line = "start"
 	try:
-		if len(sys.argv) > 1 and sys.argv[1] == "bisect":
-			shell = LVMShellProxy()
-			shell.exit_shell()
-		else:
-			shell = LVMShellProxy()
-			in_line = "start"
-			try:
-				while in_line:
-					in_line = input("lvm> ")
-					if in_line:
-						if in_line == "exit":
-							shell.exit_shell()
-							sys.exit(0)
-						start = time.time()
-						ret, out, err = shell.call_lvm(in_line.split())
-						end = time.time()
+		while in_line:
+			in_line = input("lvm> ")
+			if in_line:
+				start = time.time()
+				ret, out, err = shell.call_lvm(in_line.split())
+				end = time.time()
 
-						print(("RC: %d" % ret))
-						print(("OUT:\n%s" % out))
-						print(("ERR:\n%s" % err))
+				print(("RC: %d" % ret))
+				print(("OUT:\n%s" % out))
+				print(("ERR:\n%s" % err))
 
-						print("Command     = %f seconds" % (end - start))
-			except KeyboardInterrupt:
-				pass
-			except EOFError:
-				pass
-	except Exception as e:
-		log_error("main process exiting on exception!\n%s" % extract_stack_trace(e))
-		sys.exit(1)
-
-	sys.exit(0)
+				print("Command     = %f seconds" % (end - start))
+	except KeyboardInterrupt:
+		pass
+	except EOFError:
+		pass
+	except Exception:
+		traceback.print_exc(file=sys.stdout)

daemons/lvmdbusd/lvmdb.py.in

@@ -13,13 +13,14 @@ from collections import OrderedDict
 
 import pprint as prettyprint
 import os
+import sys
 
 from lvmdbusd import cmdhandler
-from lvmdbusd.utils import log_debug, log_error, lvm_column_key, LvmBug
+from lvmdbusd.utils import log_debug, log_error
 
 
 class DataStore(object):
-	def __init__(self, vdo_support=False):
+	def __init__(self, usejson=True):
 		self.pvs = {}
 		self.vgs = {}
 		self.lvs = {}
@@ -34,8 +35,38 @@ class DataStore(object):
 		self.lvs_in_vgs = {}
 		self.pvs_in_vgs = {}
 
+		# self.refresh()
 		self.num_refreshes = 0
-		self.vdo_support = vdo_support
+
+		if usejson:
+			self.json = cmdhandler.supports_json()
+		else:
+			self.json = usejson
+
+	@staticmethod
+	def _insert_record(table, key, record, allowed_multiple):
+		if key in table:
+			existing = table[key]
+
+			for rec_k, rec_v in record.items():
+				if rec_k in allowed_multiple:
+					# This column name allows us to store multiple value for
+					# each type
+					if not isinstance(existing[rec_k], list):
+						existing_value = existing[rec_k]
+						existing[rec_k] = [existing_value, rec_v]
+					else:
+						existing[rec_k].append(rec_v)
+				else:
+					# If something is not expected to have changing values
+					# lets ensure that
+					if existing[rec_k] != rec_v:
+						raise RuntimeError(
+							"existing[%s]=%s != %s" %
+							(rec_k, str(existing[rec_k]),
+							str(rec_v)))
+		else:
+			table[key] = record
 
 	@staticmethod
 	def _pvs_parse_common(c_pvs, c_pvs_in_vgs, c_lookup):
@@ -51,6 +82,22 @@ class DataStore(object):
 			# Lookup for translating between /dev/<name> and pv uuid
 			c_lookup[p['pv_name']] = p['pv_uuid']
 
+	@staticmethod
+	def _parse_pvs(_pvs):
+		pvs = sorted(_pvs, key=lambda pk: pk['pv_name'])
+
+		c_pvs = OrderedDict()
+		c_lookup = {}
+		c_pvs_in_vgs = {}
+
+		for p in pvs:
+			DataStore._insert_record(
+				c_pvs, p['pv_uuid'], p,
+				['pvseg_start', 'pvseg_size', 'segtype'])
+
+		DataStore._pvs_parse_common(c_pvs, c_pvs_in_vgs, c_lookup)
+		return c_pvs, c_lookup, c_pvs_in_vgs
+
 	@staticmethod
 	def _parse_pvs_json(_all):
 
@@ -58,7 +105,7 @@ class DataStore(object):
 		c_lookup = {}
 		c_pvs_in_vgs = {}
 
-		# Each item in the report is a collection of information pertaining
+		# Each item item in the report is a collection of information pertaining
 		# to the vg
 		for r in _all['report']:
 			tmp_pv = []
@@ -92,6 +139,19 @@ class DataStore(object):
 
 		return c_pvs, c_lookup, c_pvs_in_vgs
 
+	@staticmethod
+	def _parse_vgs(_vgs):
+		vgs = sorted(_vgs, key=lambda vk: vk['vg_name'])
+
+		c_vgs = OrderedDict()
+		c_lookup = {}
+
+		for i in vgs:
+			c_lookup[i['vg_name']] = i['vg_uuid']
+			DataStore._insert_record(c_vgs, i['vg_uuid'], i, [])
+
+		return c_vgs, c_lookup
+
 	@staticmethod
 	def _parse_vgs_json(_all):
 
@@ -102,22 +162,13 @@ 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_uuid'])
+		vgs = sorted(tmp_vg, key=lambda vk: vk['vg_name'])
 
 		c_vgs = OrderedDict()
 		c_lookup = {}
 
 		for i in vgs:
-			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_lookup[i['vg_name']] = i['vg_uuid']
 			c_vgs[i['vg_uuid']] = i
 
 		return c_vgs, c_lookup
@@ -156,12 +207,29 @@ class DataStore(object):
 
 		return c_lvs, c_lvs_in_vgs, c_lvs_hidden, c_lv_full_lookup
 
-	def _parse_lvs_json(self, _all):
+	@staticmethod
+	def _parse_lvs(_lvs):
+		lvs = sorted(_lvs, key=lambda vk: vk['lv_name'])
+
+		c_lvs = OrderedDict()
+		c_lv_full_lookup = OrderedDict()
+
+		for i in lvs:
+			full_name = "%s/%s" % (i['vg_name'], i['lv_name'])
+			c_lv_full_lookup[full_name] = i['lv_uuid']
+			DataStore._insert_record(
+				c_lvs, i['lv_uuid'], i,
+				['seg_pe_ranges', 'segtype'])
+
+		return DataStore._parse_lvs_common(c_lvs, c_lv_full_lookup)
+
+	@staticmethod
+	def _parse_lvs_json(_all):
 
 		c_lvs = OrderedDict()
 		c_lv_full_lookup = {}
 
-		# Each item in the report is a collection of information pertaining
+		# Each item item in the report is a collection of information pertaining
 		# to the vg
 		for r in _all['report']:
 			# Get the lv data for this VG.
@@ -176,13 +244,8 @@ 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)
 
@@ -309,12 +372,12 @@ class DataStore(object):
 		:param log  Add debug log entry/exit messages
 		:return: None
 		"""
-		try:
-			self.num_refreshes += 1
-			if log:
-				log_debug("lvmdb - refresh entry")
+		self.num_refreshes += 1
+		if log:
+			log_debug("lvmdb - refresh entry")
 
-			# Grab everything first then parse it
+		# Grab everything first then parse it
+		if self.json:
 			# Do a single lvm retrieve for everything in json
 			a = cmdhandler.lvm_full_report_json()
 
@@ -322,25 +385,29 @@ class DataStore(object):
 			_vgs, _vgs_lookup = self._parse_vgs_json(a)
 			_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs_json(a)
 
-			# Set all
-			self.pvs = _pvs
-			self.pv_path_to_uuid = _pvs_lookup
-			self.vg_name_to_uuid = _vgs_lookup
-			self.lv_full_name_to_uuid = _lvs_lookup
+		else:
+			_raw_pvs = cmdhandler.pv_retrieve_with_segs()
+			_raw_vgs = cmdhandler.vg_retrieve(None)
+			_raw_lvs = cmdhandler.lv_retrieve_with_segments()
 
-			self.vgs = _vgs
-			self.lvs = _lvs
-			self.lvs_in_vgs = _lvs_in_vgs
-			self.pvs_in_vgs = _pvs_in_vgs
-			self.lvs_hidden = _lvs_hidden
+			_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs(_raw_pvs)
+			_vgs, _vgs_lookup = self._parse_vgs(_raw_vgs)
+			_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs(_raw_lvs)
 
-			# Create lookup table for which LV and segments are on each PV
-			self.pv_lvs, self.lv_pvs = self._parse_pv_in_lvs()
-		except KeyError as ke:
-			key = ke.args[0]
-			if lvm_column_key(key):
-				raise LvmBug("missing JSON key: '%s'" % key)
-			raise ke
+		# Set all
+		self.pvs = _pvs
+		self.pv_path_to_uuid = _pvs_lookup
+		self.vg_name_to_uuid = _vgs_lookup
+		self.lv_full_name_to_uuid = _lvs_lookup
+
+		self.vgs = _vgs
+		self.lvs = _lvs
+		self.lvs_in_vgs = _lvs_in_vgs
+		self.pvs_in_vgs = _pvs_in_vgs
+		self.lvs_hidden = _lvs_hidden
+
+		# Create lookup table for which LV and segments are on each PV
+		self.pv_lvs, self.lv_pvs = self._parse_pv_in_lvs()
 
 		if log:
 			log_debug("lvmdb - refresh exit")
@@ -351,7 +418,7 @@ class DataStore(object):
 		else:
 			rc = []
 			for s in pv_name:
-				# The user could be using a symlink instead of the actual
+				# Ths user could be using a symlink instead of the actual
 				# block device, make sure we are using actual block device file
 				# if the pv name isn't in the lookup
 				if s not in self.pv_path_to_uuid:
@@ -360,13 +427,10 @@ class DataStore(object):
 			return rc
 
 	def pv_missing(self, pv_uuid):
-		# The uuid might not be a PV, default to false
 		if pv_uuid in self.pvs:
 			if self.pvs[pv_uuid]['pv_missing'] == '':
 				return False
-			else:
-				return True
-		return False
+		return True
 
 	def fetch_vgs(self, vg_name):
 		if not vg_name:
@@ -437,11 +501,15 @@ class DataStore(object):
 
 
 if __name__ == "__main__":
-	os.environ["LC_ALL"] = "C"
-	os.environ["LVM_COMMAND_PROFILE"] = "lvmdbusd"
 	pp = prettyprint.PrettyPrinter(indent=4)
 
-	ds = DataStore()
+	use_json = False
+
+	if len(sys.argv) != 1:
+		print(len(sys.argv))
+		use_json = True
+
+	ds = DataStore(use_json)
 	ds.refresh()
 
 	print("PVS")
@@ -453,10 +521,6 @@ 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

@@ -22,13 +22,14 @@ from . import lvmdb
 from gi.repository import GLib
 from .fetch import StateUpdate
 from .manager import Manager
+import traceback
 import queue
 from . import udevwatch
-from .utils import log_debug, log_error, log_msg, DebugMessages
+from .utils import log_debug, log_error
 import argparse
 import os
 import sys
-from .cmdhandler import LvmFlightRecorder, supports_vdo, supports_json
+from .cmdhandler import LvmFlightRecorder
 from .request import RequestEntry
 
 
@@ -41,23 +42,20 @@ def process_request():
 	while cfg.run.value != 0:
 		# noinspection PyBroadException
 		try:
-			req = cfg.worker_q.get(True, cfg.G_LOOP_TMO)
+			req = cfg.worker_q.get(True, 5)
 			log_debug(
-				"Method start: %s with args %s (callback = %s)" %
-				(str(req.method), str(req.arguments), str(req.cb)))
+				"Running method: %s with args %s" %
+				(str(req.method), str(req.arguments)))
 			req.run_cmd()
-			log_debug("Method complete: %s" % str(req.method))
+			log_debug("Method complete ")
 		except queue.Empty:
 			pass
-		except SystemExit:
-			break
-		except Exception as e:
-			st = utils.extract_stack_trace(e)
+		except Exception:
+			st = traceback.format_exc()
 			utils.log_error("process_request exception: \n%s" % st)
-	log_debug("process_request thread exiting!")
 
 
-def check_fr_size(value):
+def check_bb_size(value):
 	v = int(value)
 	if v < 0:
 		raise argparse.ArgumentTypeError(
@@ -67,7 +65,7 @@ def check_fr_size(value):
 
 def install_signal_handlers():
 	# Because of the glib main loop stuff the python signal handler code is
-	# apparently not usable, and we need to use the glib calls instead
+	# apparently not usable and we need to use the glib calls instead
 	signal_add = None
 
 	if hasattr(GLib, 'unix_signal_add'):
@@ -79,13 +77,13 @@ def install_signal_handlers():
 		signal_add(GLib.PRIORITY_HIGH, signal.SIGHUP, utils.handler, signal.SIGHUP)
 		signal_add(GLib.PRIORITY_HIGH, signal.SIGINT, utils.handler, signal.SIGINT)
 		signal_add(GLib.PRIORITY_HIGH, signal.SIGUSR1, utils.handler, signal.SIGUSR1)
-		signal_add(GLib.PRIORITY_HIGH, signal.SIGUSR2, utils.handler, signal.SIGUSR2)
-		signal_add(GLib.PRIORITY_HIGH, signal.SIGTERM, utils.handler, signal.SIGTERM)
 	else:
 		log_error("GLib.unix_signal_[add|add_full] are NOT available!")
 
 
-def process_args():
+def main():
+	start = time.time()
+	# Add simple command line handling
 	parser = argparse.ArgumentParser()
 	parser.add_argument(
 		"--udev", action='store_true',
@@ -106,137 +104,93 @@ def process_args():
 		default=False,
 		dest='use_lvm_shell')
 	parser.add_argument(
-		"--frsize",
-		help="Size of the flight recorder (num. entries), 0 to disable (signal 12 to dump)",
+		"--blackboxsize",
+		help="Size of the black box flight recorder, 0 to disable",
 		default=10,
-		type=check_fr_size,
-		dest='fr_size')
+		type=check_bb_size,
+		dest='bb_size')
 
-	args = parser.parse_args()
+	use_session = os.getenv('LVMDBUSD_USE_SESSION', False)
 
-	if not args.use_json:
-		log_error("Daemon no longer supports lvm without JSON support, exiting!")
-		sys.exit(1)
-	else:
-		if not supports_json():
-			log_error("Un-supported version of LVM, daemon requires JSON output, exiting!")
-			sys.exit(1)
-
-	# Add udev watching
-	if args.use_udev:
-		# Make sure this msg ends up in the journal, so we know
-		log_msg('The --udev option is no longer supported,'
-				'the daemon always uses a combination of dbus notify from lvm tools and udev')
-
-	return args
-
-
-def running_under_systemd():
-	""""
-	Checks to see if we are running under systemd, by checking daemon fd 0, 1
-	systemd sets stdin to /dev/null and 1 & 2 are a socket
-	"""
-	base = "/proc/self/fd"
-	stdout = os.readlink("%s/0" % base)
-	if stdout == "/dev/null":
-		stdout = os.readlink("%s/1" % base)
-		if "socket" in stdout:
-			return True
-	return False
-
-
-def main():
-	start = time.time()
-	use_session = os.getenv('LVM_DBUSD_USE_SESSION', False)
-
-	# Ensure that we get consistent output for parsing stdout/stderr and that we
-	# are using the lvmdbusd profile.
+	# Ensure that we get consistent output for parsing stdout/stderr
 	os.environ["LC_ALL"] = "C"
-	os.environ["LVM_COMMAND_PROFILE"] = "lvmdbusd"
-
-	# Indicator if we are running under systemd
-	cfg.systemd = running_under_systemd()
-
-	# Add simple command line handling
-	cfg.args = process_args()
 
+	cfg.args = parser.parse_args()
 	cfg.create_request_entry = RequestEntry
 
 	# We create a flight recorder in cmdhandler too, but we replace it here
 	# as the user may be specifying a different size.  The default one in
 	# cmdhandler is for when we are running other code with a different main.
-	cfg.flightrecorder = LvmFlightRecorder(cfg.args.fr_size)
+	cfg.blackbox = LvmFlightRecorder(cfg.args.bb_size)
 
-	# Create a circular buffer for debug logs
-	cfg.debug = DebugMessages()
-
-	log_debug("Using lvm binary: %s" % cfg.LVM_CMD)
-
-	# We will dynamically add interfaces which support vdo if it
-	# exists.
-	cfg.vdo_support = supports_vdo()
+	if cfg.args.use_lvm_shell and not cfg.args.use_json:
+		log_error("You cannot specify --lvmshell and --nojson")
+		sys.exit(1)
 
 	# List of threads that we start up
 	thread_list = []
 
 	install_signal_handlers()
 
-	with utils.LockFile(cfg.LOCK_FILE):
-		dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-		dbus.mainloop.glib.threads_init()
+	dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+	dbus.mainloop.glib.threads_init()
 
-		cmdhandler.set_execution(cfg.args.use_lvm_shell)
+	cmdhandler.set_execution(cfg.args.use_lvm_shell)
 
-		if use_session:
-			cfg.bus = dbus.SessionBus()
-		else:
-			cfg.bus = dbus.SystemBus()
-		# The base name variable needs to exist for things to work.
-		# noinspection PyUnusedLocal
-		base_name = dbus.service.BusName(BUS_NAME, cfg.bus)
-		cfg.om = Lvm(BASE_OBJ_PATH)
-		cfg.om.register_object(Manager(MANAGER_OBJ_PATH))
+	if use_session:
+		cfg.bus = dbus.SessionBus()
+	else:
+		cfg.bus = dbus.SystemBus()
+	# The base name variable needs to exist for things to work.
+	# noinspection PyUnusedLocal
+	base_name = dbus.service.BusName(BUS_NAME, cfg.bus)
+	cfg.om = Lvm(BASE_OBJ_PATH)
+	cfg.om.register_object(Manager(MANAGER_OBJ_PATH))
 
-		cfg.db = lvmdb.DataStore(vdo_support=cfg.vdo_support)
+	cfg.db = lvmdb.DataStore(cfg.args.use_json)
 
-		# 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'))
+	# 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'))
 
-		# Have a single thread handling updating lvm and the dbus model, so we
-		# don't have multiple threads doing this as the same time
-		updater = StateUpdate()
-		thread_list.append(updater.thread)
+	# Have a single thread handling updating lvm and the dbus model so we
+	# don't have multiple threads doing this as the same time
+	updater = StateUpdate()
+	thread_list.append(updater.thread)
 
-		cfg.load = updater.load
+	cfg.load = updater.load
 
-		cfg.loop = GLib.MainLoop()
+	cfg.loop = GLib.MainLoop()
 
-		for thread in thread_list:
-			thread.daemon = True
-			thread.start()
+	for thread in thread_list:
+		thread.damon = True
+		thread.start()
 
-		# In all cases we are going to monitor for udev until we get an
-		# ExternalEvent.  In the case where we get an external event and the user
-		# didn't specify --udev we will stop monitoring udev
-		udevwatch.add()
+	# Add udev watching
+	if cfg.args.use_udev:
+		log_debug('Utilizing udev to trigger updates')
 
-		end = time.time()
-		log_debug(
-			'Service ready! total time= %.4f, lvm time= %.4f count= %d' %
-			(end - start, cmdhandler.total_time, cmdhandler.total_count),
-			'bg_black', 'fg_light_green')
+	# In all cases we are going to monitor for udev until we get an
+	# ExternalEvent.  In the case where we get an external event and the user
+	# didn't specify --udev we will stop monitoring udev
+	udevwatch.add()
 
-		try:
-			if cfg.run.value != 0:
-				cfg.loop.run()
-				udevwatch.remove()
+	end = time.time()
+	log_debug(
+		'Service ready! total time= %.4f, lvm time= %.4f count= %d' %
+		(end - start, cmdhandler.total_time, cmdhandler.total_count),
+		'bg_black', 'fg_light_green')
 
-				for thread in thread_list:
-					thread.join()
-		except KeyboardInterrupt:
-			# If we are unable to register signal handler, we will end up here when
-			# the service gets a ^C or a kill -2 <parent pid>
-			utils.handler(signal.SIGINT)
+	try:
+		if cfg.run.value != 0:
+			cfg.loop.run()
+			udevwatch.remove()
+
+			for thread in thread_list:
+				thread.join()
+	except KeyboardInterrupt:
+		# If we are unable to register signal handler, we will end up here when
+		# the service gets a ^C or a kill -2 <parent pid>
+		utils.handler(signal.SIGINT)
 	return 0

daemons/lvmdbusd/manager.py

@@ -27,7 +27,7 @@ class Manager(AutomatedProperties):
 
 	@property
 	def Version(self):
-		return dbus.String('1.1.0')
+		return dbus.String('1.0.0')
 
 	@staticmethod
 	def handle_execute(rc, out, err):
@@ -107,10 +107,10 @@ class Manager(AutomatedProperties):
 		rc = cfg.load(log=False)
 
 		if rc != 0:
-			utils.log_debug('Manager.Refresh - exit %d %d' % (rc, lc),
+			utils.log_debug('Manager.Refresh - exit %d' % (rc),
 							'bg_black', 'fg_light_red')
 		else:
-			utils.log_debug('Manager.Refresh - exit %d %d' % (rc, lc))
+			utils.log_debug('Manager.Refresh - exit %d' % (rc))
 		return rc + lc
 
 	@dbus.service.method(
@@ -137,8 +137,7 @@ class Manager(AutomatedProperties):
 		"""
 		Dump the flight recorder to syslog
 		"""
-		cfg.debug.dump()
-		cfg.flightrecorder.dump()
+		cfg.blackbox.dump()
 
 	@staticmethod
 	def _lookup_by_lvm_id(key):
@@ -165,8 +164,6 @@ 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)
@@ -195,7 +192,6 @@ class Manager(AutomatedProperties):
 	def _external_event(command):
 		utils.log_debug("Processing _external_event= %s" % command,
 							'bg_black', 'fg_orange')
-		cfg.got_external_event = True
 		cfg.load()
 
 	@dbus.service.method(
@@ -203,6 +199,14 @@ class Manager(AutomatedProperties):
 		in_signature='s', out_signature='i')
 	def ExternalEvent(self, command):
 		utils.log_debug("ExternalEvent %s" % command)
+		# If a user didn't explicitly specify udev, we will turn it off now.
+		if not cfg.args.use_udev:
+			if udevwatch.remove():
+				utils.log_debug("ExternalEvent received, disabling "
+								"udev monitoring")
+				# We are dependent on external events now to stay current!
+				cfg.got_external_event = True
+
 		r = RequestEntry(
 			-1, Manager._external_event, (command,), None, None, False)
 		cfg.worker_q.put(r)

daemons/lvmdbusd/objectmanager.py

@@ -9,11 +9,12 @@
 
 import sys
 import threading
+import traceback
 import dbus
 import os
 import copy
 from . import cfg
-from .utils import log_debug, log_error, extract_stack_trace
+from .utils import log_debug, pv_obj_path_generate, log_error
 from .automatedproperties import AutomatedProperties
 
 
@@ -39,8 +40,8 @@ class ObjectManager(AutomatedProperties):
 				for k, v in list(obj._objects.items()):
 					path, props = v[0].emit_data()
 					rc[path] = props
-			except Exception as e:
-				log_error("_get_managed_objects exception, bailing: \n%s" % extract_stack_trace(e))
+			except Exception:
+				traceback.print_exc(file=sys.stdout)
 				sys.exit(1)
 			return rc
 
@@ -52,6 +53,15 @@ class ObjectManager(AutomatedProperties):
 									(self, ), cb, cbe, False)
 		cfg.worker_q.put(r)
 
+	def locked(self):
+		"""
+		If some external code need to run across a number of different
+		calls into ObjectManager while blocking others they can use this method
+		to lock others out.
+		:return:
+		"""
+		return ObjectManagerLock(self.rlock)
+
 	@dbus.service.signal(
 		dbus_interface="org.freedesktop.DBus.ObjectManager",
 		signature='oa{sa{sv}}')
@@ -159,8 +169,8 @@ class ObjectManager(AutomatedProperties):
 			# print('Registering object path %s for %s' %
 			# (path, dbus_object.lvm_id))
 
-			# We want fast access to the object by a number of different ways,
-			# so we use multiple hashes with different keys
+			# We want fast access to the object by a number of different ways
+			# so we use multiple hashs with different keys
 			self._lookup_add(dbus_object, path, dbus_object.lvm_id,
 				dbus_object.Uuid)
 
@@ -179,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)
 
@@ -209,7 +219,7 @@ class ObjectManager(AutomatedProperties):
 
 	def get_object_by_lvm_id(self, lvm_id):
 		"""
-		Given a lvm identifier, return the object registered for it
+		Given an lvm identifier, return the object registered for it
 		:param lvm_id: The lvm identifier
 		"""
 		with self.rlock:
@@ -220,7 +230,7 @@ class ObjectManager(AutomatedProperties):
 
 	def get_object_path_by_lvm_id(self, lvm_id):
 		"""
-		Given a lvm identifier, return the object path for it
+		Given an lvm identifier, return the object path for it
 		:param lvm_id: The lvm identifier
 		:return: Object path or '/' if not found
 		"""
@@ -230,19 +240,39 @@ class ObjectManager(AutomatedProperties):
 				return lookup_rc
 			return '/'
 
-	def _id_verify(self, path, uuid, lvm_id):
+	def _uuid_verify(self, path, uuid, lvm_id):
 		"""
-		Ensure our lookups are correct
+		Ensure uuid is present for a successful lvm_id lookup
 		NOTE: Internal call, assumes under object manager lock
 		:param path: 		Path to object we looked up
-		:param uuid: 		uuid lookup
-		:param lvm_id:		lvm_id lookup
+		:param uuid: 		lvm uuid to verify
+		:param lvm_id:		lvm_id used to find object
 		:return: None
 		"""
-		# There is no durable non-changeable name in lvm
+		# 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
 		if lvm_id != uuid:
-			obj = self.get_object_by_path(path)
-			self._lookup_add(obj, path, 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)
 
 	def _id_lookup(self, the_id):
 		path = None
@@ -277,7 +307,7 @@ class ObjectManager(AutomatedProperties):
 		register it with the object manager for the specified uuid & lvm_id.
 		Note: If path create is not None, uuid and lvm_id cannot be equal
 		:param uuid: The uuid for the lvm object we are searching for
-		:param lvm_id: The lvm name (e.g. pv device path, vg name, lv full name)
+		:param lvm_id: The lvm name (eg. pv device path, vg name, lv full name)
 		:param path_create: If not None, create the path using this function if
 				we fail to find the object by uuid or lvm_id.
 		:returns None if lvm asset not found and path_create == None otherwise
@@ -295,34 +325,61 @@ class ObjectManager(AutomatedProperties):
 			if uuid == lvm_id:
 				path = self._id_lookup(lvm_id)
 			else:
-				# We have an uuid and a lvm_id we can do sanity checks to ensure
+				# We have a uuid and a lvm_id we can do sanity checks to ensure
 				# that they are consistent
 
-				# If a PV is missing its device path is '[unknown]' or some
+				# If a PV is missing it's device path is '[unknown]' or some
 				# other text derivation of unknown.  When we find that a PV is
-				# missing we will clear out the lvm_id as it's not unique
-				# and thus not useful and harmful for lookups.
-				if cfg.db.pv_missing(uuid):
+				# missing we will clear out the lvm_id as it's likely not unique
+				# and thus not useful and potentially harmful for lookups.
+				if path_create == pv_obj_path_generate and \
+						cfg.db.pv_missing(uuid):
 					lvm_id = None
 
-				# Let's check for the uuid first
+				# Lets check for the uuid first
 				path = self._id_lookup(uuid)
 				if path:
-					# Ensure table lookups are correct
-					self._id_verify(path, uuid, lvm_id)
+					# Verify the lvm_id is sane
+					self._lvm_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:
-						# Ensure table lookups are correct
-						self._id_verify(path, uuid, lvm_id)
+						# Verify the uuid is sane
+						self._uuid_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): return %s' %
-			#	(uuid, lvm_id, str(path_create), path))
+			# print('get_object_path_by_lvm_id(%s, %s, %s, %s: return %s' %
+			# 	   (uuid, lvm_id, str(path_create), str(gen_new), path))
 
 			return path
+
+
+class ObjectManagerLock(object):
+	"""
+	The sole purpose of this class is to allow other code the ability to
+	lock the object manager using a `with` statement, eg.
+
+	with cfg.om.locked():
+		# Do stuff with object manager
+
+	This will ensure that the lock is always released (assuming this is done
+	correctly)
+	"""
+
+	def __init__(self, recursive_lock):
+		self._lock = recursive_lock
+
+	def __enter__(self):
+		# Acquire lock
+		self._lock.acquire()
+
+	# noinspection PyUnusedLocal
+	def __exit__(self, e_type, e_value, e_traceback):
+		# Release lock
+		self._lock.release()
+		self._lock = None

daemons/lvmdbusd/pv.py

@@ -14,11 +14,11 @@ 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, _handle_execute, lvm_column_key
+	lv_object_path_method
 from .loader import common
 from .request import RequestEntry
 from .state import State
-from .utils import round_size, LvmBug
+from .utils import round_size
 
 
 # noinspection PyUnusedLocal
@@ -28,23 +28,16 @@ def pvs_state_retrieve(selection, cache_refresh=True):
 	if cache_refresh:
 		cfg.db.refresh()
 
-	try:
-		for p in cfg.db.fetch_pvs(selection):
-			rc.append(
-				PvState(
-					p["pv_name"], p["pv_uuid"], p["pv_name"],
-					p["pv_fmt"], n(p["pv_size"]), n(p["pv_free"]),
-					n(p["pv_used"]), n(p["dev_size"]), n(p["pv_mda_size"]),
-					n(p["pv_mda_free"]), int(p["pv_ba_start"]),
-					n(p["pv_ba_size"]), n(p["pe_start"]),
-					int(p["pv_pe_count"]), int(p["pv_pe_alloc_count"]),
-					p["pv_attr"], p["pv_tags"], p["vg_name"], p["vg_uuid"]))
-	except KeyError as ke:
-		# Sometimes lvm omits returning one of the keys we requested.
-		key = ke.args[0]
-		if lvm_column_key(key):
-			raise LvmBug("missing JSON key: '%s'" % key)
-		raise ke
+	for p in cfg.db.fetch_pvs(selection):
+		rc.append(
+			PvState(
+				p["pv_name"], p["pv_uuid"], p["pv_name"],
+				p["pv_fmt"], n(p["pv_size"]), n(p["pv_free"]),
+				n(p["pv_used"]), n(p["dev_size"]), n(p["pv_mda_size"]),
+				n(p["pv_mda_free"]), int(p["pv_ba_start"]),
+				n(p["pv_ba_size"]), n(p["pe_start"]),
+				int(p["pv_pe_count"]), int(p["pv_pe_alloc_count"]),
+				p["pv_attr"], p["pv_tags"], p["vg_name"], p["vg_uuid"]))
 	return rc
 
 
@@ -145,12 +138,19 @@ 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)
-		Pv.handle_execute(*cmdhandler.pv_remove(pv_name, remove_options))
+		rc, out, err = cmdhandler.pv_remove(pv_name, remove_options)
+		Pv.handle_execute(rc, out, err)
 		return '/'
 
 	@staticmethod
 	def handle_execute(rc, out, err):
-		return _handle_execute(rc, out, err, PV_INTERFACE)
+		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))
 
 	@staticmethod
 	def validate_dbus_object(pv_uuid, pv_name):
@@ -178,8 +178,10 @@ 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)
-		Pv.handle_execute(*cmdhandler.pv_resize(pv_name, new_size_bytes,
-												resize_options))
+
+		rc, out, err = cmdhandler.pv_resize(pv_name, new_size_bytes,
+												resize_options)
+		Pv.handle_execute(rc, out, err)
 		return '/'
 
 	@dbus.service.method(
@@ -198,8 +200,9 @@ 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)
-		Pv.handle_execute(*cmdhandler.pv_allocatable(pv_name, yes_no,
-														allocation_options))
+		rc, out, err = cmdhandler.pv_allocatable(
+			pv_name, yes_no, allocation_options)
+		Pv.handle_execute(rc, out, err)
 		return '/'
 
 	@dbus.service.method(

daemons/lvmdbusd/request.py

@@ -7,13 +7,13 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
-import dbus
 import threading
 # noinspection PyUnresolvedReferences
 from gi.repository import GLib
 from .job import Job
 from . import cfg
-from .utils import log_error, mt_async_call, extract_stack_trace
+import traceback
+from .utils import log_error, mt_async_call
 
 
 class RequestEntry(object):
@@ -71,23 +71,13 @@ class RequestEntry(object):
 		try:
 			result = self.method(*self.arguments)
 			self.register_result(result)
-		except SystemExit as se:
-			self.register_error(-1, str(se), se)
-			raise se
-		except dbus.exceptions.DBusException as dbe:
-			# This is an expected error path when something goes awry that
-			# we handled
-			self.register_error(-1, str(dbe), dbe)
 		except Exception as e:
 			# Use the request entry to return the result as the client may
 			# have gotten a job by the time we hit an error
-			# Lets set the exception text as the error message and log the
-			# exception in the journal for figuring out what went wrong.
-			cfg.debug.dump()
-			cfg.flightrecorder.dump()
-			tb = extract_stack_trace(e)
-			log_error("While processing %s: we encountered\n%s" % (str(self.method), tb))
-			log_error("Error returned to client: %s" % str(e))
+			# Lets get the stacktrace and set that to the error message
+			st = traceback.format_exc()
+			cfg.blackbox.dump()
+			log_error("Exception returned to client: \n%s" % st)
 			self.register_error(-1, str(e), e)
 
 	def is_done(self):
@@ -141,7 +131,7 @@ class RequestEntry(object):
 
 						mt_async_call(self.cb_error, error_exception)
 			else:
-				# We have a job, and it's complete, indicate that it's done.
+				# We have a job and it's complete, indicate that it's done.
 				self._job.Complete = True
 				self._job = None