pre-release

Showing 'u' in the pv_attr reporting field is mostly unnecessary because
most PVs are allocatable, and being allocatable implies it is (u)sed,
and this is already obvious from other fields in the default 'pvs'
output like the VG name.

So move the new (u)sed pv_attr from character position 4 to 1, and only
show it in those rare cases when the PV is not (a)llocatable or the
relevant metadata is missing.

(Scripts should not be using pv_attr, but rather pv_allocatable,
pv_exported, pv_missing, pv_in_use etc.)

.gitignore

@@ -7,6 +7,8 @@
 *.orig
 *.pc
 *.pot
+*.pyc
+*.pyo
 *.rej
 *.so
 *.so.*

COPYING

@@ -2,7 +2,7 @@
 		       Version 2, June 1991
 
  Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -305,7 +305,7 @@ the "copyright" line and a pointer to where the full notice is found.
 
     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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 
 Also add information on how to contact you by electronic and paper mail.

Makefile.in

@@ -10,7 +10,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@
@@ -95,7 +95,7 @@ endif
 DISTCLEAN_TARGETS += cscope.out
 CLEAN_DIRS += autom4te.cache
 
-check check_system check_cluster check_local check_lvmetad check_lvmpolld unit: all
+check check_system check_cluster check_local check_lvmetad check_lvmpolld check_lvmlockd_test check_lvmlockd_dlm check_lvmlockd_sanlock unit: all
 	$(MAKE) -C test $(@)
 
 conf.generate: tools
@@ -166,8 +166,11 @@ install_tmpfiles_configuration:
 
 LCOV_TRACES = libdm.info lib.info liblvm.info tools.info \
 	libdaemon/client.info libdaemon/server.info \
-	daemons/clvmd.info daemons/dmeventd.info \
-	daemons/lvmetad.info
+	daemons/clvmd.info \
+	daemons/dmeventd.info \
+	daemons/lvmetad.info \
+	daemons/lvmlockd.info \
+	daemons/lvmpolld.info
 
 CLEAN_TARGETS += $(LCOV_TRACES)
 

VERSION

@@ -1 +1 @@
-2.02.134(2)-git (2015-10-30)
+2.02.144(2)-git (2016-02-26)

VERSION_DM

@@ -1 +1 @@
-1.02.111-git (2015-10-30)
+1.02.118-git (2016-02-26)

WHATS_NEW

@@ -1,5 +1,126 @@
-Version 2.02.134 - 
+Version 2.02.144 - 26th February 2016
+=====================================
+  Only show (u)sed pv_attr char when PV is not (a)llocatable. (2.02.143)
+  Update makefile to generate lcov output also for lvmpolld and lvmlockd.
+  Fix SystemdService lvm2-lvmdbusd.service name.
+  Improve support for env LVM_VG_NAME for reference VG name in lvconvert.
+  Fix regression when lvresize accepted zero sizes. (2.02.141)
+  Always warn user about PV in use even when pvremove uses --force --force.
+  Use uninitialized pool header detection in all cases.
+  Fix read error detection when checking for uninitialized thin-pool header.
+  Fix error path for internal error in lvmetad VG lookup code.
+
+Version 2.02.143 - 21st February 2016
+=====================================
+  Fix error path when sending thin-pool message fails in update_pool_lv().
+  Support reporting CheckNeeded and Fail state for thin-pool and thin LV.
+  For failing thin-pool and thin volume correctly report percentage as INVALID.
+  Report -1, not 'unkown' for lv_{snapshot_invalid,merge_failed} with --binary.
+  Add configure --enable-dbus-service for an LVM D-Bus service.
+  Replace configure --enable-python_bindings with python2 and python3 versions.
+  If PV belongs to some VG and metadata missing, skip it if system ID is used.
+  Automatically change PV header extension to latest version if writing PV/VG.
+  Identify used PVs in pv_attr field by new 'u' character.
+  Add pv_in_use reporting field to report if PV is used or not.
+  Add pv_ext_vsn reporting field to report PV header extension version.
+  Add protective flag marking PVs as used even if no metadata available.
+
+Version 2.02.142 - 15th February 2016
+=====================================
+  Fix memory pool corruption in pvmove (2.02.141).
+  Support control of spare metadata creation when repairing thin-pool.
+  Fix config type of 'log/verbose' from bool to int (2.02.99).
+  Fix inverted data LV thinp watermark calc for dmeventd response (2.02.133).
+  Use use_blkid_wiping=0 if not defined in lvm.conf and support not compiled in.
+  Do not check for suspended devices if scanning for lvmetad update.
+  Clear cached bootloader areas when PV format changed.
+  Fix partn table filter with external_device_info_source="udev" and blkid<2.20.
+
+Version 2.02.141 - 25th January 2016
 ====================================
+  Add metadata/check_pv_device_sizes switch to lvm.conf for device size checks.
+  Warn if device size is less than corresponding PV size in metadata.
+  Cache device sizes internally.
+  Restore support for command breaking in process_each_lv_in_vg() (2.02.118).
+  Use correct mempool when process_each_lv_in_vg() (2.02.118).
+  Fix lvm.8 man to show again prohibited suffixes.
+  Fix configure to set proper use_blkid_wiping if autodetected as disabled.
+  Initialise udev in clvmd for use in device scanning. (2.02.116)
+  Add seg_le_ranges report field for common format when displaying seg devices.
+  Honour report/list_item_separator for seg_metadata_le_ranges report field.
+  Don't mark hidden devs in -o devices,metadata_devices,seg_pe_ranges.(2.02.140)
+  Change LV sizes in seg_pe_ranges report field to match underlying devices.
+  Add kernel_cache_settings report field for cache LV settings used in kernel.
+
+Version 2.02.140 - 16th January 2016
+====================================
+  Fix lvm2app to return either 0 or 1 for lvm_vg_is_{clustered,exported}.
+  Add kernel_discards report field to display thin pool discard used in kernel.
+  Correct checking of target presence when driver access is disabled.
+  Eval poolmetadatasize arg earlier in lvresize.
+  Fix vgcfgrestore to respect allocatable attribute of PVs.
+  Add report/mark_hidden_devices to lvm.conf.
+  Use brackets consistently in report fields to mark hidden devices.
+  Restore background polling processing during auto-activation (2.02.119).
+  Fix invalid memory read when reporting cache LV policy_name (2.02.126).
+
+Version 2.02.139 - 8th January 2016
+===================================
+  Update lvmlockd with the new VG seqno before devices are suspended.
+  Rework vgrename to use the common processing code in toollib.
+  Make pvs show new devices on the system since the last .cache update.
+  Document F,D and M thin pool health status chars for lv_attr in lvs man page.
+  Also add lvm2-activation{-early,-net}.service systemd status for lvmdump -s.
+
+Version 2.02.138 - 14th December 2015
+=====================================
+  Support lvrename for hidden (used) cache pools.
+  Fix lvrename for stacked cache pools.
+
+Version 2.02.137 - 5th December 2015
+====================================
+  Restore archiving before changing metadata in vgextend (2.02.117).
+  Dropped internal usage of log_suppress(2).
+  Cleaned logging code for buffer size usage.
+  Added internal id_read_format_try() function to check and read valid UUID.
+  Change lvcreate, lvrename, lvresize to use process_each_vg.
+  Change process_each_vg to handle single VG as separate arg.
+  Issue error if ambiguous VG name is supplied in most commands.
+  Make process_each fns always work through full list of known VG names.
+  Use dm_get_status_mirror() instead of individual parsers.
+  Add mem pool arg for check_transient_status() target function.
+  Avoid misleading error with -m is omitted with lvconvert to raid types.
+  Add system_id to vginfo cache.
+
+Version 2.02.136 - 28th November 2015
+=====================================
+  Add new --sinceversion option for lvmconfig --type new.
+  Fix inactive table loaded for wrapping thin-pool when resizing it.
+  Extend the list of ignored libraries when locking memory.
+
+Version 2.02.135 - 23rd November 2015
+=====================================
+  Add a model file for Coverity.
+  Show correct error message for unsupported yet cache pool repair.
+  Allow lvconvert cache pools' data and metadata LV to raid.
+  Fix reading of old metadata with missing cache policy or mode settings.
+  Issue error if external_device_info_source=udev and udev db record incomplete.
+  Update lvmetad duplicate VG name handling to use hash function extensions.
+  Detect invalid vgrenames by vgid where the name is unchanged.
+  Fix passing of 32bit values through daemons (mostly lvmlockd).
+  Use local memory pool for whole alloc_handle manipulation.
+  Add missing pointer validation after dm_get_next_target().
+  Do not deref NULL pointer in debug message for _match_pv_tags().
+  Drop unneeded stat() call when checking for sysfs file.
+  Fix memory leak on error path of failing thin-pool percentage check.
+  Add missing test for failing node allocation in lvmetad.
+  Correct configure messages when enabling/disabling lvmlockd.
+
+Version 2.02.134 - 9th November 2015
+====================================
+  Refactor some lvmetad code and adjust some duplicate PV messages.
+  No longer repair/wipe VG/PVs if inaccessible because foreign or shared.
+  Pass correct data size to mirror log calc so log can be bigger than 1 extent.
 
 Version 2.02.133 - 30th October 2015
 ====================================

WHATS_NEW_DM

@@ -1,5 +1,44 @@
-Version 1.02.111 - 
+Version 1.02.118 - 26th February 2016
+=====================================
+  Fix string boundary check in _get_canonical_field_name().
+  Always initialized hist struct in _stats_parse_histogram().
+
+Version 1.02.117 - 21st February 2016
+=====================================
+  Improve status parsing for thin-pool and thin devices.
+
+Version 1.02.116 - 15th February 2016
+=====================================
+  Use fully aligned allocations for dm_pool_strdup/strndup() (1.02.64).
+  Fix thin-pool table parameter feature order to match kernel output.
+
+Version 1.02.115 - 25th January 2016
 ====================================
+  Fix man page for dmsetup udevcreatecookie.
+
+Version 1.02.114 - 14th December 2015
+=====================================
+  Better support for dmsetup static linkage.
+  Extend validity checks on dmeventd client socket.
+
+Version 1.02.113 - 5th December 2015
+====================================
+  Mirror plugin in dmeventd uses dm_get_status_mirror().
+  Add dm_get_status_mirror() for parsing mirror status line.
+
+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 unneded table reloads.
+
+Version 1.02.111 - 23rd November 2015
+=====================================
+  Extend dm_hash to support multiple values with the same key.
+  Add missing check for allocation inside dm_split_lvm_name().
+  Test dm_task_get_message_response for !NULL in dm_stats_print_region().
+  Add checks for failing dm_stats_create() in dmsetup.
+  Add missing fifo close when failed to initialize client connection.
 
 Version 1.02.110 - 30th October 2015
 ====================================

aclocal.m4

@@ -12,10 +12,67 @@
 # PARTICULAR PURPOSE.
 
 m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
+# ===========================================================================
+#     http://www.gnu.org/software/autoconf-archive/ax_python_module.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PYTHON_MODULE(modname[, fatal, python])
+#
+# DESCRIPTION
+#
+#   Checks for Python module.
+#
+#   If fatal is non-empty then absence of a module will trigger an error.
+#   The third parameter can either be "python" for Python 2 or "python3" for
+#   Python 3; defaults to Python 3.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Andrew Collier
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 8
+
+AU_ALIAS([AC_PYTHON_MODULE], [AX_PYTHON_MODULE])
+AC_DEFUN([AX_PYTHON_MODULE],[
+    if test -z $PYTHON;
+    then
+        if test -z "$3";
+        then
+            PYTHON="python3"
+        else
+            PYTHON="$3"
+        fi
+    fi
+    PYTHON_NAME=`basename $PYTHON`
+    AC_MSG_CHECKING($PYTHON_NAME module: $1)
+    $PYTHON -c "import $1" 2>/dev/null
+    if test $? -eq 0;
+    then
+        AC_MSG_RESULT(yes)
+        eval AS_TR_CPP(HAVE_PYMOD_$1)=yes
+    else
+        AC_MSG_RESULT(no)
+        eval AS_TR_CPP(HAVE_PYMOD_$1)=no
+        #
+        if test -n "$2"
+        then
+            AC_MSG_ERROR(failed to find required module $1)
+            exit 1
+        fi
+    fi
+])
+
 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
 # serial 1 (pkg-config-0.24)
 # 
-# Copyright (c) 2004 Scott James Remnant <scott@netsplit.com>.
+# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
 #
 # 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
@@ -227,4 +284,256 @@ AS_VAR_COPY([$1], [pkg_cv_][$1])
 AS_VAR_IF([$1], [""], [$5], [$4])dnl
 ])# PKG_CHECK_VAR
 
+# 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,
+# with or without modifications, as long as this notice is preserved.
+
+
+# AM_PATH_PYTHON([MINIMUM-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+# ---------------------------------------------------------------------------
+# Adds support for distributing Python modules and packages.  To
+# install modules, copy them to $(pythondir), using the python_PYTHON
+# automake variable.  To install a package with the same name as the
+# automake package, install to $(pkgpythondir), or use the
+# pkgpython_PYTHON automake variable.
+#
+# The variables $(pyexecdir) and $(pkgpyexecdir) are provided as
+# locations to install python extension modules (shared libraries).
+# Another macro is required to find the appropriate flags to compile
+# extension modules.
+#
+# If your package is configured with a different prefix to python,
+# users will have to add the install directory to the PYTHONPATH
+# environment variable, or create a .pth file (see the python
+# documentation for details).
+#
+# If the MINIMUM-VERSION argument is passed, AM_PATH_PYTHON will
+# cause an error if the version of python installed on the system
+# doesn't meet the requirement.  MINIMUM-VERSION should consist of
+# numbers and dots only.
+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 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])
+
+  m4_if([$1],[],[
+    dnl No version check is needed.
+    # Find any Python interpreter.
+    if test -z "$PYTHON"; then
+      AC_PATH_PROGS([PYTHON], _AM_PYTHON_INTERPRETER_LIST, :)
+    fi
+    am_display_PYTHON=python
+  ], [
+    dnl A version check is needed.
+    if test -n "$PYTHON"; then
+      # If the user set $PYTHON, use it and don't search something else.
+      AC_MSG_CHECKING([whether $PYTHON version is >= $1])
+      AM_PYTHON_CHECK_VERSION([$PYTHON], [$1],
+			      [AC_MSG_RESULT([yes])],
+			      [AC_MSG_RESULT([no])
+			       AC_MSG_ERROR([Python interpreter is too old])])
+      am_display_PYTHON=$PYTHON
+    else
+      # Otherwise, try each interpreter until we find one that satisfies
+      # VERSION.
+      AC_CACHE_CHECK([for a Python interpreter with version >= $1],
+	[am_cv_pathless_PYTHON],[
+	for am_cv_pathless_PYTHON in _AM_PYTHON_INTERPRETER_LIST none; do
+	  test "$am_cv_pathless_PYTHON" = none && break
+	  AM_PYTHON_CHECK_VERSION([$am_cv_pathless_PYTHON], [$1], [break])
+	done])
+      # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON.
+      if test "$am_cv_pathless_PYTHON" = none; then
+	PYTHON=:
+      else
+        AC_PATH_PROG([PYTHON], [$am_cv_pathless_PYTHON])
+      fi
+      am_display_PYTHON=$am_cv_pathless_PYTHON
+    fi
+  ])
+
+  if test "$PYTHON" = :; then
+  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.  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; sys.stdout.write(sys.version[[:3]])"`])
+  AC_SUBST([PYTHON_VERSION], [$am_cv_python_version])
+
+  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.
+
+  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])
+
+  # Just factor out some code duplication.
+  am_python_setup_sysconfig="\
+import sys
+# Prefer sysconfig over distutils.sysconfig, for better compatibility
+# with python 3.x.  See automake bug#10227.
+try:
+    import sysconfig
+except ImportError:
+    can_use_sysconfig = 0
+else:
+    can_use_sysconfig = 1
+# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs:
+# <https://github.com/pypa/virtualenv/issues/118>
+try:
+    from platform import python_implementation
+    if python_implementation() == 'CPython' and sys.version[[:3]] == '2.7':
+        can_use_sysconfig = 0
+except ImportError:
+    pass"
+
+  dnl Set up 4 directories:
+
+  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:
+    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')
+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
+	  ;;
+       esac
+       ;;
+     esac
+    ])
+  AC_SUBST([pythondir], [$am_cv_python_pythondir])
+
+  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 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:
+    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_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
+	   ;;
+       esac
+       ;;
+     esac
+    ])
+  AC_SUBST([pyexecdir], [$am_cv_python_pyexecdir])
+
+  dnl pkgpyexecdir -- $(pyexecdir)/$(PACKAGE)
+
+  AC_SUBST([pkgpyexecdir], [\${pyexecdir}/$PACKAGE])
+
+  dnl Run any user-specified action.
+  $2
+  fi
+
+])
+
+
+# AM_PYTHON_CHECK_VERSION(PROG, VERSION, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+# ---------------------------------------------------------------------------
+# Run ACTION-IF-TRUE if the Python interpreter PROG has version >= VERSION.
+# Run ACTION-IF-FALSE otherwise.
+# This test uses sys.hexversion instead of the string equivalent (first
+# word of sys.version), in order to cope with versions such as 2.2c1.
+# This supports Python 2.0 or higher. (2.0 was released on October 16, 2000).
+AC_DEFUN([AM_PYTHON_CHECK_VERSION],
+ [prog="import sys
+# split strings by '.' and convert to numeric.  Append some zeros
+# because we need at least 4 digits for the hex conversion.
+# map returns an iterator in Python 3.0 and a list in 2.x
+minver = list(map(int, '$2'.split('.'))) + [[0, 0, 0]]
+minverhex = 0
+# xrange is not present in Python 3.0 and range returns an iterator
+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-2014 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_RUN_LOG(COMMAND)
+# -------------------
+# Run COMMAND, save the exit status in ac_status, and log it.
+# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
+AC_DEFUN([AM_RUN_LOG],
+[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
+   ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   (exit $ac_status); }])
+
 m4_include([acinclude.m4])

autoconf/py-compile

@@ -0,0 +1,170 @@
+#!/bin/sh
+# py-compile - Compile a Python program
+
+scriptversion=2011-06-08.12; # UTC
+
+# 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
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# 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 <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
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+if [ -z "$PYTHON" ]; then
+  PYTHON=python
+fi
+
+me=py-compile
+
+usage_error ()
+{
+  echo "$me: $*" >&2
+  echo "Try '$me --help' for more information." >&2
+  exit 1
+}
+
+basedir=
+destdir=
+while test $# -ne 0; do
+  case "$1" in
+    --basedir)
+      if test $# -lt 2; then
+        usage_error "option '--basedir' requires an argument"
+      else
+        basedir=$2
+      fi
+      shift
+      ;;
+    --destdir)
+      if test $# -lt 2; then
+        usage_error "option '--destdir' requires an argument"
+      else
+        destdir=$2
+      fi
+      shift
+      ;;
+    -h|--help)
+      cat <<\EOF
+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.
+
+Example:
+  py-compile --destdir /tmp/pkg-root --basedir /usr/share/test test.py test2.py
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+      exit $?
+      ;;
+    -v|--version)
+      echo "$me $scriptversion"
+      exit $?
+      ;;
+    --)
+      shift
+      break
+      ;;
+    -*)
+      usage_error "unrecognized option '$1'"
+      ;;
+    *)
+      break
+      ;;
+  esac
+  shift
+done
+
+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 [ -z "$basedir" ]; then
+    pathtrans="path = file"
+else
+    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 [ -z "$destdir" ]; then
+    filetrans="filepath = path"
+else
+    filetrans="filepath = os.path.normpath('$destdir' + os.sep + path)"
+fi
+
+$PYTHON -c "
+import sys, os, py_compile, imp
+
+files = '''$files'''
+
+sys.stdout.write('Byte-compiling python modules...\n')
+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)
+    sys.stdout.flush()
+    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 $?
+
+# this will fail for python < 1.5, but that doesn't matter ...
+$PYTHON -O -c "
+import sys, os, py_compile, imp
+
+# 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 files.split():
+    $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()
+    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 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

conf/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

conf/command_profile_template.profile.in

@@ -11,14 +11,22 @@
 # Refer to 'man lvm.conf' for further information about profiles and
 # general configuration file layout.
 #
+allocation {
+	cache_mode="writethrough"
+	cache_settings {
+	}
+}
+
 global {
 	units="h"
 	si_unit_consistency=1
 	suffix=1
 	lvdisplay_shows_full_device_path=0
 }
+
 report {
 	compact_output=0
+	compact_output_cols=""
 	aligned=1
 	buffered=1
 	headings=1
@@ -28,6 +36,7 @@ report {
 	quoted=1
 	colums_as_rows=0
 	binary_values_as_numeric=0
+	time_format="%Y-%m-%d %T %z"
 	devtypes_sort="devtype_name"
 	devtypes_cols="devtype_name,devtype_max_partitions,devtype_description"
 	devtypes_cols_verbose="devtype_name,devtype_max_partitions,devtype_description"
@@ -46,4 +55,5 @@ report {
 	pvsegs_sort="pv_name,pvseg_start"
 	pvsegs_cols="pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size"
 	pvsegs_cols_verbose="pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size,lv_name,seg_start_pe,segtype,seg_pe_ranges"
+	mark_hidden_devices=1
 }

conf/example.conf.in

@@ -1109,8 +1109,8 @@ activation {
 	#   @*
 	#     Selects an LV if a tag defined on the host is also set on the LV
 	#     or VG. See tags/hosttags. If any host tags exist but volume_list
-	#     is not defined, a default single-entry list containing '@*' is
-	#     assumed.
+	#     is not defined, a default single-entry list containing '@*'
+	#     is assumed.
 	# 
 	# Example
 	# volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
@@ -1146,11 +1146,11 @@ activation {
 	#   @*
 	#     Selects an LV if a tag defined on the host is also set on the LV
 	#     or VG. See tags/hosttags. If any host tags exist but volume_list
-	#     is not defined, a default single-entry list containing '@*' is
-	#     assumed.
+	#     is not defined, a default single-entry list containing '@*'
+	#     is assumed.
 	# 
 	# Example
-	# volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
+	# auto_activation_volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
 	# 
 	# This configuration option does not have a default value defined.
 
@@ -1172,11 +1172,11 @@ activation {
 	#   @*
 	#     Selects an LV if a tag defined on the host is also set on the LV
 	#     or VG. See tags/hosttags. If any host tags exist but volume_list
-	#     is not defined, a default single-entry list containing '@*' is
-	#     assumed.
+	#     is not defined, a default single-entry list containing '@*'
+	#     is assumed.
 	# 
 	# Example
-	# volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
+	# read_only_volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
 	# 
 	# This configuration option does not have a default value defined.
 
@@ -1415,6 +1415,17 @@ activation {
 # This configuration section has an automatic default value.
 # metadata {
 
+	# Configuration option metadata/check_pv_device_sizes.
+	# Check device sizes are not smaller than corresponding PV sizes.
+	# If device size is less than corresponding PV size found in metadata,
+	# there is always a risk of data loss. If this option is set, then LVM
+	# issues a warning message each time it finds that the device size is
+	# less than corresponding PV size. You should not disable this unless
+	# you are absolutely sure about what you are doing!
+	# This configuration option is advanced.
+	# This configuration option has an automatic default value.
+	# check_pv_device_sizes = 1
+
 	# Configuration option metadata/pvmetadatacopies.
 	# Number of copies of metadata to store on each PV.
 	# The --pvmetadatacopies option overrides this setting.
@@ -1808,6 +1819,11 @@ activation {
 	# See 'pvs --segments -o help' for the list of possible fields.
 	# This configuration option has an automatic default value.
 	# pvsegs_cols_verbose = "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size,lv_name,seg_start_pe,segtype,seg_pe_ranges"
+
+	# Configuration option report/mark_hidden_devices.
+	# Use brackets [] to mark hidden devices.
+	# This configuration option has an automatic default value.
+	# mark_hidden_devices = 1
 # }
 
 # Configuration section dmeventd.

configure.in

@@ -1,6 +1,6 @@
 ###############################################################################
 ## Copyright (C) 2000-2004 Sistina Software, Inc. All rights reserved.
-## Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.
+## Copyright (C) 2004-2016 Red Hat, Inc. All rights reserved.
 ##
 ## This copyrighted material is made available to anyone wishing to use,
 ## modify, copy, or redistribute it subject to the terms and conditions
@@ -8,10 +8,10 @@
 ##
 ## 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+## Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 ################################################################################
 
-AC_PREREQ(2.61)
+AC_PREREQ(2.69)
 ################################################################################
 dnl -- Process this file with autoconf to produce a configure script.
 AC_INIT
@@ -39,7 +39,6 @@ case "$host_os" in
 		DEVMAPPER=yes
 		LVMETAD=no
 		LVMPOLLD=no
-		LVMLOCKD=no
 		LOCKDSANLOCK=no
 		LOCKDDLM=no
 		ODIRECT=yes
@@ -86,6 +85,7 @@ AC_PROG_MKDIR_P
 AC_PROG_RANLIB
 AC_PATH_TOOL(CFLOW_CMD, cflow)
 AC_PATH_TOOL(CSCOPE_CMD, cscope)
+AC_PATH_TOOL(CHMOD, chmod)
 
 ################################################################################
 dnl -- Check for header files.
@@ -1145,6 +1145,8 @@ AC_MSG_RESULT($LVMPOLLD)
 BUILD_LVMPOLLD=$LVMPOLLD
 
 ################################################################################
+BUILD_LVMLOCKD=no
+
 dnl -- Build lockdsanlock
 AC_MSG_CHECKING(whether to build lockdsanlock)
 AC_ARG_ENABLE(lockd-sanlock,
@@ -1155,14 +1157,10 @@ AC_MSG_RESULT($LOCKDSANLOCK)
 
 BUILD_LOCKDSANLOCK=$LOCKDSANLOCK
 
-if test "$BUILD_LOCKDSANLOCK" = yes; then
-	AC_DEFINE([LOCKDSANLOCK_SUPPORT], 1, [Define to 1 to include code that uses lvmlockd sanlock option.])
-fi
-
-################################################################################
 dnl -- Look for sanlock libraries
 if test "$BUILD_LOCKDSANLOCK" = yes; then
-	PKG_CHECK_MODULES(LOCKD_SANLOCK, libsanlock_client, [HAVE_LOCKD_SANLOCK=yes], $bailout)
+	PKG_CHECK_MODULES(LOCKD_SANLOCK, libsanlock_client >= 3.3.0, [HAVE_LOCKD_SANLOCK=yes], $bailout)
+	AC_DEFINE([LOCKDSANLOCK_SUPPORT], 1, [Define to 1 to include code that uses lvmlockd sanlock option.])
 	BUILD_LVMLOCKD=yes
 fi
 
@@ -1177,20 +1175,15 @@ AC_MSG_RESULT($LOCKDDLM)
 
 BUILD_LOCKDDLM=$LOCKDDLM
 
-if test "$BUILD_LOCKDDLM" = yes; then
-	AC_DEFINE([LOCKDDLM_SUPPORT], 1, [Define to 1 to include code that uses lvmlockd dlm option.])
-fi
-
-################################################################################
 dnl -- Look for dlm libraries
 if test "$BUILD_LOCKDDLM" = yes; then
 	PKG_CHECK_MODULES(LOCKD_DLM, libdlm, [HAVE_LOCKD_DLM=yes], $bailout)
+	AC_DEFINE([LOCKDDLM_SUPPORT], 1, [Define to 1 to include code that uses lvmlockd dlm option.])
 	BUILD_LVMLOCKD=yes
 fi
 
 ################################################################################
 dnl -- Build lvmlockd
-
 AC_MSG_CHECKING(whether to build lvmlockd)
 AC_MSG_RESULT($BUILD_LVMLOCKD)
 
@@ -1299,7 +1292,7 @@ if test "$BLKID_WIPING" != no; then
 		DEFAULT_USE_BLKID_WIPING=1
 		AC_DEFINE([BLKID_WIPING_SUPPORT], 1, [Define to 1 to use libblkid detection of signatures when wiping.])
 	else
-		DEFAULT_USE_BLKID_WIPING=1
+		DEFAULT_USE_BLKID_WIPING=0
 	fi
 else
 	DEFAULT_USE_BLKID_WIPING=0
@@ -1342,6 +1335,10 @@ if test "$UDEV_SYNC" = yes; then
 	pkg_config_init
 	PKG_CHECK_MODULES(UDEV, libudev >= 143, [UDEV_PC="libudev"])
 	AC_DEFINE([UDEV_SYNC_SUPPORT], 1, [Define to 1 to enable synchronisation with udev processing.])
+
+	AC_CHECK_LIB(udev, udev_device_get_is_initialized, AC_DEFINE([HAVE_LIBUDEV_UDEV_DEVICE_GET_IS_INITIALIZED], 1,
+	  [Define to 1 if udev_device_get_is_initialized is available.]))
+	LIBS=$ac_check_lib_save_LIBS
 fi
 
 dnl -- Enable udev rules
@@ -1441,25 +1438,76 @@ test "$CMDLIB" = yes \
   && LVM2CMD_LIB=-llvm2cmd \
   || LVM2CMD_LIB=
 
+################################################################################
+dnl -- Enable D-Bus service
+AC_MSG_CHECKING(whether to include Python D-Bus support)
+AC_ARG_ENABLE(dbus-service,
+	      AC_HELP_STRING([--enable-dbus-service], [install D-Bus support]),
+	      BUILD_LVMDBUSD=$enableval, BUILD_LVMDBUSD=no)
+AC_MSG_RESULT($BUILD_LVMDBUSD)
+
 ################################################################################
 dnl -- Enable Python liblvm2app bindings
 AC_MSG_CHECKING(whether to build Python wrapper for liblvm2app.so)
 AC_ARG_ENABLE(python_bindings,
-	      AC_HELP_STRING([--enable-python_bindings], [build Python applib bindings]),
+	      AC_HELP_STRING([--enable-python_bindings], [build default Python applib bindings]),
 	      PYTHON_BINDINGS=$enableval, PYTHON_BINDINGS=no)
 AC_MSG_RESULT($PYTHON_BINDINGS)
 
+AC_MSG_CHECKING(whether to build Python2 wrapper for liblvm2app.so)
+AC_ARG_ENABLE(python2_bindings,
+	      AC_HELP_STRING([--enable-python2_bindings], [build Python2 applib bindings]),
+	      PYTHON2_BINDINGS=$enableval, PYTHON2_BINDINGS=no)
+AC_MSG_RESULT($PYTHON2_BINDINGS)
+
+
+AC_MSG_CHECKING(whether to build Python3 wrapper for liblvm2app.so)
+AC_ARG_ENABLE(python3_bindings,
+	      AC_HELP_STRING([--enable-python3_bindings], [build Python3 applib bindings]),
+	      PYTHON3_BINDINGS=$enableval, PYTHON3_BINDINGS=no)
+AC_MSG_RESULT($PYTHON3_BINDINGS)
+
 if test "$PYTHON_BINDINGS" = yes; then
-	test "$APPLIB" != yes && AC_MSG_ERROR([--enable-python_bindings requires --enable-applib])
+	AC_MSG_ERROR([--enable-python-bindings is replaced by --enable-python2-bindings and --enable-python3-bindings])
+fi
 
-	AC_PATH_TOOL(PYTHON, python)
-	test -z "$PYTHON" && AC_MSG_ERROR([python is required for --enable-python_bindings but cannot be found])
+if test "$PYTHON2_BINDINGS" = yes; then
+	AM_PATH_PYTHON([2])
+	AC_PATH_TOOL(PYTHON2, python2)
+	test -z "$PYTHON2" && AC_MSG_ERROR([python2 is required for --enable-python2_bindings but cannot be found])
+	AC_PATH_TOOL(PYTHON2_CONFIG, python2-config)
+	test -z "$PYTHON2_CONFIG" && AC_PATH_TOOL(PYTHON2_CONFIG, python-config)
+	test -z "$PYTHON2_CONFIG" && AC_MSG_ERROR([python headers are required for --enable-python2_bindings but cannot be found])
+	PYTHON2_INCDIRS=`"$PYTHON2_CONFIG" --includes`
+	PYTHON2_LIBDIRS=`"$PYTHON2_CONFIG" --libs`
+	PYTHON2DIR=$pythondir
+	PYTHON_BINDINGS=yes
+fi
+	
+if test "$PYTHON3_BINDINGS" = yes -o "$BUILD_LVMDBUSD" = yes; then
+	unset PYTHON PYTHON_CONFIG
+	unset am_cv_pathless_PYTHON ac_cv_path_PYTHON am_cv_python_platform
+	unset am_cv_python_pythondir am_cv_python_version am_cv_python_pyexecdir
+	unset ac_cv_path_PYTHON_CONFIG ac_cv_path_ac_pt_PYTHON_CONFIG
+	AM_PATH_PYTHON([3])
+	PYTHON3=$PYTHON
+	test -z "$PYTHON3" && AC_MSG_ERROR([python3 is required for --enable-python3_bindings or --enable-dbus-service but cannot be found])
+	AC_PATH_TOOL(PYTHON3_CONFIG, python3-config)
+	test -z "$PYTHON3_CONFIG" && AC_MSG_ERROR([python3 headers are required for --enable-python3_bindings or --enable-dbus-service but cannot be found])
+	PYTHON3_INCDIRS=`"$PYTHON3_CONFIG" --includes`
+	PYTHON3_LIBDIRS=`"$PYTHON3_CONFIG" --libs`
+	PYTHON3DIR=$pythondir
+	PYTHON_BINDINGS=yes
+fi
 
-	AC_PATH_TOOL(PYTHON_CONFIG, python-config)
-	test -z "$PYTHON_CONFIG" && AC_MSG_ERROR([python headers are required for --enable-python_bindings but cannot be found])
+if test "$BUILD_LVMDBUSD" = yes; then
+	# To get this macro, install autoconf-archive package then run autoreconf
+	AC_PYTHON_MODULE([pyudev], [Required], python3)
+	AC_PYTHON_MODULE([dbus], [Required], python3)
+fi
 
-	PYTHON_INCDIRS=`"$PYTHON_CONFIG" --includes`
-	PYTHON_LIBDIRS=`"$PYTHON_CONFIG" --libs`
+if test "$PYTHON_BINDINGS" = yes -o "$PYTHON2_BINDINGS" = yes -o "$PYTHON3_BINDINGS" = yes; then
+	test "$APPLIB" != yes && AC_MSG_ERROR([Python_bindings require --enable-applib])
 fi
 
 ################################################################################
@@ -1911,6 +1959,7 @@ AC_SUBST(AWK)
 AC_SUBST(BLKID_PC)
 AC_SUBST(BUILD_CMIRRORD)
 AC_SUBST(BUILD_DMEVENTD)
+AC_SUBST(BUILD_LVMDBUSD)
 AC_SUBST(BUILD_LVMETAD)
 AC_SUBST(BUILD_LVMPOLLD)
 AC_SUBST(BUILD_LVMLOCKD)
@@ -1919,6 +1968,7 @@ AC_SUBST(BUILD_LOCKDDLM)
 AC_SUBST(CACHE)
 AC_SUBST(CFLAGS)
 AC_SUBST(CFLOW_CMD)
+AC_SUBST(CHMOD)
 AC_SUBST(CLDFLAGS)
 AC_SUBST(CLDNOWHOLEARCHIVE)
 AC_SUBST(CLDWHOLEARCHIVE)
@@ -1995,10 +2045,17 @@ AC_SUBST(PKGCONFIG)
 AC_SUBST(POOL)
 AC_SUBST(M_LIBS)
 AC_SUBST(PTHREAD_LIBS)
-AC_SUBST(PYTHON)
+AC_SUBST(PYTHON2)
+AC_SUBST(PYTHON3)
 AC_SUBST(PYTHON_BINDINGS)
-AC_SUBST(PYTHON_INCDIRS)
-AC_SUBST(PYTHON_LIBDIRS)
+AC_SUBST(PYTHON2_BINDINGS)
+AC_SUBST(PYTHON3_BINDINGS)
+AC_SUBST(PYTHON2_INCDIRS)
+AC_SUBST(PYTHON3_INCDIRS)
+AC_SUBST(PYTHON2_LIBDIRS)
+AC_SUBST(PYTHON3_LIBDIRS)
+AC_SUBST(PYTHON2DIR)
+AC_SUBST(PYTHON3DIR)
 AC_SUBST(QUORUM_CFLAGS)
 AC_SUBST(QUORUM_LIBS)
 AC_SUBST(RAID)
@@ -2070,6 +2127,8 @@ daemons/dmeventd/plugins/raid/Makefile
 daemons/dmeventd/plugins/mirror/Makefile
 daemons/dmeventd/plugins/snapshot/Makefile
 daemons/dmeventd/plugins/thin/Makefile
+daemons/lvmdbusd/Makefile
+daemons/lvmdbusd/path.py
 daemons/lvmetad/Makefile
 daemons/lvmpolld/Makefile
 daemons/lvmlockd/Makefile
@@ -2107,12 +2166,14 @@ scripts/blk_availability_init_red_hat
 scripts/blk_availability_systemd_red_hat.service
 scripts/clvmd_init_red_hat
 scripts/cmirrord_init_red_hat
+scripts/com.redhat.lvmdbus1.service
 scripts/dm_event_systemd_red_hat.service
 scripts/dm_event_systemd_red_hat.socket
 scripts/lvm2_cluster_activation_red_hat.sh
 scripts/lvm2_cluster_activation_systemd_red_hat.service
 scripts/lvm2_clvmd_systemd_red_hat.service
 scripts/lvm2_cmirrord_systemd_red_hat.service
+scripts/lvm2_lvmdbusd_systemd_red_hat.service
 scripts/lvm2_lvmetad_init_red_hat
 scripts/lvm2_lvmetad_systemd_red_hat.service
 scripts/lvm2_lvmetad_systemd_red_hat.socket

coverity/coverity_model.c

@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2015 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
+ */
+
+/*
+ * Coverity usage:
+ *
+ * translate model into xml
+ * cov-make-library -of coverity_model.xml coverity_model.c
+ *
+ * compile (using outdir 'cov'):
+ * cov-build --dir=cov make CC=gcc
+ *
+ * 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'):
+ * cov-format-errors --dir cov  --html-output html
+ */
+
+struct lv_segment;
+struct logical_volume;
+
+struct lv_segment *first_seg(const struct logical_volume *lv)
+{
+	return ((struct lv_segment **)lv)[0];
+}
+
+struct lv_segment *last_seg(const struct logical_volume *lv)
+{
+	return ((struct lv_segment **)lv)[0];
+}
+
+/* simple_memccpy() from glibc */
+void *memccpy(void *dest, const void *src, int c, size_t n)
+{
+	const char *s = src;
+	char *d = dest;
+
+	while (n-- > 0)
+		if ((*d++ = *s++) == (char) c)
+			return d;
+
+	return 0;
+}
+
+/*
+ * 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
+ */
+//#nodef FD_ZERO model_FD_ZERO
+//void model_FD_ZERO(void *fdset);
+
+void model_FD_ZERO(void *fdset)
+{
+	unsigned i;
+
+	for (i = 0; i < 1024 / 8 / sizeof(long); ++i)
+		((long*)fdset)[i] = 0;
+}
+
+/*
+ * Added extra pointer check to not need these models,
+ * for now just keep then in file
+ */
+
+/*
+struct cmd_context;
+struct profile;
+
+const char *find_config_tree_str(struct cmd_context *cmd, int id, struct profile *profile)
+{
+        return "text";
+}
+
+const char *find_config_tree_str_allow_empty(struct cmd_context *cmd, int id, struct profile *profile)
+{
+        return "text";
+}
+*/
+
+/*
+ * Until fixed coverity case# 00531860:
+ *   A FORWARD_NULL false positive on a recursive function call
+ *
+ * model also these functions:
+ */
+/*
+const struct dm_config_node;
+const struct dm_config_node *find_config_tree_array(struct cmd_context *cmd, int id, struct profile *profile)
+{
+	const struct dm_config_node *cn;
+
+	return cn;
+}
+
+const struct dm_config_node *find_config_tree_node(struct cmd_context *cmd, int id, struct profile *profile)
+{
+	const struct dm_config_node *cn;
+
+	return cn;
+}
+
+int find_config_tree_bool(struct cmd_context *cmd, int id, struct profile *profile)
+{
+	int b;
+
+	return b;
+}
+*/

daemons/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@
@@ -44,8 +44,12 @@ ifeq ("@BUILD_LVMLOCKD@", "yes")
   SUBDIRS += lvmlockd 
 endif
 
+ifeq ("@BUILD_LVMDBUSD@", "yes")
+  SUBDIRS += lvmdbusd 
+endif
+
 ifeq ($(MAKECMDGOALS),distclean)
-  SUBDIRS = clvmd cmirrord dmeventd lvmetad lvmpolld lvmlockd
+  SUBDIRS = clvmd cmirrord dmeventd lvmetad lvmpolld lvmlockd lvmdbusd
 endif
 
 include $(top_builddir)/make.tmpl

daemons/clvmd/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/clvmd/clvm.h

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /* Definitions for CLVMD server and clients */
@@ -50,7 +50,7 @@ struct clvm_header {
 #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 */
-static const char CLVMD_SOCKNAME[]= DEFAULT_RUN_DIR "/clvmd.sock";
+#define CLVMD_SOCKNAME		DEFAULT_RUN_DIR "/clvmd.sock"
 
 /* Internal commands & replies */
 #define CLVMD_CMD_REPLY    1
@@ -76,8 +76,10 @@ static const char CLVMD_SOCKNAME[]= DEFAULT_RUN_DIR "/clvmd.sock";
 #define CLVMD_CMD_SYNC_NAMES	    45
 
 /* Used internally by some callers, but not part of the protocol.*/
-#define NODE_ALL	"*"
-#define NODE_LOCAL	"."
-#define NODE_REMOTE	"^"
+#ifndef NODE_ALL
+#  define NODE_ALL	"*"
+#  define NODE_LOCAL	"."
+#  define NODE_REMOTE	"^"
+#endif
 
 #endif

daemons/clvmd/clvmd-cman.c

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/clvmd/clvmd-command.c

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/clvmd/clvmd-common.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/clvmd/clvmd-comms.h

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/clvmd/clvmd-corosync.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/clvmd/clvmd-openais.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/clvmd/clvmd-singlenode.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "clvmd-common.h"

daemons/clvmd/clvmd.c

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*
@@ -374,7 +374,7 @@ int main(int argc, char *argv[])
 	/* Deal with command-line arguments */
 	opterr = 0;
 	optind = 0;
-	while ((opt = getopt_long(argc, argv, "vVhfd:t:RST:CI:E:",
+	while ((opt = getopt_long(argc, argv, "Vhfd:t:RST:CI:E:",
 				  longopts, NULL)) != -1) {
 		switch (opt) {
 		case 'h':
@@ -604,7 +604,10 @@ int main(int argc, char *argv[])
 		 local_client_head.fd, &local_client_head, newfd->fd, newfd);
 
 	/* Don't let anyone else to do work until we are started */
-	pthread_create(&lvm_thread, &stack_attr, lvm_thread_fn, &lvm_params);
+	if (pthread_create(&lvm_thread, &stack_attr, lvm_thread_fn, &lvm_params)) {
+		log_sys_error("pthread_create", "");
+		goto out;
+	}
 
 	/* Don't start until the LVM thread is ready */
 	pthread_barrier_wait(&lvm_start_barrier);

daemons/clvmd/clvmd.h

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef _CLVMD_H

daemons/clvmd/lvm-functions.c

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "clvmd-common.h"
@@ -291,6 +291,7 @@ static int hold_lock(char *resource, int mode, int flags)
 		}
 
 		lvi->lock_mode = mode;
+		lvi->lock_id = 0;
 		status = sync_lock(resource, mode, flags & ~LCKF_CONVERT, &lvi->lock_id);
 		saved_errno = errno;
 		if (status) {
@@ -662,7 +663,8 @@ int do_refresh_cache(void)
 
 	init_full_scan_done(0);
 	init_ignore_suspended_devices(1);
-	lvmcache_label_scan(cmd, 2);
+	lvmcache_force_next_label_scan();
+	lvmcache_label_scan(cmd);
 	dm_pool_empty(cmd->mem);
 
 	pthread_mutex_unlock(&lvm_lock);
@@ -899,8 +901,12 @@ int init_clvm(struct dm_hash_table *excl_uuid)
 	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;
 	}
 
@@ -927,6 +933,7 @@ void destroy_lvm(void)
 	if (cmd) {
 		memlock_dec_daemon(cmd);
 		destroy_toolcontext(cmd);
+		udev_fin_library_context();
 		cmd = NULL;
 	}
 }

daemons/clvmd/lvm-functions.h

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /* Functions in lvm-functions.c */

daemons/clvmd/refresh_clvmd.c

@@ -10,7 +10,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /* FIXME Remove duplicated functions from this file. */

daemons/clvmd/refresh_clvmd.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 

daemons/cmirrord/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/cmirrord/clogd.c

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "logging.h"
 #include "common.h"

daemons/cmirrord/cluster.c

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "logging.h"
 #include "cluster.h"
@@ -1440,7 +1440,7 @@ static void cpg_leave_callback(struct clog_cpg *match,
 			free(rq);
 		}
 	}
-	for (i = 0, j = 0; i < match->checkpoints_needed; i++, j++) {
+	for (i = 0, j = 0; (int) i < match->checkpoints_needed; i++, j++) {
 		match->checkpoint_requesters[j] = match->checkpoint_requesters[i];
 		if (match->checkpoint_requesters[i] == left->nodeid) {
 			LOG_ERROR("[%s] Removing pending ckpt from needed list (%u is leaving)",

daemons/cmirrord/cluster.h

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #ifndef _LVM_CLOG_CLUSTER_H
 #define _LVM_CLOG_CLUSTER_H

daemons/cmirrord/common.h

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #ifndef _LVM_CLOG_COMMON_H
 #define _LVM_CLOG_COMMON_H

daemons/cmirrord/functions.c

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "logging.h"
 #include "functions.h"

daemons/cmirrord/functions.h

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #ifndef _LVM_CLOG_FUNCTIONS_H
 #define _LVM_CLOG_FUNCTIONS_H

daemons/cmirrord/link_mon.c

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "logging.h"
 #include "link_mon.h"

daemons/cmirrord/link_mon.h

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #ifndef _LVM_CLOG_LINK_MON_H
 #define _LVM_CLOG_LINK_MON_H

daemons/cmirrord/local.c

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "logging.h"
 #include "common.h"

daemons/cmirrord/local.h

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #ifndef _LVM_CLOG_LOCAL_H
 #define _LVM_CLOG_LOCAL_H

daemons/cmirrord/logging.c

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "logging.h"
 

daemons/cmirrord/logging.h

@@ -7,7 +7,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef _LVM_CLOG_LOGGING_H

daemons/dmeventd/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/dmeventd/dmeventd.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*
@@ -408,7 +408,7 @@ static struct thread_status *_alloc_thread_status(const struct message_data *dat
 	if (!(thread->device.uuid = dm_strdup(data->device_uuid)))
 		goto_out;
 
-        /* Until real name resolved, use UUID */
+	/* Until real name resolved, use UUID */
 	if (!(thread->device.name = dm_strdup(data->device_uuid)))
 		goto_out;
 
@@ -1355,78 +1355,89 @@ static int _get_timeout(struct message_data *message_data)
 	return (msg->data && msg->size) ? 0 : -ENOMEM;
 }
 
-/* Open fifos used for client communication. */
-static int _open_fifos(struct dm_event_fifos *fifos)
+static int _open_fifo(const char *path)
 {
 	struct stat st;
+	int fd = -1;
+ 
+ 	/*
+	 * FIXME Explicitly verify the code's requirement that path is secure:
+	 * - All parent directories owned by root without group/other write access unless sticky.
+	 */
 
-	/* Create client fifo. */
-	(void) dm_prepare_selinux_context(fifos->client_path, S_IFIFO);
-	if ((mkfifo(fifos->client_path, 0600) == -1) && errno != EEXIST) {
-		log_sys_error("client mkfifo", fifos->client_path);
-		(void) dm_prepare_selinux_context(NULL, 0);
-		goto fail;
+	/* If path exists, only use it if it is root-owned fifo mode 0600 */
+	if ((lstat(path, &st) < 0)) {
+		if (errno != ENOENT) {
+			log_sys_error("stat", path);
+			return -1;
+		}
+	} 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);
+		if (unlink(path)) {
+			log_sys_error("unlink", path);
+			return -1;
+		}
 	}
 
-	/* Create server fifo. */
-	(void) dm_prepare_selinux_context(fifos->server_path, S_IFIFO);
-	if ((mkfifo(fifos->server_path, 0600) == -1) && errno != EEXIST) {
-		log_sys_error("server mkfifo", fifos->server_path);
+	/* Create fifo. */
+	(void) dm_prepare_selinux_context(path, S_IFIFO);
+	if ((mkfifo(path, 0600) == -1) && errno != EEXIST) {
+		log_sys_error("mkfifo", path);
 		(void) dm_prepare_selinux_context(NULL, 0);
 		goto fail;
 	}
 
 	(void) dm_prepare_selinux_context(NULL, 0);
 
-	/* Warn about wrong permissions if applicable */
-	if ((!stat(fifos->client_path, &st)) && (st.st_mode & 0777) != 0600)
-		log_warn("WARNING: Fixing wrong permissions on %s: %s.\n",
-			 fifos->client_path, strerror(errno));
-
-	if ((!stat(fifos->server_path, &st)) && (st.st_mode & 0777) != 0600)
-		log_warn("WARNING: Fixing wrong permissions on %s: %s.\n",
-			 fifos->server_path, strerror(errno));
-
-	/* If they were already there, make sure permissions are ok. */
-	if (chmod(fifos->client_path, 0600)) {
-		log_sys_error("chmod", fifos->client_path);
-		goto fail;
-	}
-
-	if (chmod(fifos->server_path, 0600)) {
-		log_sys_error("chmod", fifos->server_path);
-		goto fail;
-	}
-
 	/* Need to open read+write or we will block or fail */
-	if ((fifos->server = open(fifos->server_path, O_RDWR)) < 0) {
-		log_sys_error("server open", fifos->server_path);
+	if ((fd = open(path, O_RDWR)) < 0) {
+		log_sys_error("open", path);
 		goto fail;
 	}
 
-	if (fcntl(fifos->server, F_SETFD, FD_CLOEXEC) < 0) {
-		log_sys_error("fcntl(FD_CLOEXEC)", fifos->server_path);
+	/* Warn about wrong permissions if applicable */
+	if (fstat(fd, &st)) {
+		log_sys_error("fstat", path);
 		goto fail;
 	}
 
-	/* Need to open read+write for select() to work. */
-	if ((fifos->client = open(fifos->client_path, O_RDWR)) < 0) {
-		log_sys_error("client open", fifos->client_path);
+	if (!S_ISFIFO(st.st_mode) || st.st_uid ||
+	    (st.st_mode & (S_IEXEC | S_IRWXG | S_IRWXO))) {
+		log_error("%s: fifo has incorrect attributes", path);
 		goto fail;
 	}
 
-	if (fcntl(fifos->client, F_SETFD, FD_CLOEXEC) < 0) {
-		log_sys_error("fcntl(FD_CLOEXEC)", fifos->client_path);
+	if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
+		log_sys_error("fcntl(FD_CLOEXEC)", path);
 		goto fail;
 	}
 
+	return fd;
+
+fail:
+	if ((fd >= 0) && close(fd))
+		log_sys_error("close", path);
+
+	return -1;
+}
+
+/* Open fifos used for client communication. */
+static int _open_fifos(struct dm_event_fifos *fifos)
+{
+	/* Create client fifo. */
+	if ((fifos->client = _open_fifo(fifos->client_path)) < 0)
+		goto fail;
+
+	/* Create server fifo. */
+	if ((fifos->server = _open_fifo(fifos->server_path)) < 0)
+		goto fail;
+
 	return 1;
-fail:
-	if (fifos->server >= 0 && close(fifos->server))
-		log_sys_error("server close", fifos->server_path);
 
+fail:
 	if (fifos->client >= 0 && close(fifos->client))
-		log_sys_error("client close", fifos->client_path);
+		log_sys_error("close", fifos->client_path);
 
 	return 0;
 }
@@ -1961,21 +1972,21 @@ static int _reinstate_registrations(struct dm_event_fifos *fifos)
 		    !(dev_name = strtok(NULL, _delim)) ||
 		    !(mask = strtok(NULL, _delim)) ||
 		    !(timeout = strtok(NULL, _delim))) {
-			fprintf(stderr, _failed_parsing_msg);
+			fputs(_failed_parsing_msg, stderr);
 			continue;
 		}
 
 		errno = 0;
 		mask_value = strtoul(mask, &endp, 10);
 		if (errno || !endp || *endp) {
-			fprintf(stderr, _failed_parsing_msg);
+			fputs(_failed_parsing_msg, stderr);
 			continue;
 		}
 
 		errno = 0;
 		timeout_value = strtoul(timeout, &endp, 10);
 		if (errno || !endp || *endp) {
-			fprintf(stderr, _failed_parsing_msg);
+			fputs(_failed_parsing_msg, stderr);
 			continue;
 		}
 
@@ -2260,9 +2271,9 @@ int main(int argc, char *argv[])
 
 	log_notice("dmeventd shutting down.");
 
-	if (close(fifos.client))
+	if (fifos.client >= 0 && close(fifos.client))
 		log_sys_error("client close", fifos.client_path);
-	if (close(fifos.server))
+	if (fifos.server >= 0 && close(fifos.server))
 		log_sys_error("server close", fifos.server_path);
 
 	if (_use_syslog)

daemons/dmeventd/dmeventd.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef __DMEVENTD_DOT_H__

daemons/dmeventd/libdevmapper-event.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "dm-logging.h"
@@ -412,28 +412,55 @@ static int _start_daemon(char *dmeventd_path, struct dm_event_fifos *fifos)
 	char default_dmeventd_path[] = DMEVENTD_PATH;
 	char *args[] = { dmeventd_path ? : default_dmeventd_path, NULL };
 
-	if (stat(fifos->client_path, &statbuf))
-		goto start_server;
+	/*
+	 * FIXME Explicitly verify the code's requirement that client_path is secure:
+	 * - All parent directories owned by root without group/other write access unless sticky.
+	 */
 
-	if (!S_ISFIFO(statbuf.st_mode)) {
-		log_error("%s is not a fifo.", fifos->client_path);
+	/* If client fifo path exists, only use it if it is root-owned fifo mode 0600 */
+	if ((lstat(fifos->client_path, &statbuf) < 0)) {
+		if (errno == ENOENT)
+			/* Jump ahead if fifo does not already exist. */
+			goto start_server;
+		else {
+			log_sys_error("stat", fifos->client_path);
+			return 0;
+		}
+	} else if (!S_ISFIFO(statbuf.st_mode)) {
+		log_error("%s must be a fifo.", fifos->client_path);
+		return 0;
+	} else if (statbuf.st_uid) {
+		log_error("%s must be owned by uid 0.", fifos->client_path);
+		return 0;
+	} else if (statbuf.st_mode & (S_IEXEC | S_IRWXG | S_IRWXO)) {
+		log_error("%s must have mode 0600.", fifos->client_path);
 		return 0;
 	}
 
 	/* Anyone listening?  If not, errno will be ENXIO */
 	fifos->client = open(fifos->client_path, O_WRONLY | O_NONBLOCK);
 	if (fifos->client >= 0) {
+		/* Should never happen if all the above checks passed. */
+		if ((fstat(fifos->client, &statbuf) < 0) ||
+		    !S_ISFIFO(statbuf.st_mode) || statbuf.st_uid ||
+		    (statbuf.st_mode & (S_IEXEC | S_IRWXG | S_IRWXO))) {
+			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);
+			return 0;
+		}
+
 		/* server is running and listening */
 		if (close(fifos->client))
 			log_sys_debug("close", fifos->client_path);
 		return 1;
-	} else if (errno != ENXIO) {
+	} else if (errno != ENXIO && errno != ENOENT)  {
 		/* problem */
 		log_sys_error("open", fifos->client_path);
 		return 0;
 	}
 
-      start_server:
+start_server:
 	/* server is not running */
 
 	if ((args[0][0] == '/') && stat(args[0], &statbuf)) {
@@ -587,8 +614,8 @@ static int _do_event(int cmd, char *dmeventd_path, struct dm_event_daemon_messag
 	};
 
 	if (!_init_client(dmeventd_path, &fifos)) {
-		stack;
-		return -ESRCH;
+		ret = -ESRCH;
+		goto_out;
 	}
 
 	ret = daemon_talk(&fifos, msg, DM_EVENT_CMD_HELLO, NULL, NULL, 0, 0);
@@ -598,7 +625,7 @@ static int _do_event(int cmd, char *dmeventd_path, struct dm_event_daemon_messag
 
 	if (!ret)
 		ret = daemon_talk(&fifos, msg, cmd, dso_name, dev_name, evmask, timeout);
-
+out:
 	/* what is the opposite of init? */
 	fini_fifos(&fifos);
 
@@ -727,6 +754,7 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next)
 
 	uuid = dm_task_get_uuid(dmt);
 
+	/* FIXME Distinguish errors connecting to daemon */
 	if (_do_event(next ? DM_EVENT_CMD_GET_NEXT_REGISTERED_DEVICE :
 		      DM_EVENT_CMD_GET_REGISTERED_DEVICE, dmevh->dmeventd_path,
 		      &msg, dmevh->dso, uuid, dmevh->mask, 0)) {
@@ -841,7 +869,7 @@ void dm_event_log(const char *subsys, int level, const char *file,
 	static time_t start = 0;
 	const char *indent = "";
 	FILE *stream = stdout;
-	int prio = -1;
+	int prio;
 	time_t now;
 
 	switch (level & ~(_LOG_STDERR | _LOG_ONCE)) {

daemons/dmeventd/libdevmapper-event.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/dmeventd/plugins/Makefile.in

@@ -10,7 +10,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/dmeventd/plugins/lvm2/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/dmeventd/plugins/lvm2/dmeventd_lvm.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "lib.h"

daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*

daemons/dmeventd/plugins/mirror/Makefile.in

@@ -10,7 +10,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -9,13 +9,12 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "lib.h"
 #include "libdevmapper-event.h"
 #include "dmeventd_lvm.h"
-#include "defaults.h"
 
 /* FIXME Reformat to 80 char lines. */
 
@@ -31,8 +30,9 @@ struct dso_state {
 
 DM_EVENT_LOG_FN("mirr")
 
-static int _process_status_code(const char status_code, const char *dev_name,
-				const char *dev_type, int r)
+static void _process_status_code(dm_status_mirror_health_t health,
+				 uint32_t major, uint32_t minor,
+				 const char *dev_type, int *r)
 {
 	/*
 	 *    A => Alive - No failures
@@ -42,90 +42,60 @@ static int _process_status_code(const char status_code, const char *dev_name,
 	 *    R => Read - A read failure occurred, mirror data unaffected
 	 *    U => Unclassified failure (bug)
 	 */ 
-	if (status_code == 'F') {
-		log_error("%s device %s flush failed.", dev_type, dev_name);
-		r = ME_FAILURE;
-	} else if (status_code == 'S')
-		log_error("%s device %s sync failed.", dev_type, dev_name);
-	else if (status_code == 'R')
-		log_error("%s device %s read failed.", dev_type, dev_name);
-	else if (status_code != 'A') {
-		log_error("%s device %s has failed (%c).",
-			  dev_type, dev_name, status_code);
-		r = ME_FAILURE;
+	switch (health) {
+	case DM_STATUS_MIRROR_ALIVE:
+		return;
+	case DM_STATUS_MIRROR_FLUSH_FAILED:
+		log_error("%s device %u:%u flush failed.",
+			  dev_type, major, minor);
+		*r = ME_FAILURE;
+		break;
+	case DM_STATUS_MIRROR_SYNC_FAILED:
+		log_error("%s device %u:%u sync failed.",
+			  dev_type, major, minor);
+		break;
+	case DM_STATUS_MIRROR_READ_FAILED:
+		log_error("%s device %u:%u read failed.",
+			  dev_type, major, minor);
+		break;
+	default:
+		log_error("%s device %u:%u has failed (%c).",
+			  dev_type, major, minor, (char)health);
+		*r = ME_FAILURE;
+		break;
 	}
-
-	return r;
 }
 
-static int _get_mirror_event(char *params)
+static int _get_mirror_event(struct dso_state *state, char *params)
 {
-	int i, r = ME_INSYNC;
-	char **args = NULL;
-	char *dev_status_str;
-	char *log_status_str;
-	char *sync_str;
-	char *p = NULL;
-	int log_argc, num_devs;
+	int r = ME_INSYNC;
+	unsigned i;
+	struct dm_status_mirror *ms;
 
-	/*
-	 * dm core parms:	     0 409600 mirror
-	 * Mirror core parms:	     2 253:4 253:5 400/400
-	 * New-style failure params: 1 AA
-	 * New-style log params:     3 cluster 253:3 A
-	 *			 or  3 disk 253:3 A
-	 *			 or  1 core
-	 */
-
-	/* number of devices */
-	if (!dm_split_words(params, 1, 0, &p))
-		goto out_parse;
-
-	if (!(num_devs = atoi(p)) ||
-	    (num_devs > DEFAULT_MIRROR_MAX_IMAGES) || (num_devs < 0))
-		goto out_parse;
-	p += strlen(p) + 1;
-
-	/* devices names + "400/400" + "1 AA" + 1 or 3 log parms + NULL */
-	args = dm_malloc((num_devs + 7) * sizeof(char *));
-	if (!args || dm_split_words(p, num_devs + 7, 0, args) < num_devs + 5)
-		goto out_parse;
-
-	/* FIXME: Code differs from lib/mirror/mirrored.c */
-	dev_status_str = args[2 + num_devs];
-	log_argc = atoi(args[3 + num_devs]);
-	log_status_str = args[3 + num_devs + log_argc];
-	sync_str = args[num_devs];
+	if (!dm_get_status_mirror(state->mem, params, &ms))
+		goto_out;
 
 	/* Check for bad mirror devices */
-	for (i = 0; i < num_devs; i++)
-		r = _process_status_code(dev_status_str[i], args[i],
-			i ? "Secondary mirror" : "Primary mirror", r);
+	for (i = 0; i < ms->dev_count; ++i)
+		_process_status_code(ms->devs[i].health,
+				     ms->devs[i].major, ms->devs[i].minor,
+				     i ? "Secondary mirror" : "Primary mirror", &r);
 
 	/* Check for bad disk log device */
-	if (log_argc > 1)
-		r = _process_status_code(log_status_str[0],
-					 args[2 + num_devs + log_argc],
-					 "Log", r);
+	for (i = 0; i < ms->log_count; ++i)
+		_process_status_code(ms->logs[i].health,
+				     ms->logs[i].major, ms->logs[i].minor,
+				     "Log", &r);
 
-	if (r == ME_FAILURE)
-		goto out;
+	/* Ignore if not in-sync */
+	if ((r == ME_INSYNC) && (ms->insync_regions != ms->total_regions))
+		r = ME_IGNORE;
 
-	p = strstr(sync_str, "/");
-	if (p) {
-		p[0] = '\0';
-		if (strcmp(sync_str, p+1))
-			r = ME_IGNORE;
-		p[0] = '/';
-	} else
-		goto out_parse;
+	dm_pool_free(state->mem, ms);
 
-out:
-	dm_free(args);
 	return r;
 
-out_parse:
-	dm_free(args);
+out:
 	log_error("Unable to parse mirror status string.");
 
 	return ME_IGNORE;
@@ -172,7 +142,7 @@ void process_event(struct dm_task *dmt,
 			continue;
 		}
 
-		switch(_get_mirror_event(params)) {
+		switch(_get_mirror_event(state, params)) {
 		case ME_INSYNC:
 			/* FIXME: all we really know is that this
 			   _part_ of the device is in sync

daemons/dmeventd/plugins/raid/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/dmeventd/plugins/raid/dmeventd_raid.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "lib.h"

daemons/dmeventd/plugins/snapshot/Makefile.in

@@ -10,7 +10,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/dmeventd/plugins/snapshot/dmeventd_snapshot.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "lib.h"

daemons/dmeventd/plugins/thin/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/dmeventd/plugins/thin/dmeventd_thin.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "lib.h"	/* using here lvm log */

daemons/lvmdbusd/Makefile.in

@@ -0,0 +1,65 @@
+#
+# Copyright (C) 2016 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@
+
+lvmdbusdir = $(python3dir)/lvmdbusd
+
+LVMDBUS_SRCDIR_FILES = \
+	automatedproperties.py \
+	background.py \
+	cfg.py \
+	cmdhandler.py \
+	fetch.py \
+	__init__.py \
+	job.py \
+	loader.py \
+	lvmdb.py \
+	main.py \
+	lvm_shell_proxy.py \
+	lv.py \
+	manager.py \
+	objectmanager.py \
+	pv.py \
+	refresh.py \
+	request.py \
+	state.py \
+	udevwatch.py \
+	utils.py \
+	vg.py
+
+LVMDBUS_BUILDDIR_FILES = \
+	path.py
+
+LVMDBUSD = $(srcdir)/lvmdbusd
+
+include $(top_builddir)/make.tmpl
+
+.PHONY: install_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
+
+install: install_lvm2
+

daemons/lvmdbusd/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from .main import main

daemons/lvmdbusd/automatedproperties.py

@@ -0,0 +1,175 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import dbus
+from . import cfg
+from .utils import get_properties, add_properties, get_object_property_diff, \
+	log_debug
+from .state import State
+
+
+# noinspection PyPep8Naming,PyUnresolvedReferences
+class AutomatedProperties(dbus.service.Object):
+	"""
+	This class implements the needed interfaces for:
+	org.freedesktop.DBus.Properties
+
+	Other classes inherit from it to get the same behavior
+	"""
+
+	def __init__(self, object_path, search_method=None):
+		dbus.service.Object.__init__(self, cfg.bus, object_path)
+		self._ap_interface = []
+		self._ap_o_path = object_path
+		self._ap_search_method = search_method
+		self.state = None
+
+	def dbus_object_path(self):
+		return self._ap_o_path
+
+	def emit_data(self):
+		props = {}
+
+		for i in self.interface():
+			props[i] = self.GetAll(i)
+
+		return self._ap_o_path, props
+
+	def set_interface(self, interface):
+		"""
+		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.
+		:param interface:       An interface the object supports
+		:return:
+		"""
+		if interface not in self._ap_interface:
+			self._ap_interface.append(interface)
+
+	# noinspection PyUnusedLocal
+	def interface(self, all_interfaces=False):
+		if all_interfaces:
+			cpy = list(self._ap_interface)
+			cpy.extend(
+				["org.freedesktop.DBus.Introspectable",
+					"org.freedesktop.DBus.Properties"])
+			return cpy
+
+		return self._ap_interface
+
+	# Properties
+	# noinspection PyUnusedLocal
+	@dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE,
+							in_signature='ss', out_signature='v')
+	def Get(self, interface_name, property_name):
+		value = getattr(self, 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!
+		log_debug('Get (%s), type (%s), value(%s)' %
+					(property_name, str(type(value)), str(value)))
+		return value
+
+	@dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE,
+							in_signature='s', out_signature='a{sv}')
+	def GetAll(self, interface_name):
+		if interface_name in self.interface(True):
+			# Using introspection, lets build this dynamically
+			properties = get_properties(self)
+			if interface_name in properties:
+				return properties[interface_name][1]
+			return {}
+		raise dbus.exceptions.DBusException(
+			self._ap_interface,
+			'The object %s does not implement the %s interface'
+			% (self.__class__, interface_name))
+
+	@dbus.service.method(dbus_interface=dbus.PROPERTIES_IFACE,
+							in_signature='ssv')
+	def Set(self, interface_name, property_name, new_value):
+		setattr(self, property_name, new_value)
+		self.PropertiesChanged(interface_name,
+								{property_name: new_value}, [])
+
+	# As dbus-python does not support introspection for properties we will
+	# get the autogenerated xml and then add our wanted properties to it.
+	@dbus.service.method(dbus_interface=dbus.INTROSPECTABLE_IFACE,
+							out_signature='s')
+	def Introspect(self):
+		r = dbus.service.Object.Introspect(self, self._ap_o_path, cfg.bus)
+		# Look at the properties in the class
+		props = get_properties(self)
+
+		for int_f, v in props.items():
+			r = add_properties(r, int_f, v[0])
+
+		return r
+
+	@dbus.service.signal(dbus_interface=dbus.PROPERTIES_IFACE,
+							signature='sa{sv}as')
+	def PropertiesChanged(self, interface_name, changed_properties,
+							invalidated_properties):
+		log_debug(('SIGNAL: PropertiesChanged(%s, %s, %s, %s)' %
+					(str(self._ap_o_path), str(interface_name),
+					str(changed_properties), str(invalidated_properties))))
+
+	def refresh(self, search_key=None, object_state=None):
+		"""
+		Take the values (properties) of an object and update them with what
+		lvm currently has.  You can either fetch the new ones or supply the
+		new state to be updated with
+		:param search_key: The value to use to search for
+		:param object_state: Use this as the new object state
+		"""
+		num_changed = 0
+
+		# If we can't do a lookup, bail now, this happens if we blindly walk
+		# through all dbus objects as some don't have a search method, like
+		# 'Manager' object.
+		if not self._ap_search_method:
+			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:
+			new_state = self._ap_search_method([search])[0]
+			assert isinstance(new_state, State)
+
+		assert new_state
+
+		# When we refresh an object the object identifiers might have changed
+		# because LVM allows the user to change them (name & uuid), thus if
+		# they have changed we need to update the object manager so that
+		# look-ups will happen correctly
+		old_id = self.state.identifiers()
+		new_id = new_state.identifiers()
+		if old_id[0] != new_id[0] or old_id[1] != new_id[1]:
+			cfg.om.lookup_update(self, new_id[0], new_id[1])
+
+		# Grab the properties values, then replace the state of the object
+		# and retrieve the new values
+		# TODO: We need to add locking to prevent concurrent access to the
+		# properties so that a client is not accessing while we are
+		# replacing.
+		o_prop = get_properties(self)
+		self.state = new_state
+		n_prop = get_properties(self)
+
+		changed = get_object_property_diff(o_prop, n_prop)
+
+		if changed:
+			for int_f, v in changed.items():
+				self.PropertiesChanged(int_f, v, [])
+			num_changed += 1
+		return num_changed

daemons/lvmdbusd/background.py

@@ -0,0 +1,212 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import threading
+import subprocess
+from . import cfg
+import time
+from .cmdhandler import options_to_cli_args
+import dbus
+from .job import Job, JobState
+from .utils import pv_range_append, pv_dest_ranges, log_debug, log_error
+from .request import RequestEntry
+import traceback
+
+_rlock = threading.RLock()
+_thread_list = list()
+
+
+def pv_move_lv_cmd(move_options, lv_full_name,
+					pv_source, pv_source_range, pv_dest_range_list):
+	cmd = ['pvmove', '-i', '1']
+	cmd.extend(options_to_cli_args(move_options))
+
+	if lv_full_name:
+		cmd.extend(['-n', lv_full_name])
+
+	pv_range_append(cmd, pv_source, *pv_source_range)
+	pv_dest_ranges(cmd, pv_dest_range_list)
+
+	return cmd
+
+
+def lv_merge_cmd(merge_options, lv_full_name):
+	cmd = ['lvconvert', '--merge', '-i', '1']
+	cmd.extend(options_to_cli_args(merge_options))
+	cmd.append(lv_full_name)
+	return cmd
+
+
+def _create_background_dbus_job(job_state):
+	job_obj = Job(None, job_state)
+	cfg.om.register_object(job_obj)
+	return job_obj.dbus_object_path()
+
+
+def _move_merge(interface_name, cmd, time_out):
+	# Create job object to be used while running the command
+	rc = '/'
+	job_state = JobState(None)
+	add(cmd, job_state)
+
+	if time_out == -1:
+		# Waiting forever
+		done = job_state.Wait(time_out)
+		if not done:
+			ec, err_msg = job_state.GetError
+			raise dbus.exceptions.DBusException(
+				interface_name,
+				'Exit code %s, stderr = %s' % (str(ec), err_msg))
+	elif time_out == 0:
+		# Immediately create and return a job
+		rc = _create_background_dbus_job(job_state)
+	else:
+		# Willing to wait for a bit
+		done = job_state.Wait(time_out)
+		if not done:
+			rc = _create_background_dbus_job(job_state)
+
+	return rc
+
+
+def move(interface_name, lv_name, pv_src_obj, pv_source_range,
+			pv_dests_and_ranges, move_options, time_out):
+	"""
+	Common code for the pvmove handling.
+	:param interface_name:  What dbus interface we are providing for
+	:param lv_name:     Optional (None or name of LV to move)
+	:param pv_src_obj:  dbus object patch for source PV
+	:param pv_source_range: (0,0 to ignore, else start, end segments)
+	:param pv_dests_and_ranges: Array of PV object paths and start/end segs
+	:param move_options: Hash with optional arguments
+	:param time_out:
+	:return: Object path to job object
+	"""
+	pv_dests = []
+	pv_src = cfg.om.get_object_by_path(pv_src_obj)
+	if pv_src:
+
+		# Check to see if we are handling a move to a specific
+		# destination(s)
+		if len(pv_dests_and_ranges):
+			for pr in pv_dests_and_ranges:
+				pv_dbus_obj = cfg.om.get_object_by_path(pr[0])
+				if not pv_dbus_obj:
+					raise dbus.exceptions.DBusException(
+						interface_name,
+						'PV Destination (%s) not found' % pr[0])
+
+				pv_dests.append((pv_dbus_obj.lvm_id, pr[1], pr[2]))
+
+		# Generate the command line for this command, but don't
+		# execute it.
+		cmd = pv_move_lv_cmd(move_options,
+								lv_name,
+								pv_src.lvm_id,
+								pv_source_range,
+								pv_dests)
+
+		return _move_merge(interface_name, cmd, time_out)
+	else:
+		raise dbus.exceptions.DBusException(
+			interface_name, 'pv_src_obj (%s) not found' % pv_src_obj)
+
+
+def merge(interface_name, lv_uuid, lv_name, merge_options, time_out):
+	# Make sure we have a dbus object representing it
+	dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
+	if dbo:
+		cmd = lv_merge_cmd(merge_options, dbo.lvm_id)
+		return _move_merge(interface_name, cmd, time_out)
+	else:
+		raise dbus.exceptions.DBusException(
+			interface_name,
+			'LV with uuid %s and name %s not present!' % (lv_uuid, lv_name))
+
+
+def background_reaper():
+	while cfg.run.value != 0:
+		with _rlock:
+			num_threads = len(_thread_list) - 1
+			if num_threads >= 0:
+				for i in range(num_threads, -1, -1):
+					_thread_list[i].join(0)
+					if not _thread_list[i].is_alive():
+						_thread_list.pop(i)
+
+		time.sleep(3)
+
+
+def process_background_result(job_object, exit_code, error_msg):
+	cfg.load()
+	job_object.set_result(exit_code, error_msg)
+	return None
+
+
+# noinspection PyUnusedLocal
+def empty_cb(disregard):
+	pass
+
+
+def background_execute(command, background_job, skip_first_line=False):
+
+	# Wrap this whole operation in an exception handler, otherwise if we
+	# hit a code bug we will silently exit this thread without anyone being
+	# the wiser.
+	try:
+		process = subprocess.Popen(command, stdout=subprocess.PIPE,
+									stderr=subprocess.PIPE, close_fds=True)
+		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(':')
+					background_job.Percent = \
+						round(float(percentage.strip()[:-1]), 1)
+			except ValueError:
+				log_error("Trying to parse percentage which failed for %s" %
+					line_str)
+
+		out = process.communicate()
+
+		if process.returncode == 0:
+			background_job.Percent = 100
+
+		# Queue up the result so that it gets executed in same thread as others.
+		r = RequestEntry(
+			-1, process_background_result,
+			(background_job, process.returncode, out[1]),
+			empty_cb, empty_cb, False)
+		cfg.worker_q.put(r)
+	except Exception:
+		# In the unlikely event that we blew up, lets notify fill out the
+		# job object so that the client doesn't hang potentially forever!
+		st = traceback.format_exc()
+		error = "Exception in background thread: \n%s" % st
+		log_error(error)
+		r = RequestEntry(
+			-1, process_background_result,
+			(background_job, 1, error),
+			empty_cb, empty_cb, False)
+		cfg.worker_q.put(r)
+
+
+def add(command, reporting_job):
+	# Create the thread, get it running and then add it to the list
+	t = threading.Thread(
+		target=background_execute,
+		name="thread: " + ' '.join(command),
+		args=(command, reporting_job))
+	t.start()
+
+	with _rlock:
+		_thread_list.append(t)

daemons/lvmdbusd/cfg.py

@@ -0,0 +1,80 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import os
+import multiprocessing
+import queue
+import itertools
+try:
+	from . import path
+except SystemError:
+	import path
+
+LVM_CMD = os.getenv('LVM_BINARY', path.LVM_BINARY)
+
+# This is the global object manager
+om = None
+
+# This is the global bus connection
+bus = None
+
+# Shared state variable across all processes
+run = multiprocessing.Value('i', 1)
+
+# Debug
+DEBUG = True
+
+# Use lvm shell
+USE_SHELL = False
+
+# Lock used by pprint
+stdout_lock = multiprocessing.Lock()
+
+kick_q = multiprocessing.Queue()
+worker_q = queue.Queue()
+
+# Main event loop
+loop = None
+
+BASE_INTERFACE = 'com.redhat.lvmdbus1'
+PV_INTERFACE = BASE_INTERFACE + '.Pv'
+VG_INTERFACE = BASE_INTERFACE + '.Vg'
+LV_INTERFACE = BASE_INTERFACE + '.Lv'
+LV_COMMON_INTERFACE = BASE_INTERFACE + '.LvCommon'
+THIN_POOL_INTERFACE = BASE_INTERFACE + '.ThinPool'
+CACHE_POOL_INTERFACE = BASE_INTERFACE + '.CachePool'
+LV_CACHED = BASE_INTERFACE + '.CachedLv'
+SNAPSHOT_INTERFACE = BASE_INTERFACE + '.Snapshot'
+MANAGER_INTERFACE = BASE_INTERFACE + '.Manager'
+JOB_INTERFACE = BASE_INTERFACE + '.Job'
+
+BASE_OBJ_PATH = '/' + BASE_INTERFACE.replace('.', '/')
+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"
+CACHE_POOL_PATH = BASE_OBJ_PATH + "/CachePool"
+HIDDEN_LV_PATH = BASE_OBJ_PATH + "/HiddenLv"
+MANAGER_OBJ_PATH = BASE_OBJ_PATH + '/Manager'
+JOB_OBJ_PATH = BASE_OBJ_PATH + '/Job'
+
+# Counters for object path generation
+pv_id = itertools.count()
+vg_id = itertools.count()
+lv_id = itertools.count()
+thin_id = itertools.count()
+cache_pool_id = itertools.count()
+job_id = itertools.count()
+hidden_lv = itertools.count()
+
+# Used to prevent circular imports...
+load = None
+
+# Global cached state
+db = None

daemons/lvmdbusd/cmdhandler.py

@@ -0,0 +1,629 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from subprocess import Popen, PIPE
+import time
+import threading
+from itertools import chain
+
+try:
+	from . import cfg
+	from .utils import pv_dest_ranges, log_debug, log_error
+	from .lvm_shell_proxy import LVMShellProxy
+except SystemError:
+	import cfg
+	from utils import pv_dest_ranges, log_debug, log_error
+	from lvm_shell_proxy import LVMShellProxy
+
+SEP = '{|}'
+
+total_time = 0.0
+total_count = 0
+
+# We need to prevent different threads from using the same lvm shell
+# at the same time.
+cmd_lock = threading.Lock()
+
+# The actual method which gets called to invoke the lvm command, can vary
+# from forking a new process to using lvm shell
+_t_call = None
+
+
+def _debug_c(cmd, exit_code, out):
+	log_error('CMD= %s' % ' '.join(cmd))
+	log_error(("EC= %d" % exit_code))
+	log_error(("STDOUT=\n %s\n" % out[0]))
+	log_error(("STDERR=\n %s\n" % out[1]))
+
+
+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
+	"""
+	# 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)
+
+	process = Popen(command, stdout=PIPE, stderr=PIPE, close_fds=True)
+	out = process.communicate()
+
+	stdout_text = bytes(out[0]).decode("utf-8")
+	stderr_text = bytes(out[1]).decode("utf-8")
+
+	if debug or process.returncode != 0:
+		_debug_c(command, process.returncode, (stdout_text, stderr_text))
+
+	if process.returncode == 0:
+		if cfg.DEBUG and out[1] and len(out[1]):
+			log_error('WARNING: lvm is out-putting text to STDERR on success!')
+			_debug_c(command, process.returncode, (stdout_text, stderr_text))
+
+	return process.returncode, stdout_text, stderr_text
+
+
+def _shell_cfg():
+	global _t_call
+	log_debug('Using lvm shell!')
+	lvm_shell = LVMShellProxy()
+	_t_call = lvm_shell.call_lvm
+
+
+if cfg.USE_SHELL:
+	_shell_cfg()
+else:
+	_t_call = call_lvm
+
+
+def set_execution(shell):
+	global _t_call
+	with cmd_lock:
+		_t_call = None
+		if shell:
+			log_debug('Using lvm shell!')
+			lvm_shell = LVMShellProxy()
+			_t_call = lvm_shell.call_lvm
+		else:
+			_t_call = call_lvm
+
+
+def time_wrapper(command, debug=False):
+	global total_time
+	global total_count
+
+	with cmd_lock:
+		start = time.time()
+		results = _t_call(command, debug)
+		total_time += (time.time() - start)
+		total_count += 1
+
+	return results
+
+
+call = time_wrapper
+
+
+# Default cmd
+# Place default arguments for every command here.
+def _dc(cmd, args):
+	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()):
+		if k.startswith("-"):
+			rc.append(k)
+		else:
+			rc.append("--%s" % k)
+		if v != "":
+			rc.append(str(v))
+	return rc
+
+
+def pv_remove(device, remove_options):
+	cmd = ['pvremove']
+	cmd.extend(options_to_cli_args(remove_options))
+	cmd.append(device)
+	return call(cmd)
+
+
+def _tag(operation, what, add, rm, tag_options):
+	cmd = [operation]
+	cmd.extend(options_to_cli_args(tag_options))
+
+	if isinstance(what, list):
+		cmd.extend(what)
+	else:
+		cmd.append(what)
+
+	if add:
+		cmd.extend(list(chain.from_iterable(('--addtag', x) for x in add)))
+	if rm:
+		cmd.extend(list(chain.from_iterable(('--deltag', x) for x in rm)))
+
+	return call(cmd, False)
+
+
+def pv_tag(pv_devices, add, rm, tag_options):
+	return _tag('pvchange', pv_devices, add, rm, tag_options)
+
+
+def vg_tag(vg_name, add, rm, tag_options):
+	return _tag('vgchange', vg_name, add, rm, tag_options)
+
+
+def lv_tag(lv_name, add, rm, tag_options):
+	return _tag('lvchange', lv_name, add, rm, tag_options)
+
+
+def vg_rename(vg, new_name, rename_options):
+	cmd = ['vgrename']
+	cmd.extend(options_to_cli_args(rename_options))
+	cmd.extend([vg, new_name])
+	return call(cmd)
+
+
+def vg_remove(vg_name, remove_options):
+	cmd = ['vgremove']
+	cmd.extend(options_to_cli_args(remove_options))
+	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', str(size_bytes) + 'B'])
+	cmd.extend(['--name', name, vg_name])
+	pv_dest_ranges(cmd, pv_dests)
+	return call(cmd)
+
+
+def vg_lv_snapshot(vg_name, snapshot_options, name, size_bytes):
+	cmd = ['lvcreate']
+	cmd.extend(options_to_cli_args(snapshot_options))
+	cmd.extend(["-s"])
+
+	if size_bytes != 0:
+		cmd.extend(['--size', str(size_bytes) + 'B'])
+
+	cmd.extend(['--name', name, vg_name])
+	return call(cmd)
+
+
+def vg_lv_create_linear(vg_name, create_options, name, size_bytes, thin_pool):
+	cmd = ['lvcreate']
+	cmd.extend(options_to_cli_args(create_options))
+
+	if not thin_pool:
+		cmd.extend(['--size', str(size_bytes) + 'B'])
+	else:
+		cmd.extend(['--thin', '--size', str(size_bytes) + 'B'])
+	cmd.extend(['--name', name, vg_name])
+	return call(cmd)
+
+
+def vg_lv_create_striped(vg_name, create_options, name, size_bytes,
+							num_stripes, stripe_size_kb, thin_pool):
+	cmd = ['lvcreate']
+	cmd.extend(options_to_cli_args(create_options))
+
+	if not thin_pool:
+		cmd.extend(['--size', str(size_bytes) + 'B'])
+	else:
+		cmd.extend(['--thin', '--size', str(size_bytes) + 'B'])
+
+	cmd.extend(['--stripes', str(num_stripes)])
+
+	if stripe_size_kb != 0:
+		cmd.extend(['--stripesize', str(stripe_size_kb)])
+
+	cmd.extend(['--name', name, vg_name])
+	return call(cmd)
+
+
+def _vg_lv_create_raid(vg_name, create_options, name, raid_type, size_bytes,
+						num_stripes, stripe_size_kb):
+	cmd = ['lvcreate']
+
+	cmd.extend(options_to_cli_args(create_options))
+
+	cmd.extend(['--type', raid_type])
+	cmd.extend(['--size', str(size_bytes) + 'B'])
+
+	if num_stripes != 0:
+		cmd.extend(['--stripes', str(num_stripes)])
+
+	if stripe_size_kb != 0:
+		cmd.extend(['--stripesize', str(stripe_size_kb)])
+
+	cmd.extend(['--name', name, vg_name])
+	return call(cmd)
+
+
+def vg_lv_create_raid(vg_name, create_options, name, raid_type, size_bytes,
+						num_stripes, stripe_size_kb):
+	cmd = ['lvcreate']
+	cmd.extend(options_to_cli_args(create_options))
+
+	return _vg_lv_create_raid(vg_name, create_options, name, raid_type,
+								size_bytes, num_stripes, stripe_size_kb)
+
+
+def vg_lv_create_mirror(vg_name, create_options, name, size_bytes, num_copies):
+	cmd = ['lvcreate']
+	cmd.extend(options_to_cli_args(create_options))
+
+	cmd.extend(['--type', 'mirror'])
+	cmd.extend(['--mirrors', str(num_copies)])
+	cmd.extend(['--size', str(size_bytes) + 'B'])
+	cmd.extend(['--name', name, vg_name])
+	return call(cmd)
+
+
+def vg_create_cache_pool(md_full_name, data_full_name, create_options):
+	cmd = ['lvconvert']
+	cmd.extend(options_to_cli_args(create_options))
+	cmd.extend(['--type', 'cache-pool', '--force', '-y',
+				'--poolmetadata', md_full_name, data_full_name])
+	return call(cmd)
+
+
+def vg_create_thin_pool(md_full_name, data_full_name, create_options):
+	cmd = ['lvconvert']
+	cmd.extend(options_to_cli_args(create_options))
+	cmd.extend(['--type', 'thin-pool', '--force', '-y',
+				'--poolmetadata', md_full_name, data_full_name])
+	return call(cmd)
+
+
+def lv_remove(lv_path, remove_options):
+	cmd = ['lvremove']
+	cmd.extend(options_to_cli_args(remove_options))
+	cmd.extend(['-f', lv_path])
+	return call(cmd)
+
+
+def lv_rename(lv_path, new_name, rename_options):
+	cmd = ['lvrename']
+	cmd.extend(options_to_cli_args(rename_options))
+	cmd.extend([lv_path, new_name])
+	return call(cmd)
+
+
+def lv_resize(lv_full_name, size_change, pv_dests,
+				resize_options):
+	cmd = ['lvresize', '--force']
+
+	cmd.extend(options_to_cli_args(resize_options))
+
+	if size_change < 0:
+		cmd.append("-L-%dB" % (-size_change))
+	else:
+		cmd.append("-L+%dB" % (size_change))
+
+	cmd.append(lv_full_name)
+	pv_dest_ranges(cmd, pv_dests)
+	return call(cmd)
+
+
+def lv_lv_create(lv_full_name, create_options, name, size_bytes):
+	cmd = ['lvcreate']
+	cmd.extend(options_to_cli_args(create_options))
+	cmd.extend(['--virtualsize', str(size_bytes) + 'B', '-T'])
+	cmd.extend(['--name', name, lv_full_name])
+	return call(cmd)
+
+
+def lv_cache_lv(cache_pool_full_name, lv_full_name, cache_options):
+	# lvconvert --type cache --cachepool VG/CachePoolLV VG/OriginLV
+	cmd = ['lvconvert']
+	cmd.extend(options_to_cli_args(cache_options))
+	cmd.extend(['--type', 'cache', '--cachepool',
+				cache_pool_full_name, lv_full_name])
+	return call(cmd)
+
+
+def lv_detach_cache(lv_full_name, detach_options, destroy_cache):
+	cmd = ['lvconvert']
+	if destroy_cache:
+		option = '--uncache'
+	else:
+		# Currently fairly dangerous
+		# see: https://bugzilla.redhat.com/show_bug.cgi?id=1248972
+		option = '--splitcache'
+	cmd.extend(options_to_cli_args(detach_options))
+	# needed to prevent interactive questions
+	cmd.extend(["--yes", "--force"])
+	cmd.extend([option, lv_full_name])
+	return call(cmd)
+
+
+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', 'pv_seg_start', 'pvseg_size', 'segtype']
+
+	# 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):
+	cmd = ['pvresize']
+
+	cmd.extend(options_to_cli_args(create_options))
+
+	if size_bytes != 0:
+		cmd.extend(['--setphysicalvolumesize', str(size_bytes) + 'B'])
+
+	cmd.extend([device])
+	return call(cmd)
+
+
+def pv_create(create_options, devices):
+	cmd = ['pvcreate', '-ff']
+	cmd.extend(options_to_cli_args(create_options))
+	cmd.extend(devices)
+	return call(cmd)
+
+
+def pv_allocatable(device, yes, allocation_options):
+	yn = 'n'
+
+	if yes:
+		yn = 'y'
+
+	cmd = ['pvchange']
+	cmd.extend(options_to_cli_args(allocation_options))
+	cmd.extend(['-x', yn, device])
+	return call(cmd)
+
+
+def pv_scan(activate, cache, device_paths, major_minors, scan_options):
+	cmd = ['pvscan']
+	cmd.extend(options_to_cli_args(scan_options))
+
+	if activate:
+		cmd.extend(['--activate', "ay"])
+
+	if cache:
+		cmd.append('--cache')
+
+		if len(device_paths) > 0:
+			for d in device_paths:
+				cmd.append(d)
+
+		if len(major_minors) > 0:
+			for mm in major_minors:
+				cmd.append("%s:%s" % (mm))
+
+	return call(cmd)
+
+
+def vg_create(create_options, pv_devices, name):
+	cmd = ['vgcreate']
+	cmd.extend(options_to_cli_args(create_options))
+	cmd.append(name)
+	cmd.extend(pv_devices)
+	return call(cmd)
+
+
+def vg_change(change_options, name):
+	cmd = ['vgchange']
+	cmd.extend(options_to_cli_args(change_options))
+	cmd.append(name)
+	return call(cmd)
+
+
+def vg_reduce(vg_name, missing, pv_devices, reduce_options):
+	cmd = ['vgreduce']
+	cmd.extend(options_to_cli_args(reduce_options))
+
+	if len(pv_devices) == 0:
+		cmd.append('--all')
+	if missing:
+		cmd.append('--removemissing')
+
+	cmd.append(vg_name)
+	cmd.extend(pv_devices)
+	return call(cmd)
+
+
+def vg_extend(vg_name, extend_devices, extend_options):
+	cmd = ['vgextend']
+	cmd.extend(options_to_cli_args(extend_options))
+	cmd.append(vg_name)
+	cmd.extend(extend_devices)
+	return call(cmd)
+
+
+def _vg_value_set(name, arguments, options):
+	cmd = ['vgchange']
+	cmd.extend(options_to_cli_args(options))
+	cmd.append(name)
+	cmd.extend(arguments)
+	return call(cmd)
+
+
+def vg_allocation_policy(vg_name, policy, policy_options):
+	return _vg_value_set(vg_name, ['--alloc', policy], policy_options)
+
+
+def vg_max_pv(vg_name, number, max_options):
+	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(number)], max_options)
+
+
+def vg_uuid_gen(vg_name, ignore, options):
+	assert ignore is None
+	return _vg_value_set(vg_name, ['--uuid'], options)
+
+
+def activate_deactivate(op, name, activate, control_flags, options):
+	cmd = [op]
+	cmd.extend(options_to_cli_args(options))
+
+	op = '-a'
+
+	if control_flags:
+		# Autoactivation
+		if (1 << 0) & control_flags:
+			op += 'a'
+		# Exclusive locking (Cluster)
+		if (1 << 1) & control_flags:
+			op += 'e'
+
+		# Local node activation
+		if (1 << 2) & control_flags:
+			op += 'l'
+
+		# Activation modes
+		if (1 << 3) & control_flags:
+			cmd.extend(['--activationmode', 'complete'])
+		elif (1 << 4) & control_flags:
+			cmd.extend(['--activationmode', 'partial'])
+
+		# Ignore activation skip
+		if (1 << 5) & control_flags:
+			cmd.append('--ignoreactivationskip')
+
+	if activate:
+		op += 'y'
+	else:
+		op += 'n'
+
+	cmd.append(op)
+	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']
+
+	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__':
+	pv_data = pv_retrieve_with_segs()
+
+	for p in pv_data:
+		log_debug(str(p))

daemons/lvmdbusd/fetch.py

@@ -0,0 +1,30 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from .pv import load_pvs
+from .vg import load_vgs
+from .lv import load_lvs
+from . import cfg
+
+
+def load(refresh=True, emit_signal=True, cache_refresh=True, log=True):
+	num_total_changes = 0
+
+	# Go through and load all the PVs, VGs and LVs
+	if cache_refresh:
+		cfg.db.refresh(log)
+
+	num_total_changes += load_pvs(refresh=refresh, emit_signal=emit_signal,
+									cache_refresh=False)[1]
+	num_total_changes += load_vgs(refresh=refresh, emit_signal=emit_signal,
+									cache_refresh=False)[1]
+	num_total_changes += load_lvs(refresh=refresh, emit_signal=emit_signal,
+									cache_refresh=False)[1]
+
+	return num_total_changes

daemons/lvmdbusd/job.py

@@ -0,0 +1,170 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from .automatedproperties import AutomatedProperties
+from .utils import job_obj_path_generate
+from . import cfg
+from .cfg import JOB_INTERFACE
+import dbus
+import threading
+
+
+# noinspection PyPep8Naming
+class JobState(object):
+	def __init__(self, request):
+		self.rlock = threading.RLock()
+
+		self._percent = 0
+		self._complete = False
+		self._request = request
+		self._cond = threading.Condition(self.rlock)
+		self._ec = 0
+		self._stderr = ''
+
+		# 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
+			self._percent = 1
+
+	@property
+	def Percent(self):
+		with self.rlock:
+			return self._percent
+
+	@Percent.setter
+	def Percent(self, value):
+		with self.rlock:
+			self._percent = value
+
+	@property
+	def Complete(self):
+		with self.rlock:
+			if self._request:
+				self._complete = self._request.is_done()
+				if self._complete:
+					self._percent = 100
+
+			return self._complete
+
+	@Complete.setter
+	def Complete(self, value):
+		with self.rlock:
+			self._complete = value
+			self._cond.notify_all()
+
+	@property
+	def GetError(self):
+		with self.rlock:
+			if self.Complete:
+				if self._request:
+					(rc, error) = self._request.get_errors()
+					return (rc, str(error))
+				else:
+					return (self._ec, self._stderr)
+			else:
+				return (-1, 'Job is not complete!')
+
+	def set_result(self, ec, msg):
+		with self.rlock:
+			self.Complete = True
+			self._ec = ec
+			self._stderr = msg
+
+	def dtor(self):
+		with self.rlock:
+			self._request = None
+
+	def Wait(self, timeout):
+		try:
+			with self._cond:
+				# Check to see if we are done, before we wait
+				if not self.Complete:
+					if timeout != -1:
+						self._cond.wait(timeout)
+					else:
+						self._cond.wait()
+				return self.Complete
+		except RuntimeError:
+			return False
+
+	@property
+	def Result(self):
+		with self.rlock:
+			if self._request:
+				return self._request.result()
+			return '/'
+
+
+# noinspection PyPep8Naming
+class Job(AutomatedProperties):
+	_Percent_meta = ('y', JOB_INTERFACE)
+	_Complete_meta = ('b', JOB_INTERFACE)
+	_Result_meta = ('o', JOB_INTERFACE)
+	_GetError_meta = ('(is)', JOB_INTERFACE)
+
+	def __init__(self, request, job_state=None):
+		super(Job, self).__init__(job_obj_path_generate())
+		self.set_interface(JOB_INTERFACE)
+
+		if job_state:
+			self.state = job_state
+		else:
+			self.state = JobState(request)
+
+	@property
+	def Percent(self):
+		return self.state.Percent
+
+	@Percent.setter
+	def Percent(self, value):
+		self.state.Percent = value
+
+	@property
+	def Complete(self):
+		return self.state.Complete
+
+	@Complete.setter
+	def Complete(self, value):
+		self.state.Complete = value
+
+	@property
+	def GetError(self):
+		return self.state.GetError
+
+	def set_result(self, ec, msg):
+		self.state.set_result(ec, msg)
+
+	@dbus.service.method(dbus_interface=JOB_INTERFACE)
+	def Remove(self):
+		if self.state.Complete:
+			cfg.om.remove_object(self, True)
+			self.state.dtor()
+		else:
+			raise dbus.exceptions.DBusException(
+				JOB_INTERFACE, 'Job is not complete!')
+
+	@dbus.service.method(dbus_interface=JOB_INTERFACE,
+							in_signature='i',
+							out_signature='b')
+	def Wait(self, timeout):
+		return self.state.Wait(timeout)
+
+	@property
+	def Result(self):
+		return self.state.Result
+
+	@property
+	def lvm_id(self):
+		return str(id(self))
+
+	@property
+	def Uuid(self):
+		import uuid
+		return uuid.uuid1()

daemons/lvmdbusd/loader.py

@@ -0,0 +1,85 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from . import cfg
+
+
+def _compare_construction(o_state, new_state):
+	# We need to check to see if the objects would get constructed
+	# the same
+	existing_ctor, existing_path = o_state.creation_signature()
+	new_ctor, new_path = new_state.creation_signature()
+
+	# print("%s == %s and %s == %s" % (str(existing_ctor), str(new_ctor),
+	#      str(existing_path), str(new_path)))
+
+	return ((existing_ctor == new_ctor) and (existing_path == new_path))
+
+
+def common(retrieve, o_type, search_keys,
+			object_path, refresh, emit_signal, cache_refresh):
+	num_changes = 0
+	existing_paths = []
+	rc = []
+
+	if search_keys:
+		assert isinstance(search_keys, list)
+
+	if cache_refresh:
+		cfg.db.refresh()
+
+	objects = retrieve(search_keys, cache_refresh=False)
+
+	# If we are doing a refresh we need to know what we have in memory, what's
+	# in lvm and add those that are new and remove those that are gone!
+	if refresh:
+		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
+		# and it's already present
+		return_object = True
+
+		if refresh:
+			# We are refreshing all the PVs from LVM, if this one exists
+			# we need to refresh our state.
+			dbus_object = cfg.om.get_object_by_uuid_lvm_id(*o.identifiers())
+
+			if dbus_object:
+				del existing_paths[dbus_object.dbus_object_path()]
+
+				# If the old object state and new object state wouldn't be
+				# created with the same path and same object constructor we
+				# need to remove the old object and construct the new one
+				# instead!
+				if not _compare_construction(dbus_object.state, o):
+					# Remove existing and construct new one
+					cfg.om.remove_object(dbus_object, emit_signal)
+					dbus_object = o.create_dbus_object(None)
+					cfg.om.register_object(dbus_object, emit_signal)
+					num_changes += 1
+				else:
+					num_changes += dbus_object.refresh(object_state=o)
+				return_object = False
+
+		if return_object:
+			dbus_object = o.create_dbus_object(object_path)
+			cfg.om.register_object(dbus_object, emit_signal)
+			rc.append(dbus_object)
+
+		object_path = None
+
+	if refresh:
+		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

daemons/lvmdbusd/lv.py

@@ -0,0 +1,833 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from .automatedproperties import AutomatedProperties
+
+from . import utils
+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
+from .request import RequestEntry
+from .utils import n, n32
+from .loader import common
+from .state import State
+from . import background
+from .utils import round_size
+
+
+# noinspection PyUnusedLocal
+def lvs_state_retrieve(selection, cache_refresh=True):
+	rc = []
+
+	if cache_refresh:
+		cfg.db.refresh()
+
+	for l in cfg.db.fetch_lvs(selection):
+		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']))
+	return rc
+
+
+def load_lvs(lv_name=None, object_path=None, refresh=False, emit_signal=False,
+				cache_refresh=True):
+	# noinspection PyUnresolvedReferences
+	return common(
+		lvs_state_retrieve,
+		(LvCommon, Lv, LvThinPool, LvSnapShot),
+		lv_name, object_path, refresh, emit_signal, cache_refresh)
+
+
+# noinspection PyPep8Naming,PyUnresolvedReferences,PyUnusedLocal
+class LvState(State):
+	@staticmethod
+	def _pv_devices(uuid):
+		rc = []
+		for pv in sorted(cfg.db.lv_contained_pv(uuid)):
+			(pv_uuid, pv_name, pv_segs) = pv
+			pv_obj = cfg.om.get_object_path_by_lvm_id(
+				pv_uuid, pv_name, gen_new=False)
+			rc.append((pv_obj, pv_segs))
+
+		return dbus.Array(rc, signature="(oa(tts))")
+
+	def vg_name_lookup(self):
+		return cfg.om.get_object_by_path(self.Vg).Name
+
+	@property
+	def lvm_id(self):
+		return "%s/%s" % (self.vg_name_lookup(), self.Name)
+
+	def identifiers(self):
+		return (self.Uuid, self.lvm_id)
+
+	def _get_hidden_lv(self):
+		rc = dbus.Array([], "o")
+
+		vg_name = self.vg_name_lookup()
+
+		for l in cfg.db.hidden_lvs(self.Uuid):
+			full_name = "%s/%s" % (vg_name, l[1])
+			op = cfg.om.get_object_path_by_lvm_id(
+				l[0], full_name, gen_new=False)
+			assert op
+			rc.append(op)
+		return rc
+
+	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):
+		utils.init_class_from_arguments(self)
+
+		# The segtypes is possibly an array with potentially dupes or a single
+		# value
+		self._segs = dbus.Array([], signature='s')
+		if not isinstance(segtypes, list):
+			self._segs.append(segtypes)
+		else:
+			self._segs.extend(set(segtypes))
+
+		self.Vg = cfg.om.get_object_path_by_lvm_id(
+			vg_uuid, vg_name, vg_obj_path_generate)
+
+		self.Devices = LvState._pv_devices(self.Uuid)
+
+		if PoolLv:
+			gen = utils.lv_object_path_method(Name, (Attr, layout, role))
+
+			self.PoolLv = cfg.om.get_object_path_by_lvm_id(
+				pool_lv_uuid, '%s/%s' % (vg_name, PoolLv),
+				gen)
+		else:
+			self.PoolLv = '/'
+
+		if OriginLv:
+			self.OriginLv = \
+				cfg.om.get_object_path_by_lvm_id(
+					origin_uuid, '%s/%s' % (vg_name, OriginLv),
+					vg_obj_path_generate)
+		else:
+			self.OriginLv = '/'
+
+		self.HiddenLvs = self._get_hidden_lv()
+
+	@property
+	def SegType(self):
+		return self._segs
+
+	def _object_path_create(self):
+		return utils.lv_object_path_method(
+			self.Name, (self.Attr, self.layout, self.role))
+
+	def _object_type_create(self):
+		if self.Name[0] == '[':
+			return LvCommon
+		if self.Attr[0] == 't':
+			return LvThinPool
+		elif self.Attr[0] == 'C':
+			if 'pool' in self.layout:
+				return LvCachePool
+			else:
+				return LvCacheLv
+		elif self.OriginLv != '/':
+			return LvSnapShot
+		else:
+			return Lv
+
+	def create_dbus_object(self, path):
+		if not path:
+			path = cfg.om.get_object_path_by_lvm_id(
+				self.Uuid, self.lvm_id, self._object_path_create())
+
+		obj_ctor = self._object_type_create()
+		return obj_ctor(path, self)
+
+	def creation_signature(self):
+		klass = self._object_type_create()
+		path_method = self._object_path_create()
+		return (klass, path_method)
+
+
+# noinspection PyPep8Naming
+@utils.dbus_property(LV_COMMON_INTERFACE, 'Uuid', 's')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'Name', 's')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'Path', 's')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'SizeBytes', 't')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'DataPercent', 'u')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'SegType', 'as')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'Vg', 'o')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'OriginLv', 'o')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'PoolLv', 'o')
+@utils.dbus_property(LV_COMMON_INTERFACE, 'Devices', "a(oa(tts))")
+@utils.dbus_property(LV_COMMON_INTERFACE, 'HiddenLvs', "ao")
+class LvCommon(AutomatedProperties):
+	_Tags_meta = ("as", LV_COMMON_INTERFACE)
+	_IsThinVolume_meta = ("b", LV_COMMON_INTERFACE)
+	_IsThinPool_meta = ("b", LV_COMMON_INTERFACE)
+	_Active_meta = ("b", LV_COMMON_INTERFACE)
+	_VolumeType_meta = ("(ss)", LV_COMMON_INTERFACE)
+	_Permissions_meta = ("(ss)", LV_COMMON_INTERFACE)
+	_AllocationPolicy_meta = ("(ss)", LV_COMMON_INTERFACE)
+	_State_meta = ("(ss)", LV_COMMON_INTERFACE)
+	_TargetType_meta = ("(ss)", LV_COMMON_INTERFACE)
+	_Health_meta = ("(ss)", LV_COMMON_INTERFACE)
+	_FixedMinor_meta = ('b', LV_COMMON_INTERFACE)
+	_ZeroBlocks_meta = ('b', LV_COMMON_INTERFACE)
+	_SkipActivation_meta = ('b', LV_COMMON_INTERFACE)
+
+	# noinspection PyUnusedLocal,PyPep8Naming
+	def __init__(self, object_path, object_state):
+		super(LvCommon, self).__init__(object_path, lvs_state_retrieve)
+		self.set_interface(LV_COMMON_INTERFACE)
+		self.state = object_state
+
+	@property
+	def VolumeType(self):
+		type_map = {'C': 'Cache', 'm': 'mirrored',
+					'M': 'Mirrored without initial sync', 'o': 'origin',
+					'O': 'Origin with merging snapshot', 'r': 'raid',
+					'R': 'Raid without initial sync', 's': 'snapshot',
+					'S': 'merging Snapshot', 'p': 'pvmove',
+					'v': 'virtual', 'i': 'mirror  or  raid  image',
+					'I': 'mirror or raid Image out-of-sync',
+					'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',
+					'-': 'Unspecified'}
+		return (self.state.Attr[0], type_map[self.state.Attr[0]])
+
+	@property
+	def Permissions(self):
+		type_map = {'w': 'writable', 'r': 'read-only',
+					'R': 'Read-only activation of non-read-only volume',
+					'-': 'Unspecified'}
+		return (self.state.Attr[1], type_map[self.state.Attr[1]])
+
+	@property
+	def AllocationPolicy(self):
+		type_map = {'a': 'anywhere', 'A': 'anywhere locked',
+					'c': 'contiguous', 'C': 'contiguous locked',
+					'i': 'inherited', 'I': 'inherited locked',
+					'l': 'cling', 'L': 'cling locked',
+					'n': 'normal', 'N': 'normal locked', '-': 'Unspecified'}
+		return (self.state.Attr[2], type_map[self.state.Attr[2]])
+
+	@property
+	def FixedMinor(self):
+		return self.state.Attr[3] == 'm'
+
+	@property
+	def State(self):
+		type_map = {'a': 'active', 's': 'suspended', 'I': 'Invalid snapshot',
+					'S': 'invalid Suspended snapshot',
+					'm': 'snapshot merge failed',
+					'M': 'suspended snapshot (M)erge failed',
+					'd': 'mapped device present without  tables',
+					'i': 'mapped device present with inactive table',
+					'X': 'unknown', '-': 'Unspecified'}
+		return (self.state.Attr[4], type_map[self.state.Attr[4]])
+
+	@property
+	def TargetType(self):
+		type_map = {'C': 'Cache', 'm': 'mirror', 'r': 'raid',
+					's': 'snapshot', 't': 'thin', 'u': 'unknown',
+					'v': 'virtual', '-': 'Unspecified'}
+		return (self.state.Attr[6], type_map[self.state.Attr[6]])
+
+	@property
+	def ZeroBlocks(self):
+		return self.state.Attr[7] == 'z'
+
+	@property
+	def Health(self):
+		type_map = {'p': 'partial', 'r': 'refresh',
+					'm': 'mismatches', 'w': 'writemostly',
+					'X': 'X unknown', '-': 'Unspecified'}
+		return (self.state.Attr[8], type_map[self.state.Attr[8]])
+
+	@property
+	def SkipActivation(self):
+		return self.state.Attr[9] == 'k'
+
+	def vg_name_lookup(self):
+		return self.state.vg_name_lookup()
+
+	def lv_full_name(self):
+		return "%s/%s" % (self.state.vg_name_lookup(), self.state.Name)
+
+	@property
+	def identifiers(self):
+		return self.state.identifiers
+
+	@property
+	def Tags(self):
+		return utils.parse_tags(self.state.Tags)
+
+	@property
+	def lvm_id(self):
+		return self.state.lvm_id
+
+	@property
+	def IsThinVolume(self):
+		return self.state.Attr[0] == 'V'
+
+	@property
+	def IsThinPool(self):
+		return self.state.Attr[0] == 't'
+
+	@property
+	def Active(self):
+		return self.state.active == "active"
+
+	@dbus.service.method(
+		dbus_interface=LV_COMMON_INTERFACE,
+		in_signature='ia{sv}',
+		out_signature='o')
+	def _Future(self, tmo, open_options):
+		raise dbus.exceptions.DBusException(LV_COMMON_INTERFACE, 'Do not use!')
+
+
+# noinspection PyPep8Naming
+class Lv(LvCommon):
+	# noinspection PyUnusedLocal,PyPep8Naming
+	def __init__(self, object_path, object_state):
+		super(Lv, self).__init__(object_path, object_state)
+		self.set_interface(LV_INTERFACE)
+		self.state = object_state
+
+	@staticmethod
+	def _remove(lv_uuid, lv_name, remove_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
+
+		if dbo:
+			# Remove the LV, if successful then remove from the model
+			rc, out, err = cmdhandler.lv_remove(lv_name, remove_options)
+
+			if rc == 0:
+				cfg.om.remove_object(dbo, True)
+				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))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(lv_uuid, lv_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='ia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Remove(self, tmo, remove_options, cb, cbe):
+		r = RequestEntry(
+			tmo, Lv._remove,
+			(self.Uuid, self.lvm_id, remove_options),
+			cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _rename(lv_uuid, lv_name, new_name, rename_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
+
+		if dbo:
+			# Rename the logical volume
+			rc, out, err = cmdhandler.lv_rename(lv_name, new_name,
+												rename_options)
+			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))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(lv_uuid, lv_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='sia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Rename(self, name, tmo, rename_options, cb, cbe):
+		utils.validate_lv_name(LV_INTERFACE, self.vg_name_lookup(), name)
+
+		r = RequestEntry(
+			tmo, Lv._rename,
+			(self.Uuid, self.lvm_id, name, rename_options),
+			cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='o(tt)a(ott)ia{sv}',
+		out_signature='o')
+	def Move(self, pv_src_obj, pv_source_range,
+				pv_dests_and_ranges,
+				tmo, move_options):
+		return background.move(
+			LV_INTERFACE, self.lvm_id, pv_src_obj,
+			pv_source_range, pv_dests_and_ranges,
+			move_options, tmo)
+
+	@staticmethod
+	def _snap_shot(lv_uuid, lv_name, name, optional_size,
+			snapshot_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
+
+		if dbo:
+			# If you specify a size you get a 'thick' snapshot even if
+			# it is a thin lv
+			if not dbo.IsThinVolume:
+				if optional_size == 0:
+					# TODO: Should we pick a sane default or force user to
+					# make a decision?
+					space = dbo.SizeBytes / 80
+					remainder = space % 512
+					optional_size = space + 512 - remainder
+
+			rc, out, err = cmdhandler.vg_lv_snapshot(
+				lv_name, snapshot_options, name, optional_size)
+			if rc == 0:
+				return_path = '/'
+				full_name = "%s/%s" % (dbo.vg_name_lookup(), name)
+				lvs = load_lvs([full_name], emit_signal=True)[0]
+				for l in lvs:
+					return_path = l.dbus_object_path()
+
+				# Refresh self and all included PVs
+				cfg.load(cache_refresh=False)
+				return return_path
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(lv_uuid, lv_name))
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='stia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def Snapshot(self, name, optional_size, tmo,
+			snapshot_options, cb, cbe):
+
+		utils.validate_lv_name(LV_INTERFACE, self.vg_name_lookup(), name)
+
+		r = RequestEntry(
+			tmo, Lv._snap_shot,
+			(self.Uuid, self.lvm_id, name,
+			optional_size, snapshot_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _resize(lv_uuid, lv_name, new_size_bytes, pv_dests_and_ranges,
+				resize_options):
+		# Make sure we have a dbus object representing it
+		pv_dests = []
+		dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
+
+		if dbo:
+			# If we have PVs, verify them
+			if len(pv_dests_and_ranges):
+				for pr in pv_dests_and_ranges:
+					pv_dbus_obj = cfg.om.get_object_by_path(pr[0])
+					if not pv_dbus_obj:
+						raise dbus.exceptions.DBusException(
+							LV_INTERFACE,
+							'PV Destination (%s) not found' % pr[0])
+
+					pv_dests.append((pv_dbus_obj.lvm_id, pr[1], pr[2]))
+
+			size_change = new_size_bytes - dbo.SizeBytes
+
+			rc, out, err = cmdhandler.lv_resize(dbo.lvm_id, size_change,
+												pv_dests, resize_options)
+
+			if rc == 0:
+				# Refresh what's changed
+				cfg.load()
+				return "/"
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(lv_uuid, lv_name))
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='ta(ott)ia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Resize(self, new_size_bytes, pv_dests_and_ranges, tmo,
+			resize_options, cb, cbe):
+		"""
+		Resize a LV
+		:param new_size_bytes: The requested final size in bytes
+		:param pv_dests_and_ranges: An array of pv object paths and src &
+									dst. segment ranges
+		:param tmo: -1 to wait forever, 0 to return job immediately, else
+					number of seconds to wait for operation to complete
+					before getting a job
+		:param resize_options: key/value hash of options
+		:param cb:  Used by framework not client facing API
+		:param cbe: Used by framework not client facing API
+		:return: '/' if complete, else job object path
+		"""
+		r = RequestEntry(
+			tmo, Lv._resize,
+			(self.Uuid, self.lvm_id, round_size(new_size_bytes),
+			pv_dests_and_ranges,
+			resize_options), cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _lv_activate_deactivate(uuid, lv_name, activate, control_flags,
+								options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, lv_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.activate_deactivate(
+				'lvchange', lv_name, activate, control_flags, options)
+			if rc == 0:
+				dbo.refresh()
+				return '/'
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(uuid, lv_name))
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='tia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Activate(self, control_flags, tmo, activate_options, cb, cbe):
+		r = RequestEntry(
+			tmo, Lv._lv_activate_deactivate,
+			(self.state.Uuid, self.state.lvm_id, True,
+			control_flags, activate_options),
+			cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	# noinspection PyProtectedMember
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='tia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Deactivate(self, control_flags, tmo, activate_options, cb, cbe):
+		r = RequestEntry(
+			tmo, Lv._lv_activate_deactivate,
+			(self.state.Uuid, self.state.lvm_id, False,
+			control_flags, activate_options),
+			cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _add_rm_tags(uuid, lv_name, tags_add, tags_del, tag_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, lv_name)
+
+		if dbo:
+
+			rc, out, err = cmdhandler.lv_tag(
+				lv_name, tags_add, tags_del, tag_options)
+			if rc == 0:
+				dbo.refresh()
+				return '/'
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(uuid, lv_name))
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='asia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def TagsAdd(self, tags, tmo, tag_options, cb, cbe):
+
+		for t in tags:
+			utils.validate_tag(LV_INTERFACE, t)
+
+		r = RequestEntry(
+			tmo, Lv._add_rm_tags,
+			(self.state.Uuid, self.state.lvm_id,
+			tags, None, tag_options),
+			cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=LV_INTERFACE,
+		in_signature='asia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def TagsDel(self, tags, tmo, tag_options, cb, cbe):
+
+		for t in tags:
+			utils.validate_tag(LV_INTERFACE, t)
+
+		r = RequestEntry(
+			tmo, Lv._add_rm_tags,
+			(self.state.Uuid, self.state.lvm_id,
+			None, tags, tag_options),
+			cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+
+# noinspection PyPep8Naming
+class LvThinPool(Lv):
+	_DataLv_meta = ("o", THIN_POOL_INTERFACE)
+	_MetaDataLv_meta = ("o", THIN_POOL_INTERFACE)
+
+	def _fetch_hidden(self, name):
+
+		# The name is vg/name
+		full_name = "%s/%s" % (self.vg_name_lookup(), name)
+
+		o = cfg.om.get_object_by_lvm_id(full_name)
+		if o:
+			return o.dbus_object_path()
+
+		return '/'
+
+	def _get_data_meta(self):
+
+		# Get the data
+		return (self._fetch_hidden(self.state.data_lv),
+				self._fetch_hidden(self.state.metadata_lv))
+
+	def __init__(self, object_path, object_state):
+		super(LvThinPool, self).__init__(object_path, object_state)
+		self.set_interface(THIN_POOL_INTERFACE)
+		self._data_lv, self._metadata_lv = self._get_data_meta()
+
+	@property
+	def DataLv(self):
+		return self._data_lv
+
+	@property
+	def MetaDataLv(self):
+		return self._metadata_lv
+
+	@staticmethod
+	def _lv_create(lv_uuid, lv_name, name, size_bytes, create_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
+
+		lv_created = '/'
+
+		if dbo:
+			rc, out, err = cmdhandler.lv_lv_create(
+				lv_name, create_options, name, size_bytes)
+			if rc == 0:
+				full_name = "%s/%s" % (dbo.vg_name_lookup(), name)
+				lvs = load_lvs([full_name], emit_signal=True)[0]
+				for l in lvs:
+					lv_created = l.dbus_object_path()
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(lv_uuid, lv_name))
+		return lv_created
+
+	@dbus.service.method(
+		dbus_interface=THIN_POOL_INTERFACE,
+		in_signature='stia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def LvCreate(self, name, size_bytes, tmo, create_options, cb, cbe):
+		utils.validate_lv_name(THIN_POOL_INTERFACE, self.vg_name_lookup(), name)
+
+		r = RequestEntry(
+			tmo, LvThinPool._lv_create,
+			(self.Uuid, self.lvm_id, name,
+			round_size(size_bytes), create_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+
+# noinspection PyPep8Naming
+class LvCachePool(Lv):
+	def __init__(self, object_path, object_state):
+		super(LvCachePool, self).__init__(object_path, object_state)
+		self.set_interface(CACHE_POOL_INTERFACE)
+
+	@staticmethod
+	def _cache_lv(lv_uuid, lv_name, lv_object_path, cache_options):
+
+		# Make sure we have a dbus object representing cache pool
+		dbo = cfg.om.get_object_by_uuid_lvm_id(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 dbo and 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!
+				cfg.om.remove_object(dbo, emit_signal=True)
+				cfg.om.remove_object(lv_to_cache, emit_signal=True)
+				cfg.load()
+
+				lv_converted = \
+					cfg.om.get_object_by_lvm_id(fcn).dbus_object_path()
+
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			msg = ""
+			if not dbo:
+				dbo += 'CachePool LV with uuid %s and name %s not present!' % \
+					(lv_uuid, lv_name)
+
+			if not lv_to_cache:
+				dbo += 'LV to cache with object path %s not present!' % \
+					(lv_object_path)
+
+			raise dbus.exceptions.DBusException(LV_INTERFACE, msg)
+		return lv_converted
+
+	@dbus.service.method(
+		dbus_interface=CACHE_POOL_INTERFACE,
+		in_signature='oia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def CacheLv(self, lv_object, tmo, cache_options, cb, cbe):
+		r = RequestEntry(
+			tmo, LvCachePool._cache_lv,
+			(self.Uuid, self.lvm_id, lv_object,
+			cache_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+
+# noinspection PyPep8Naming
+class LvCacheLv(Lv):
+	_CachePool_meta = ("o", LV_CACHED)
+
+	def __init__(self, object_path, object_state):
+		super(LvCacheLv, self).__init__(object_path, object_state)
+		self.set_interface(LV_CACHED)
+
+	@property
+	def CachePool(self):
+		return self.state.PoolLv
+
+	@staticmethod
+	def _detach_lv(lv_uuid, lv_name, detach_options, destroy_cache):
+		# Make sure we have a dbus object representing cache pool
+		dbo = cfg.om.get_object_by_uuid_lvm_id(lv_uuid, lv_name)
+
+		if dbo:
+
+			# Get current cache name
+			cache_pool = cfg.om.get_object_by_path(dbo.CachePool)
+
+			rc, out, err = cmdhandler.lv_detach_cache(
+				dbo.lv_full_name(), detach_options, destroy_cache)
+			if rc == 0:
+				# The cache pool gets removed as hidden and put back to
+				# visible, so lets delete
+				cfg.om.remove_object(cache_pool, emit_signal=True)
+				cfg.om.remove_object(dbo, emit_signal=True)
+				cfg.load()
+
+				uncached_lv_path = \
+					cfg.om.get_object_by_lvm_id(lv_name).dbus_object_path()
+
+			else:
+				raise dbus.exceptions.DBusException(
+					LV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				LV_INTERFACE,
+				'LV with uuid %s and name %s not present!' %
+				(lv_uuid, lv_name))
+		return uncached_lv_path
+
+	@dbus.service.method(
+		dbus_interface=LV_CACHED,
+		in_signature='bia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def DetachCachePool(self, destroy_cache, tmo, detach_options, cb, cbe):
+		r = RequestEntry(
+			tmo, LvCacheLv._detach_lv,
+			(self.Uuid, self.lvm_id, detach_options,
+			destroy_cache), cb, cbe)
+		cfg.worker_q.put(r)
+
+
+# noinspection PyPep8Naming
+class LvSnapShot(Lv):
+	def __init__(self, object_path, object_state):
+		super(LvSnapShot, self).__init__(object_path, object_state)
+		self.set_interface(SNAPSHOT_INTERFACE)
+
+	@dbus.service.method(
+		dbus_interface=SNAPSHOT_INTERFACE,
+		in_signature='ia{sv}',
+		out_signature='o')
+	def Merge(self, tmo, merge_options):
+		return background.merge(SNAPSHOT_INTERFACE, self.Uuid, self.lvm_id,
+								merge_options, tmo)

daemons/lvmdbusd/lvm_shell_proxy.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+#
+# Copyright 2015-2016, Vratislav Podzimek <vpodzime@redhat.com>
+
+import subprocess
+import shlex
+from fcntl import fcntl, F_GETFL, F_SETFL
+from os import O_NONBLOCK
+import traceback
+import sys
+import re
+
+try:
+	from .cfg import LVM_CMD
+	from .utils import log_debug, log_error
+except:
+	from cfg import LVM_CMD
+	from utils import log_debug, log_error
+
+SHELL_PROMPT = "lvm> "
+
+
+def _quote_arg(arg):
+	if len(shlex.split(arg)) > 1:
+		return '"%s"' % arg
+	else:
+		return arg
+
+
+class LVMShellProxy(object):
+	def _read_until_prompt(self):
+		prev_ec = None
+		stdout = ""
+		while not stdout.endswith(SHELL_PROMPT):
+			try:
+				tmp = self.lvm_shell.stdout.read()
+				if tmp:
+					stdout += tmp.decode("utf-8")
+			except IOError:
+				# nothing written yet
+				pass
+
+		# strip the prompt from the STDOUT before returning and grab the exit
+		# code if it's available
+		m = self.re.match(stdout)
+		if m:
+			prev_ec = int(m.group(2))
+			strip_idx = -1 * len(m.group(1))
+		else:
+			strip_idx = -1 * len(SHELL_PROMPT)
+
+		return stdout[:strip_idx], prev_ec
+
+	def _read_line(self):
+		while True:
+			try:
+				tmp = self.lvm_shell.stdout.readline()
+				if tmp:
+					return tmp.decode("utf-8")
+			except IOError:
+				pass
+
+	def _discard_echo(self, expected):
+		line = ""
+		while line != expected:
+			# GNU readline inserts some interesting characters at times...
+			line += self._read_line().replace(' \r', '')
+
+	def _write_cmd(self, cmd):
+		cmd_bytes = bytes(cmd, "utf-8")
+		num_written = self.lvm_shell.stdin.write(cmd_bytes)
+		assert (num_written == len(cmd_bytes))
+		self.lvm_shell.stdin.flush()
+
+	def _lvm_echos(self):
+		echo = False
+		cmd = "version\n"
+		self._write_cmd(cmd)
+		line = self._read_line()
+
+		if line == cmd:
+			echo = True
+
+		self._read_until_prompt()
+
+		return echo
+
+	def __init__(self):
+		self.re = re.compile(".*(\[(-?[0-9]+)\] lvm> $)", re.DOTALL)
+
+		# run the lvm shell
+		self.lvm_shell = subprocess.Popen(
+			[LVM_CMD], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+			stderr=subprocess.PIPE, close_fds=True)
+		flags = fcntl(self.lvm_shell.stdout, F_GETFL)
+		fcntl(self.lvm_shell.stdout, F_SETFL, flags | O_NONBLOCK)
+		flags = fcntl(self.lvm_shell.stderr, F_GETFL)
+		fcntl(self.lvm_shell.stderr, F_SETFL, flags | O_NONBLOCK)
+
+		# wait for the first prompt
+		self._read_until_prompt()
+
+		# Check to see if the version of LVM we are using is running with
+		# gnu readline which will echo our writes from stdin to stdout
+		self.echo = self._lvm_echos()
+
+	def call_lvm(self, argv, debug=False):
+		# create the command string
+		cmd = " ".join(_quote_arg(arg) for arg in argv)
+		cmd += "\n"
+
+		# run the command by writing it to the shell's STDIN
+		self._write_cmd(cmd)
+
+		# If lvm is utilizing gnu readline, it echos stdin to stdout
+		if self.echo:
+			self._discard_echo(cmd)
+
+		# read everything from the STDOUT to the next prompt
+		stdout, exit_code = self._read_until_prompt()
+
+		# read everything from STDERR if there's something (we waited for the
+		# prompt on STDOUT so there should be all or nothing at this point on
+		# STDERR)
+		stderr = None
+		try:
+			t_error = self.lvm_shell.stderr.read()
+			if t_error:
+				stderr = t_error.decode("utf-8")
+		except IOError:
+			# nothing on STDERR
+			pass
+
+		if exit_code is not None:
+			rc = exit_code
+		else:
+			# LVM does write to stderr even when it did complete successfully,
+			# so without having the exit code in the prompt we can never be
+			# sure.
+			if stderr:
+				rc = 1
+			else:
+				rc = 0
+
+		if debug or rc != 0:
+			log_error(('CMD: %s' % cmd))
+			log_error(("EC = %d" % rc))
+			log_error(("STDOUT=\n %s\n" % stdout))
+			log_error(("STDERR=\n %s\n" % stderr))
+
+		return (rc, stdout, stderr)
+
+	def __del__(self):
+		self.lvm_shell.terminate()
+
+
+if __name__ == "__main__":
+	shell = LVMShellProxy()
+	in_line = "start"
+	try:
+		while in_line:
+			in_line = input("lvm> ")
+			if in_line:
+				ret, out, err, = shell.call_lvm(in_line.split())
+				print(("RET: %d" % ret))
+				print(("OUT:\n%s" % out))
+				print(("ERR:\n%s" % err))
+	except KeyboardInterrupt:
+		pass
+	except EOFError:
+		pass
+	except Exception:
+		traceback.print_exc(file=sys.stdout)
+	finally:
+		print()

daemons/lvmdbusd/lvmdb.py

@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from collections import OrderedDict
+
+import pprint as prettyprint
+
+try:
+	from . import cmdhandler
+	from .utils import log_debug
+except SystemError:
+	import cmdhandler
+	from utils import log_debug
+
+
+class DataStore(object):
+	def __init__(self):
+		self.pvs = {}
+		self.vgs = {}
+		self.lvs = {}
+		self.pv_lvs = {}
+		self.lv_pvs = {}
+		self.lvs_hidden = {}
+
+		self.pv_path_to_uuid = {}
+		self.vg_name_to_uuid = {}
+		self.lv_full_name_to_uuid = {}
+
+		self.lvs_in_vgs = {}
+		self.pvs_in_vgs = {}
+
+		# self.refresh()
+		self.num_refreshes = 0
+
+	@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 _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,
+				['pv_seg_start', 'pvseg_size', 'segtype'])
+
+		for p in c_pvs.values():
+			# Capture which PVs are associated with which VG
+			if p['vg_uuid'] not in c_pvs_in_vgs:
+				c_pvs_in_vgs[p['vg_uuid']] = []
+
+			if p['vg_name']:
+				c_pvs_in_vgs[p['vg_uuid']].append(
+					(p['pv_name'], p['pv_uuid']))
+
+			# Lookup for translating between /dev/<name> and pv uuid
+			c_lookup[p['pv_name']] = p['pv_uuid']
+
+		return c_pvs, c_lookup, c_pvs_in_vgs
+
+	@staticmethod
+	def _parse_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_lvs(_lvs):
+		lvs = sorted(_lvs, key=lambda vk: vk['lv_name'])
+
+		c_lvs = OrderedDict()
+		c_lvs_in_vgs = {}
+		c_lvs_hidden = {}
+		c_lv_full_lookup = {}
+
+		for i in lvs:
+			full_name = "%s/%s" % (i['vg_name'], i['lv_name'])
+			c_lv_full_lookup[full_name] = i['lv_uuid']
+			DataStore._insert_record(
+				c_lvs, i['lv_uuid'], i,
+				['seg_pe_ranges', 'segtype'])
+
+		for i in c_lvs.values():
+			if i['vg_uuid'] not in c_lvs_in_vgs:
+				c_lvs_in_vgs[i['vg_uuid']] = []
+
+			c_lvs_in_vgs[
+				i['vg_uuid']].append(
+					(i['lv_name'],
+					(i['lv_attr'], i['lv_layout'], i['lv_role']),
+					i['lv_uuid']))
+
+			if i['lv_parent']:
+				# Lookup what the parent refers too
+				parent_name = i['lv_parent']
+				full_parent_name = "%s/%s" % (i['vg_name'], parent_name)
+				if full_parent_name not in c_lv_full_lookup:
+					parent_name = '[%s]' % (parent_name)
+					full_parent_name = "%s/%s" % (i['vg_name'], parent_name)
+
+				parent_uuid = c_lv_full_lookup[full_parent_name]
+
+				if parent_uuid not in c_lvs_hidden:
+					c_lvs_hidden[parent_uuid] = []
+
+				c_lvs_hidden[parent_uuid].append(
+					(i['lv_uuid'], i['lv_name']))
+
+		return c_lvs, c_lvs_in_vgs, c_lvs_hidden, c_lv_full_lookup
+
+	@staticmethod
+	def _make_list(l):
+		if not isinstance(l, list):
+			l = [l]
+		return l
+
+	@staticmethod
+	def _parse_seg_entry(se, segtype):
+		if se:
+			# print("_parse_seg_entry %s %s" % (str(se), str(segtype)))
+			device, segs = se.split(":")
+			start, end = segs.split('-')
+			return (device, (start, end), segtype)
+		else:
+			return ("", (), segtype)
+
+	@staticmethod
+	def _build_segments(l, seg_types):
+		rc = []
+		l = DataStore._make_list(l)
+		s = DataStore._make_list(seg_types)
+
+		assert len(l) == len(s)
+		ls = list(zip(l, s))
+
+		for i in ls:
+			if ' ' in i[0]:
+				tmp = i[0].split(' ')
+				for t in tmp:
+					rc.append(DataStore._parse_seg_entry(t, i[1]))
+			else:
+				rc.append(DataStore._parse_seg_entry(*i))
+		return rc
+
+	@staticmethod
+	def _pv_device_lv_entry(table, pv_device, lv_uuid, meta, lv_attr,
+							segment_info):
+
+		if pv_device not in table:
+			table[pv_device] = {}
+
+		if lv_uuid not in table[pv_device]:
+			table[pv_device][lv_uuid] = {}
+			table[pv_device][lv_uuid]['segs'] = [segment_info]
+			table[pv_device][lv_uuid]['name'] = meta
+			table[pv_device][lv_uuid]['meta'] = lv_attr
+		else:
+			table[pv_device][lv_uuid]['segs'].append(segment_info)
+
+	@staticmethod
+	def _pv_device_lv_format(pv_device_lvs):
+		rc = {}
+
+		for pv_device, pd in pv_device_lvs.items():
+			lvs = []
+			for lv_uuid, ld in sorted(pd.items()):
+				lvs.append((lv_uuid, ld['name'], ld['meta'], ld['segs']))
+
+			rc[pv_device] = lvs
+		return rc
+
+	@staticmethod
+	def _lvs_device_pv_entry(table, lv_uuid, pv_device, pv_uuid, segment_info):
+		if lv_uuid not in table:
+			table[lv_uuid] = {}
+
+		if pv_device not in table[lv_uuid]:
+			table[lv_uuid][pv_device] = {}
+			table[lv_uuid][pv_device]['segs'] = [segment_info]
+			table[lv_uuid][pv_device]['pv_uuid'] = pv_uuid
+		else:
+			table[lv_uuid][pv_device]['segs'].append(segment_info)
+
+	@staticmethod
+	def _lvs_device_pv_format(lvs_device_pvs):
+		rc = {}
+
+		for lv_uuid, ld in lvs_device_pvs.items():
+			pvs = []
+			for pv_device, pd in sorted(ld.items()):
+				pvs.append((pd['pv_uuid'], pv_device, pd['segs']))
+
+			rc[lv_uuid] = pvs
+		return rc
+
+	def _parse_pv_in_lvs(self):
+		pv_device_lvs = {}  # What LVs are stored on a PV
+		lvs_device_pv = {}  # Where LV data is stored
+
+		for i in self.lvs.values():
+			segs = self._build_segments(i['seg_pe_ranges'], i['segtype'])
+			for s in segs:
+				# We are referring to physical device
+				if '/dev/' in s[0]:
+					device, r, seg_type = s
+
+					DataStore._pv_device_lv_entry(
+						pv_device_lvs, device, i['lv_uuid'], i['lv_name'],
+						(i['lv_attr'], i['lv_layout'], i['lv_role']),
+						(r[0], r[1], seg_type))
+
+					# (pv_name, pv_segs, pv_uuid)
+					DataStore._lvs_device_pv_entry(
+						lvs_device_pv, i['lv_uuid'], device,
+						self.pv_path_to_uuid[device], (r[0], r[1], seg_type))
+				else:
+					# TODO Handle the case where the segments refer to a LV
+					# and not a PV
+					pass
+					# print("Handle this %s %s %s" % (s[0], s[1], s[2]))
+
+		# Convert form to needed result for consumption
+		pv_device_lvs_result = DataStore._pv_device_lv_format(pv_device_lvs)
+		lvs_device_pv_result = DataStore._lvs_device_pv_format(lvs_device_pv)
+
+		return pv_device_lvs_result, lvs_device_pv_result
+
+	def refresh(self, log=True):
+		"""
+		Go out and query lvm for the latest data in as few trips as possible
+		:param log  Add debug log entry/exit messages
+		:return: None
+		"""
+		self.num_refreshes += 1
+		if log:
+			log_debug("lvmdb - refresh entry")
+
+		# Grab everything first then parse it
+		_raw_pvs = cmdhandler.pv_retrieve_with_segs()
+		_raw_vgs = cmdhandler.vg_retrieve(None)
+		_raw_lvs = cmdhandler.lv_retrieve_with_segments()
+
+		_pvs, _pvs_lookup, _pvs_in_vgs = self._parse_pvs(_raw_pvs)
+		_vgs, _vgs_lookup = self._parse_vgs(_raw_vgs)
+		_lvs, _lvs_in_vgs, _lvs_hidden, _lvs_lookup = self._parse_lvs(_raw_lvs)
+
+		# 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")
+
+	def fetch_pvs(self, pv_name):
+		if not pv_name:
+			return self.pvs.values()
+		else:
+			rc = []
+			for s in pv_name:
+				rc.append(self.pvs[self.pv_path_to_uuid[s]])
+			return rc
+
+	def fetch_vgs(self, vg_name):
+		if not vg_name:
+			return self.vgs.values()
+		else:
+			rc = []
+			for s in vg_name:
+				rc.append(self.vgs[self.vg_name_to_uuid[s]])
+			return rc
+
+	def fetch_lvs(self, lv_names):
+		try:
+			if not lv_names:
+				return self.lvs.values()
+			else:
+				rc = []
+				for s in lv_names:
+					rc.append(self.lvs[self.lv_full_name_to_uuid[s]])
+				return rc
+		except KeyError as ke:
+			print("Key %s not found!" % (str(lv_names)))
+			print("lv name to uuid lookup")
+			for keys in sorted(self.lv_full_name_to_uuid.keys()):
+				print("%s" % (keys))
+			print("lvs entries by uuid")
+			for keys in sorted(self.lvs.keys()):
+				print("%s" % (keys))
+			raise ke
+
+	def pv_pe_segments(self, pv_uuid):
+		pv = self.pvs[pv_uuid]
+		return list(zip(pv['pv_seg_start'], pv['pvseg_size']))
+
+	def pv_contained_lv(self, pv_device):
+		rc = []
+		if pv_device in self.pv_lvs:
+			rc = self.pv_lvs[pv_device]
+		return rc
+
+	def lv_contained_pv(self, lv_uuid):
+		rc = []
+		if lv_uuid in self.lv_pvs:
+			rc = self.lv_pvs[lv_uuid]
+		return rc
+
+	def lvs_in_vg(self, vg_uuid):
+		# Return an array of
+		# (lv_name, (lv_attr, lv_layout, lv_role), lv_uuid)
+		rc = []
+		if vg_uuid in self.lvs_in_vgs:
+			rc = self.lvs_in_vgs[vg_uuid]
+		return rc
+
+	def pvs_in_vg(self, vg_uuid):
+		# Returns an array of (pv_name, pv_uuid)
+		rc = []
+		if vg_uuid in self.pvs_in_vgs:
+			rc = self.pvs_in_vgs[vg_uuid]
+		return rc
+
+	def hidden_lvs(self, lv_uuid):
+		# For a specified LV, return a list of hidden lv_uuid, lv_name
+		# for it
+		rc = []
+		if lv_uuid in self.lvs_hidden:
+			rc = self.lvs_hidden[lv_uuid]
+		return rc
+
+
+if __name__ == "__main__":
+	pp = prettyprint.PrettyPrinter(indent=4)
+
+	ds = DataStore()
+	ds.refresh()
+
+	for v in ds.pvs.values():
+		pp.pprint(v)
+
+	for v in ds.vgs.values():
+		pp.pprint(v)
+
+	print("LVS")
+	for v in ds.lvs.values():
+		pp.pprint(v)
+
+	print("LVS in VG")
+	for k, v in ds.lvs_in_vgs.items():
+		print("VG uuid = %s" % (k))
+		pp.pprint(v)
+
+	print("pv_in_lvs")
+	for k, v in ds.pv_lvs.items():
+		print("PV %s contains LVS:" % (k))
+		pp.pprint(v)
+
+	for k, v in ds.lv_pvs.items():
+		print("LV device = %s" % (k))
+		pp.pprint(v)

daemons/lvmdbusd/lvmdbusd

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import sys
+import lvmdbusd
+
+if __name__ == '__main__':
+	sys.exit(lvmdbusd.main())

daemons/lvmdbusd/main.py

@@ -0,0 +1,176 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from . import cfg
+from . import objectmanager
+from . import utils
+from .cfg import BASE_INTERFACE, BASE_OBJ_PATH, MANAGER_OBJ_PATH
+import threading
+from . import cmdhandler
+import time
+import signal
+import dbus
+from . import lvmdb
+# noinspection PyUnresolvedReferences
+from gi.repository import GObject
+from .fetch import load
+from .manager import Manager
+from .background import background_reaper
+import traceback
+import queue
+from . import udevwatch
+from .utils import log_debug
+import argparse
+import os
+from .refresh import handle_external_event, event_complete
+
+
+class Lvm(objectmanager.ObjectManager):
+	def __init__(self, object_path):
+		super(Lvm, self).__init__(object_path, BASE_INTERFACE)
+
+
+def _discard_pending_refreshes():
+	# We just handled a refresh, if we have any in the queue they can be
+	# removed because by definition they are older than the refresh we just did.
+	# As we limit the number of refreshes getting into the queue
+	# we should only ever have one to remove.
+	requests = []
+	while not cfg.worker_q.empty():
+		try:
+			r = cfg.worker_q.get(block=False)
+			if r.method != handle_external_event:
+				requests.append(r)
+			else:
+				# Make sure we make this event complete even though it didn't
+				# run, otherwise no other events will get processed
+				event_complete()
+				break
+		except queue.Empty:
+			break
+
+	# Any requests we removed, but did not discard need to be re-queued
+	for r in requests:
+		cfg.worker_q.put(r)
+
+
+def process_request():
+	while cfg.run.value != 0:
+		try:
+			req = cfg.worker_q.get(True, 5)
+
+			start = cfg.db.num_refreshes
+
+			log_debug(
+				"Running method: %s with args %s" %
+				(str(req.method), str(req.arguments)))
+			req.run_cmd()
+
+			end = cfg.db.num_refreshes
+
+			num_refreshes = end - start
+
+			if num_refreshes > 0:
+				_discard_pending_refreshes()
+
+				if num_refreshes > 1:
+					log_debug(
+						"Inspect method %s for too many refreshes" %
+						(str(req.method)))
+			log_debug("Complete ")
+		except queue.Empty:
+			pass
+		except Exception:
+			st = traceback.format_exc()
+			utils.log_error("process_request exception: \n%s" % st)
+
+
+def main():
+	# Add simple command line handling
+	parser = argparse.ArgumentParser()
+	parser.add_argument("--udev", action='store_true',
+						help="Use udev for updating state", default=False,
+						dest='use_udev')
+	parser.add_argument("--debug", action='store_true',
+						help="Dump debug messages", default=False,
+						dest='debug')
+
+	use_session = os.getenv('LVMDBUSD_USE_SESSION', False)
+
+	args = parser.parse_args()
+
+	cfg.DEBUG = args.debug
+
+	# List of threads that we start up
+	thread_list = []
+
+	start = time.time()
+
+	# Install signal handlers
+	for s in [signal.SIGHUP, signal.SIGINT]:
+		try:
+			signal.signal(s, utils.handler)
+		except RuntimeError:
+			pass
+
+	dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+	GObject.threads_init()
+	dbus.mainloop.glib.threads_init()
+
+	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(BASE_INTERFACE, cfg.bus)
+	cfg.om = Lvm(BASE_OBJ_PATH)
+	cfg.om.register_object(Manager(MANAGER_OBJ_PATH))
+
+	cfg.load = load
+
+	cfg.db = lvmdb.DataStore()
+
+	# Start up thread to monitor pv moves
+	thread_list.append(
+		threading.Thread(target=background_reaper, name="pv_move_reaper"))
+
+	# Using a thread to process requests.
+	thread_list.append(threading.Thread(target=process_request))
+
+	cfg.load(refresh=False, emit_signal=False)
+	cfg.loop = GObject.MainLoop()
+
+	for process in thread_list:
+		process.damon = True
+		process.start()
+
+	end = time.time()
+	log_debug(
+		'Service ready! total time= %.2f, lvm time= %.2f count= %d' %
+		(end - start, cmdhandler.total_time, cmdhandler.total_count),
+		'bg_black', 'fg_light_green')
+
+	# Add udev watching
+	if args.use_udev:
+		log_debug('Utilizing udev to trigger updates')
+		udevwatch.add()
+
+	try:
+		if cfg.run.value != 0:
+			cfg.loop.run()
+
+			if args.use_udev:
+				udevwatch.remove()
+
+			for process in thread_list:
+				process.join()
+	except KeyboardInterrupt:
+		utils.handler(signal.SIGINT, None)
+	return 0

daemons/lvmdbusd/manager.py

@@ -0,0 +1,246 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from .automatedproperties import AutomatedProperties
+
+from . import utils
+from .cfg import MANAGER_INTERFACE
+import dbus
+from . import cfg
+from . import cmdhandler
+from .fetch import load_pvs, load_vgs
+from .request import RequestEntry
+from .refresh import event_add
+
+
+# noinspection PyPep8Naming
+class Manager(AutomatedProperties):
+	_Version_meta = ("t", MANAGER_INTERFACE)
+
+	def __init__(self, object_path):
+		super(Manager, self).__init__(object_path)
+		self.set_interface(MANAGER_INTERFACE)
+
+	@property
+	def Version(self):
+		return '1.0.0'
+
+	@staticmethod
+	def _pv_create(device, create_options):
+
+		# Check to see if we are already trying to create a PV for an existing
+		# PV
+		pv = cfg.om.get_object_path_by_lvm_id(
+			device, device, None, False)
+		if pv:
+			raise dbus.exceptions.DBusException(
+				MANAGER_INTERFACE, "PV Already exists!")
+
+		created_pv = []
+		rc, out, err = cmdhandler.pv_create(create_options, [device])
+		if rc == 0:
+			pvs = load_pvs([device], emit_signal=True)[0]
+			for p in pvs:
+				created_pv = p.dbus_object_path()
+		else:
+			raise dbus.exceptions.DBusException(
+				MANAGER_INTERFACE,
+				'Exit code %s, stderr = %s' % (str(rc), err))
+
+		return created_pv
+
+	@dbus.service.method(
+		dbus_interface=MANAGER_INTERFACE,
+		in_signature='sia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def PvCreate(self, device, tmo, create_options, cb, cbe):
+		utils.validate_device_path(MANAGER_INTERFACE, device)
+		r = RequestEntry(
+			tmo, Manager._pv_create,
+			(device, create_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _create_vg(name, pv_object_paths, create_options):
+		pv_devices = []
+
+		for p in pv_object_paths:
+			pv = cfg.om.get_object_by_path(p)
+			if pv:
+				pv_devices.append(pv.Name)
+			else:
+				raise dbus.exceptions.DBusException(
+					MANAGER_INTERFACE, 'object path = %s not found' % p)
+
+		rc, out, err = cmdhandler.vg_create(create_options, pv_devices, name)
+		created_vg = "/"
+
+		if rc == 0:
+			vgs = load_vgs([name], emit_signal=True)[0]
+			for v in vgs:
+				created_vg = v.dbus_object_path()
+
+			# Update the PVS
+			load_pvs(refresh=True, emit_signal=True, cache_refresh=False)
+		else:
+			raise dbus.exceptions.DBusException(
+				MANAGER_INTERFACE,
+				'Exit code %s, stderr = %s' % (str(rc), err))
+		return created_vg
+
+	@dbus.service.method(
+		dbus_interface=MANAGER_INTERFACE,
+		in_signature='saoia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def VgCreate(self, name, pv_object_paths, tmo, create_options, cb, cbe):
+		utils.validate_vg_name(MANAGER_INTERFACE, name)
+		r = RequestEntry(
+			tmo, Manager._create_vg,
+			(name, pv_object_paths, create_options,),
+			cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _refresh():
+		utils.log_debug('Manager.Refresh - entry')
+
+		# This is a diagnostic and should not be run in normal operation, so
+		# lets remove the log entries for refresh as it's implied.
+		rc = cfg.load(log=False)
+
+		if rc != 0:
+			utils.log_debug('Manager.Refresh - exit %d' % (rc),
+							'bg_black', 'fg_light_red')
+		else:
+			utils.log_debug('Manager.Refresh - exit %d' % (rc))
+		return rc
+
+	@dbus.service.method(
+		dbus_interface=MANAGER_INTERFACE,
+		out_signature='t',
+		async_callbacks=('cb', 'cbe'))
+	def Refresh(self, cb, cbe):
+		"""
+		Take all the objects we know about and go out and grab the latest
+		more of a test method at the moment to make sure we are handling object
+		paths correctly.
+
+		:param cb   Callback for result
+		:param cbe  Callback for errors
+
+		Returns the number of changes, object add/remove/properties changed
+		"""
+		r = RequestEntry(-1, Manager._refresh, (), cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=MANAGER_INTERFACE,
+		in_signature='s',
+		out_signature='o')
+	def LookUpByLvmId(self, key):
+		"""
+		Given a lvm id in one of the forms:
+
+		/dev/sda
+		some_vg
+		some_vg/some_lv
+		Oe1rPX-Pf0W-15E5-n41N-ZmtF-jXS0-Osg8fn
+
+		return the object path in O(1) time.
+
+		:param key: The lookup value
+		:return: Return the object path.  If object not found you will get '/'
+		"""
+		p = cfg.om.get_object_path_by_lvm_id(
+			key, key, gen_new=False)
+		if p:
+			return p
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=MANAGER_INTERFACE,
+		in_signature='b')
+	def UseLvmShell(self, yes_no):
+		"""
+		Allow the client to enable/disable lvm shell, used for testing
+		:param yes_no:
+		:return: Nothing
+		"""
+		cmdhandler.set_execution(yes_no)
+
+	@dbus.service.method(
+		dbus_interface=MANAGER_INTERFACE,
+		in_signature='s', out_signature='i')
+	def ExternalEvent(self, command):
+
+		event_add((command,))
+		return dbus.Int32(0)
+
+	@staticmethod
+	def _pv_scan(activate, cache, device_path, major_minor, scan_options):
+
+		rc, out, err = cmdhandler.pv_scan(
+			activate, cache, device_path,
+			major_minor, scan_options)
+
+		if rc == 0:
+			# This could potentially change the state quite a bit, so lets
+			# update everything to be safe
+			cfg.load()
+			return '/'
+		else:
+			raise dbus.exceptions.DBusException(
+				MANAGER_INTERFACE,
+				'Exit code %s, stderr = %s' % (str(rc), err))
+
+	@dbus.service.method(
+		dbus_interface=MANAGER_INTERFACE,
+		in_signature='bbasa(ii)ia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def PvScan(self, activate, cache, device_paths, major_minors,
+			tmo, scan_options, cb, cbe):
+		"""
+		Scan all supported LVM block devices in the system for physical volumes
+		NOTE: major_minors & device_paths only usable when cache == True
+		:param activate: If True, activate any newly found LVs
+		:param cache:    If True, update lvmetad
+		:param device_paths: Array of device paths or empty
+		:param major_minors: Array of structures (major,minor)
+		:param tmo: Timeout for operation
+		:param scan_options:  Additional options to pvscan
+		:param cb: Not visible in API (used for async. callback)
+		:param cbe: Not visible in API (used for async. error callback)
+		:return: '/' if operation done, else job path
+		"""
+		for d in device_paths:
+			utils.validate_device_path(MANAGER_INTERFACE, d)
+
+		r = RequestEntry(
+			tmo, Manager._pv_scan,
+			(activate, cache, device_paths, major_minors,
+			scan_options), cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@property
+	def lvm_id(self):
+		"""
+		Intended to be overridden by classes that inherit
+		"""
+		return str(id(self))
+
+	@property
+	def Uuid(self):
+		"""
+		Intended to be overridden by classes that inherit
+		"""
+		import uuid
+		return uuid.uuid1()

daemons/lvmdbusd/objectmanager.py

@@ -0,0 +1,282 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import sys
+import threading
+import traceback
+import dbus
+from . import cfg
+from .utils import log_debug
+from .automatedproperties import AutomatedProperties
+
+
+# noinspection PyPep8Naming
+class ObjectManager(AutomatedProperties):
+	"""
+	Implements the org.freedesktop.DBus.ObjectManager interface
+	"""
+
+	def __init__(self, object_path, interface):
+		super(ObjectManager, self).__init__(object_path, interface)
+		self.set_interface(interface)
+		self._ap_o_path = object_path
+		self._objects = {}
+		self._id_to_object_path = {}
+		self.rlock = threading.RLock()
+
+	@dbus.service.method(
+		dbus_interface="org.freedesktop.DBus.ObjectManager",
+		out_signature='a{oa{sa{sv}}}')
+	def GetManagedObjects(self):
+		with self.rlock:
+			rc = {}
+			try:
+				for k, v in list(self._objects.items()):
+					path, props = v[0].emit_data()
+					rc[path] = props
+			except Exception:
+				traceback.print_exc(file=sys.stdout)
+				sys.exit(1)
+			return rc
+
+	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}}')
+	def InterfacesAdded(self, object_path, int_name_prop_dict):
+		log_debug(
+			('SIGNAL: InterfacesAdded(%s, %s)' %
+			(str(object_path), str(int_name_prop_dict))))
+
+	@dbus.service.signal(
+		dbus_interface="org.freedesktop.DBus.ObjectManager",
+		signature='oas')
+	def InterfacesRemoved(self, object_path, interface_list):
+		log_debug(('SIGNAL: InterfacesRemoved(%s, %s)' %
+			(str(object_path), str(interface_list))))
+
+	def _lookup_add(self, obj, path, lvm_id, uuid):
+		"""
+		Store information about what we added to the caches so that we
+		can remove it cleanly
+		:param obj:     The dbus object we are storing
+		:param lvm_id:  The user name for the asset
+		:param uuid:    The uuid for the asset
+		:return:
+		"""
+		# Note: Only called internally, lock implied
+
+		# We could have a temp entry from the forward creation of a path
+		self._lookup_remove(path)
+
+		self._objects[path] = (obj, lvm_id, uuid)
+		self._id_to_object_path[lvm_id] = path
+
+		if uuid:
+			self._id_to_object_path[uuid] = path
+
+	def _lookup_remove(self, obj_path):
+		# Note: Only called internally, lock implied
+		if obj_path in self._objects:
+			(obj, lvm_id, uuid) = self._objects[obj_path]
+			del self._id_to_object_path[lvm_id]
+			del self._id_to_object_path[uuid]
+			del self._objects[obj_path]
+
+	def lookup_update(self, dbus_obj, new_uuid, new_lvm_id):
+		with self.rlock:
+			obj_path = dbus_obj.dbus_object_path()
+			self._lookup_remove(obj_path)
+			self._lookup_add(
+				dbus_obj, obj_path,
+				new_lvm_id, new_uuid)
+
+	def object_paths_by_type(self, o_type):
+		with self.rlock:
+			rc = {}
+
+			for k, v in list(self._objects.items()):
+				if isinstance(v[0], o_type):
+					rc[k] = True
+			return rc
+
+	def register_object(self, dbus_object, emit_signal=False):
+		"""
+		Given a dbus object add it to the collection
+		:param dbus_object: Dbus object to register
+		:param emit_signal: If true emit a signal for interfaces added
+		"""
+		with self.rlock:
+			path, props = dbus_object.emit_data()
+
+			# print 'Registering object path %s for %s' %
+			# (path, dbus_object.lvm_id)
+
+			# We want fast access to the object by a number of different ways
+			# so we use multiple hashs with different keys
+			self._lookup_add(dbus_object, path, dbus_object.lvm_id,
+				dbus_object.Uuid)
+
+			if emit_signal:
+				self.InterfacesAdded(path, props)
+
+	def remove_object(self, dbus_object, emit_signal=False):
+		"""
+		Given a dbus object, remove it from the collection and remove it
+		from the dbus framework as well
+		:param dbus_object:  Dbus object to remove
+		:param emit_signal:  If true emit the interfaces removed signal
+		"""
+		with self.rlock:
+			# Store off the object path and the interface first
+			path = dbus_object.dbus_object_path()
+			interfaces = dbus_object.interface()
+
+			# print 'UN-Registering object path %s for %s' % \
+			#      (path, dbus_object.lvm_id)
+
+			self._lookup_remove(path)
+
+			# Remove from dbus library
+			dbus_object.remove_from_connection(cfg.bus, path)
+
+			# Optionally emit a signal
+			if emit_signal:
+				self.InterfacesRemoved(path, interfaces)
+
+	def get_object_by_path(self, path):
+		"""
+		Given a dbus path return the object registered for it
+		:param path: The dbus path
+		:return: The object
+		"""
+		with self.rlock:
+			if path in self._objects:
+				return self._objects[path][0]
+			return None
+
+	def get_object_by_uuid_lvm_id(self, uuid, lvm_id):
+		with self.rlock:
+			return self.get_object_by_path(
+				self.get_object_path_by_lvm_id(uuid, lvm_id, None, False))
+
+	def get_object_by_lvm_id(self, lvm_id):
+		"""
+		Given an lvm identifier, return the object registered for it
+		:param lvm_id: The lvm identifier
+		"""
+		with self.rlock:
+			if lvm_id in self._id_to_object_path:
+				return self.get_object_by_path(self._id_to_object_path[lvm_id])
+			return None
+
+	def _uuid_verify(self, path, lvm_id, uuid):
+		"""
+		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 lvm_id:		lvm_id used to find object
+		:param uuid: 		lvm uuid to verify
+		:return: None
+		"""
+		# This gets called when we found an object based on lvm_id, ensure
+		# uuid is correct too, as they can change
+		if lvm_id != uuid:
+			if uuid not in self._id_to_object_path:
+				obj = self.get_object_by_path(path)
+				self._lookup_add(obj, path, lvm_id, uuid)
+
+	def get_object_path_by_lvm_id(self, uuid, lvm_id, path_create=None,
+								gen_new=True):
+		"""
+		For a given lvm asset return the dbus object registered to it.  If the
+		object is not found and gen_new == True and path_create is a valid
+		function we will create a new path, register it and return it.
+		:param uuid: The uuid for the lvm object
+		:param lvm_id: The lvm name
+		:param path_create: If true create an object path if not found
+		:param gen_new: The function used to create the new path
+		"""
+		with self.rlock:
+			assert lvm_id
+			assert uuid
+
+			if gen_new:
+				assert path_create
+
+			path = None
+
+			if lvm_id in self._id_to_object_path:
+				path = self._id_to_object_path[lvm_id]
+				self._uuid_verify(path, lvm_id, uuid)
+				return path
+			if "/" in lvm_id:
+				vg, lv = lvm_id.split("/", 1)
+				int_lvm_id = vg + "/" + ("[%s]" % lv)
+				if int_lvm_id in self._id_to_object_path:
+					path = self._id_to_object_path[int_lvm_id]
+					self._uuid_verify(path, int_lvm_id, uuid)
+					return path
+
+			if uuid and uuid in self._id_to_object_path:
+				# If we get here it indicates that we found the object, but
+				# the lvm_id lookup failed.  In the case of a rename, the uuid
+				# will be correct, but the lvm_id will be wrong and vise versa.
+				# If the lvm_id does not equal the uuid, lets fix up the table
+				# so that lookups will be handled correctly.
+				path = self._id_to_object_path[uuid]
+
+				# In some cases we are looking up by one or the other, don't
+				# update when they are the same.
+				if uuid != lvm_id:
+					obj = self.get_object_by_path(path)
+					self._lookup_add(obj, path, lvm_id, uuid)
+			else:
+				if gen_new:
+					path = path_create()
+					self._lookup_add(None, path, lvm_id, uuid)
+
+			# pprint('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/path.py.in

@@ -0,0 +1,10 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+LVM_BINARY = "@LVM_PATH@"

daemons/lvmdbusd/pv.py

@@ -0,0 +1,282 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from .automatedproperties import AutomatedProperties
+from . import utils
+from . import cfg
+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
+from .loader import common
+from .request import RequestEntry
+from .state import State
+from .utils import round_size
+
+
+# noinspection PyUnusedLocal
+def pvs_state_retrieve(selection, cache_refresh=True):
+	rc = []
+
+	if cache_refresh:
+		cfg.db.refresh()
+
+	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
+
+
+def load_pvs(device=None, object_path=None, refresh=False, emit_signal=False,
+		cache_refresh=True):
+	return common(
+		pvs_state_retrieve, (Pv,), device, object_path, refresh,
+		emit_signal, cache_refresh)
+
+
+# noinspection PyUnresolvedReferences
+class PvState(State):
+	@property
+	def lvm_id(self):
+		return self.lvm_path
+
+	def _lv_object_list(self, vg_name):
+
+		# Note we are returning "a(oa(tts))"
+
+		rc = []
+		if vg_name:
+			for lv in sorted(cfg.db.pv_contained_lv(self.lvm_id)):
+				lv_uuid, lv_name, meta, segs = lv
+				full_name = "%s/%s" % (vg_name, lv_name)
+
+				path_create = lv_object_path_method(lv_name, meta)
+				lv_path = cfg.om.get_object_path_by_lvm_id(
+					lv_uuid, full_name, path_create)
+
+				rc.append((lv_path, segs))
+		return dbus.Array(rc, signature="(oa(tts))")
+
+	# noinspection PyUnusedLocal,PyPep8Naming
+	def __init__(self, lvm_path, Uuid, Name,
+			Fmt, SizeBytes, FreeBytes, UsedBytes, DevSizeBytes,
+			MdaSizeBytes, MdaFreeBytes, BaStart, BaSizeBytes,
+			PeStart, PeCount, PeAllocCount, attr, Tags, vg_name,
+			vg_uuid):
+		utils.init_class_from_arguments(self)
+		self.pe_segments = cfg.db.pv_pe_segments(Uuid)
+
+		self.lv = self._lv_object_list(vg_name)
+
+		if vg_name:
+			self.vg_path = cfg.om.get_object_path_by_lvm_id(
+				vg_uuid, vg_name, vg_obj_path_generate)
+		else:
+			self.vg_path = '/'
+
+	def identifiers(self):
+		return (self.Uuid, self.lvm_path)
+
+	def create_dbus_object(self, path):
+		if not path:
+			path = cfg.om.get_object_path_by_lvm_id(self.Uuid, self.Name,
+													pv_obj_path_generate)
+		return Pv(path, self)
+
+	# noinspection PyMethodMayBeStatic
+	def creation_signature(self):
+		return (Pv, pv_obj_path_generate)
+
+
+# noinspection PyPep8Naming
+@utils.dbus_property(PV_INTERFACE, 'Uuid', 's')  # PV UUID/pv_uuid
+@utils.dbus_property(PV_INTERFACE, 'Name', 's')  # PV/pv_name
+@utils.dbus_property(PV_INTERFACE, 'Fmt', 's')  # Fmt/pv_fmt
+@utils.dbus_property(PV_INTERFACE, 'SizeBytes', 't')  # PSize/pv_size
+@utils.dbus_property(PV_INTERFACE, 'FreeBytes', 't')  # PFree/pv_free
+@utils.dbus_property(PV_INTERFACE, 'UsedBytes', 't')  # Used/pv_used
+@utils.dbus_property(PV_INTERFACE, 'DevSizeBytes', 't')  # DevSize/dev_size
+@utils.dbus_property(PV_INTERFACE, 'MdaSizeBytes', 't')  # PMdaSize/pv_mda_size
+@utils.dbus_property(PV_INTERFACE, 'MdaFreeBytes', 't')  # PMdaFree/pv_mda_free
+@utils.dbus_property(PV_INTERFACE, 'BaStart', 't')  # BA start/pv_ba_start
+@utils.dbus_property(PV_INTERFACE, 'BaSizeBytes', 't')  # BA size/pv_ba_size
+@utils.dbus_property(PV_INTERFACE, 'PeStart', 't')  # 1st PE/pe_start
+@utils.dbus_property(PV_INTERFACE, 'PeCount', 't')  # PE/pv_pe_count
+@utils.dbus_property(PV_INTERFACE, 'PeAllocCount', 't')  # PE Allocation count
+class Pv(AutomatedProperties):
+	# For properties that we need custom handlers we need these, otherwise
+	# we won't get our introspection data
+	_Tags_meta = ("as", PV_INTERFACE)
+	_PeSegments_meta = ("a(tt)", PV_INTERFACE)
+	_Exportable_meta = ("b", PV_INTERFACE)
+	_Allocatable_meta = ("b", PV_INTERFACE)
+	_Missing_meta = ("b", PV_INTERFACE)
+	_Lv_meta = ("a(oa(tts))", PV_INTERFACE)
+	_Vg_meta = ("o", PV_INTERFACE)
+
+	# noinspection PyUnusedLocal,PyPep8Naming
+	def __init__(self, object_path, state_obj):
+		super(Pv, self).__init__(object_path, pvs_state_retrieve)
+		self.set_interface(PV_INTERFACE)
+		self.state = state_obj
+
+	@staticmethod
+	def _remove(pv_uuid, pv_name, remove_options):
+		# Remove the PV, if successful then remove from the model
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(pv_uuid, pv_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.pv_remove(pv_name, remove_options)
+			if rc == 0:
+				cfg.om.remove_object(dbo, True)
+			else:
+				# Need to work on error handling, need consistent
+				raise dbus.exceptions.DBusException(
+					PV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				PV_INTERFACE,
+				'PV with uuid %s and name %s not present!' %
+				(pv_uuid, pv_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=PV_INTERFACE,
+		in_signature='ia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Remove(self, tmo, remove_options, cb, cbe):
+		r = RequestEntry(
+			tmo, Pv._remove,
+			(self.Uuid, self.lvm_id, remove_options),
+			cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _resize(pv_uuid, pv_name, new_size_bytes, resize_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(pv_uuid, pv_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.pv_resize(pv_name, new_size_bytes,
+												resize_options)
+			if rc == 0:
+				dbo.refresh()
+			else:
+				raise dbus.exceptions.DBusException(
+					PV_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				PV_INTERFACE,
+				'PV with uuid %s and name %s not present!' %
+				(pv_uuid, pv_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=PV_INTERFACE,
+		in_signature='tia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def ReSize(self, new_size_bytes, tmo, resize_options, cb, cbe):
+		r = RequestEntry(
+			tmo, Pv._resize,
+			(self.Uuid, self.lvm_id, round_size(new_size_bytes),
+			resize_options), cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _allocation_enabled(pv_uuid, pv_name, yes_no, allocation_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(pv_uuid, pv_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.pv_allocatable(
+				pv_name, yes_no, allocation_options)
+			if rc == 0:
+				cfg.load()
+			else:
+				raise dbus.exceptions.DBusException(
+					PV_INTERFACE, 'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				PV_INTERFACE,
+				'PV with uuid %s and name %s not present!' %
+				(pv_uuid, pv_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=PV_INTERFACE,
+		in_signature='bia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def AllocationEnabled(self, yes, tmo, allocation_options, cb, cbe):
+		r = RequestEntry(
+			tmo, Pv._allocation_enabled,
+			(self.Uuid, self.lvm_id,
+			yes, allocation_options),
+			cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@property
+	def Tags(self):
+		return utils.parse_tags(self.state.Tags)
+
+	@property
+	def PeSegments(self):
+		if len(self.state.pe_segments):
+			return self.state.pe_segments
+		return dbus.Array([], '(tt)')
+
+	@property
+	def Exportable(self):
+		if self.state.attr[1] == 'x':
+			return True
+		return False
+
+	@property
+	def Allocatable(self):
+		if self.state.attr[0] == 'a':
+			return True
+		return False
+
+	@property
+	def Missing(self):
+		if self.state.attr[2] == 'm':
+			return True
+		return False
+
+	def object_path(self):
+		return self._object_path
+
+	@property
+	def lvm_id(self):
+		return self.state.lvm_id
+
+	@property
+	def identifiers(self):
+		return self.state.identifiers()
+
+	@property
+	def Lv(self):
+		return self.state.lv
+
+	@property
+	def Vg(self):
+		return self.state.vg_path

daemons/lvmdbusd/refresh.py

@@ -0,0 +1,45 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+# Try and minimize the refreshes we do.
+
+import threading
+from .request import RequestEntry
+from . import cfg
+from . import utils
+
+_rlock = threading.RLock()
+_count = 0
+
+
+def handle_external_event(command):
+	utils.log_debug("External event: '%s'" % command)
+	event_complete()
+	cfg.load()
+
+
+def event_add(params):
+	global _rlock
+	global _count
+	with _rlock:
+		if _count == 0:
+			_count += 1
+			r = RequestEntry(
+				-1, handle_external_event,
+				params, None, None, False)
+			cfg.worker_q.put(r)
+
+
+def event_complete():
+	global _rlock
+	global _count
+	with _rlock:
+		if _count > 0:
+			_count -= 1
+		return _count

daemons/lvmdbusd/request.py

@@ -0,0 +1,140 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import threading
+# noinspection PyUnresolvedReferences
+from gi.repository import GObject
+from .job import Job
+from . import cfg
+import traceback
+from .utils import log_error
+
+
+class RequestEntry(object):
+	def __init__(self, tmo, method, arguments, cb, cb_error,
+			return_tuple=True):
+		self.tmo = tmo
+		self.method = method
+		self.arguments = arguments
+		self.cb = cb
+		self.cb_error = cb_error
+
+		self.timer_id = -1
+		self.lock = threading.RLock()
+		self.done = False
+		self._result = None
+		self._job = False
+		self._rc = 0
+		self._rc_error = None
+		self._return_tuple = return_tuple
+
+		if self.tmo < 0:
+			# Client is willing to block forever
+			pass
+		elif tmo == 0:
+			self._return_job()
+		else:
+			self.timer_id = GObject.timeout_add_seconds(
+				tmo, RequestEntry._request_timeout, self)
+
+	@staticmethod
+	def _request_timeout(r):
+		"""
+		Method which gets called when the timer runs out!
+		:param r:  RequestEntry which timed out
+		:return: Nothing
+		"""
+		r.timer_expired()
+
+	def _return_job(self):
+		self._job = Job(self)
+		cfg.om.register_object(self._job, True)
+		if self._return_tuple:
+			self.cb(('/', self._job.dbus_object_path()))
+		else:
+			self.cb(self._job.dbus_object_path())
+
+	def run_cmd(self):
+		try:
+			result = self.method(*self.arguments)
+			self.register_result(result)
+		except Exception:
+			# Use the request entry to return the result as the client may
+			# have gotten a job by the time we hit an error
+			# Lets get the stacktrace and set that to the error message
+			st = traceback.format_exc()
+			log_error("Exception returned to client: \n%s" % st)
+			self.register_error(-1, st)
+
+	def is_done(self):
+		with self.lock:
+			rc = self.done
+		return rc
+
+	def get_errors(self):
+		with self.lock:
+			return (self._rc, self._rc_error)
+
+	def result(self):
+		with self.lock:
+			if self.done:
+				return self._result
+			return '/'
+
+	def _reg_ending(self, result, error_rc=0, error=None):
+		with self.lock:
+			self.done = True
+			if self.timer_id != -1:
+				# Try to prevent the timer from firing
+				GObject.source_remove(self.timer_id)
+
+			self._result = result
+			self._rc = error_rc
+			self._rc_error = error
+
+			if not self._job:
+				# We finished and there is no job, so return result or error
+				# now!
+				# Note: If we don't have a valid cb or cbe, this indicates a
+				# request that doesn't need a response as we already returned
+				# one before the request was processed.
+				if error_rc == 0:
+					if self.cb:
+						if self._return_tuple:
+							self.cb((result, '/'))
+						else:
+							self.cb(result)
+				else:
+					if self.cb_error:
+						self.cb_error(self._rc_error)
+			else:
+				# We have a job and it's complete, indicate that it's done.
+				# TODO: We need to signal the job is done too.
+				self._job.Complete = True
+				self._job = None
+
+	def register_error(self, error_rc, error):
+		self._reg_ending(None, error_rc, error)
+
+	def register_result(self, result):
+		self._reg_ending(result)
+
+	def timer_expired(self):
+		with self.lock:
+			# Set the timer back to -1 as we will get a warning if we try
+			# to remove a timer that doesn't exist
+			self.timer_id = -1
+			if not self.done:
+				# Create dbus job object and return path to caller
+				self._return_job()
+			else:
+				# The job is done, we have nothing to do
+				pass
+
+		return False

daemons/lvmdbusd/state.py

@@ -0,0 +1,27 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from abc import ABCMeta, abstractmethod
+
+
+class State(object, metaclass=ABCMeta):
+	@abstractmethod
+	def lvm_id(self):
+		pass
+
+	@abstractmethod
+	def identifiers(self):
+		pass
+
+	@abstractmethod
+	def create_dbus_object(self, path):
+		pass
+
+	def __str__(self):
+		return '*****\n' + str(self.__dict__) + '\n******\n'

daemons/lvmdbusd/udevwatch.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import pyudev
+from .refresh import event_add
+from . import cfg
+
+observer = None
+
+
+# noinspection PyUnusedLocal
+def filter_event(action, device):
+	# Filter for events of interest and add a request object to be processed
+	# when appropriate.
+	refresh = False
+
+	if '.ID_FS_TYPE_NEW' in device:
+		fs_type_new = device['.ID_FS_TYPE_NEW']
+
+		if 'LVM' in fs_type_new:
+			refresh = True
+		elif fs_type_new == '':
+			# Check to see if the device was one we knew about
+			if 'DEVNAME' in device:
+				found = cfg.om.get_object_by_lvm_id(device['DEVNAME'])
+				if found:
+					refresh = True
+
+	if 'DM_LV_NAME' in device:
+		refresh = True
+
+	if refresh:
+		event_add(('udev',))
+
+
+def add():
+	global observer
+	context = pyudev.Context()
+	monitor = pyudev.Monitor.from_netlink(context)
+	monitor.filter_by('block')
+	observer = pyudev.MonitorObserver(monitor, filter_event)
+	observer.start()
+
+
+def remove():
+	global observer
+	observer.stop()
+	observer = None

daemons/lvmdbusd/utils.py

@@ -0,0 +1,484 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import xml.etree.ElementTree as Et
+import sys
+import inspect
+import ctypes
+import os
+import string
+
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+
+try:
+	from . import cfg
+except SystemError:
+	import cfg
+
+STDOUT_TTY = os.isatty(sys.stdout.fileno())
+
+
+def rtype(dbus_type):
+	"""
+	Decorator making sure that the decorated function returns a value of
+	specified type.
+	:param dbus_type: The specific dbus type to return value as
+	"""
+
+	def decorator(fn):
+		def decorated(*args, **kwargs):
+			return dbus_type(fn(*args, **kwargs))
+
+		return decorated
+
+	return decorator
+
+
+# Field is expected to be a number, handle the corner cases when parsing
+@rtype(dbus.UInt64)
+def n(v):
+	if not v:
+		return 0
+	return int(float(v))
+
+
+@rtype(dbus.UInt32)
+def n32(v):
+	if not v:
+		return 0
+	return int(float(v))
+
+
+# noinspection PyProtectedMember
+def init_class_from_arguments(obj_instance):
+	for k, v in list(sys._getframe(1).f_locals.items()):
+		if k != 'self':
+			nt = k
+
+			# If the current attribute has a value, but the incoming does
+			# not, don't overwrite it.  Otherwise the default values on the
+			# property decorator don't work as expected.
+			cur = getattr(obj_instance, nt, v)
+
+			# print 'Init class %s = %s' % (nt, str(v))
+			if not (cur and len(str(cur)) and (v is None or len(str(v))) == 0):
+				setattr(obj_instance, nt, v)
+
+
+def get_properties(f):
+	"""
+	Walks through an object instance or it's parent class(es) and determines
+	which attributes are properties and if they were created to be used for
+	dbus.
+	:param f:   Object to inspect
+	:return:    A dictionary of tuples with each tuple being:
+				0 = An array of dicts with the keys being: p_t, p_name,
+				p_access(type, name, access)
+				1 = Hash of property names and current value
+	"""
+	interfaces = dict()
+
+	for c in inspect.getmro(f.__class__):
+
+		h = vars(c)
+		for p, value in h.items():
+			if isinstance(value, property):
+				# We found a property, see if it has a metadata type
+				key = attribute_type_name(p)
+				if key in h:
+					interface = h[key][1]
+
+					if interface not in interfaces:
+						interfaces[interface] = ([], {})
+
+					access = ''
+					if getattr(f.__class__, p).fget:
+						access += 'read'
+					if getattr(f.__class__, p).fset:
+						access += 'write'
+
+					interfaces[interface][0].append(
+						dict(
+							p_t=getattr(f, key)[0],
+							p_name=p,
+							p_access=access))
+
+					interfaces[interface][1][p] = getattr(f, p)
+
+	return interfaces
+
+
+def get_object_property_diff(o_prop, n_prop):
+	"""
+	Walk through each object properties and report what has changed and with
+	the new values
+	:param o_prop:   Old keys/values
+	:param n_prop:   New keys/values
+	:return: hash of properties that have changed and their new value
+	"""
+	rc = {}
+
+	for intf_k, intf_v in o_prop.items():
+		for k, v in list(intf_v[1].items()):
+			# print('Comparing %s:%s to %s:%s' %
+			#      (k, o_prop[intf_k][1][k], k, str(n_prop[intf_k][1][k])))
+			if o_prop[intf_k][1][k] != n_prop[intf_k][1][k]:
+				new_value = n_prop[intf_k][1][k]
+
+				if intf_k not in rc:
+					rc[intf_k] = dict()
+
+				rc[intf_k][k] = new_value
+	return rc
+
+
+def add_properties(xml, interface, props):
+	"""
+	Given xml that describes the interface, add property values to the XML
+	for the specified interface.
+	:param xml:         XML to edit
+	:param interface:   Interface to add the properties too
+	:param props:       Output from get_properties
+	:return: updated XML string
+	"""
+	root = Et.fromstring(xml)
+
+	if props:
+
+		for c in root:
+			# print c.attrib['name']
+			if c.attrib['name'] == interface:
+				for p in props:
+					temp = '<property type="%s" name="%s" access="%s"/>\n' % \
+						(p['p_t'], p['p_name'], p['p_access'])
+					c.append(Et.fromstring(temp))
+
+		return Et.tostring(root, encoding='utf8')
+	return xml
+
+
+def attribute_type_name(name):
+	"""
+	Given the property name, return string of the attribute type
+	:param name:
+	:return:
+	"""
+	return "_%s_meta" % name
+
+
+_type_map = dict(
+	s=dbus.String,
+	o=dbus.ObjectPath,
+	t=dbus.UInt64,
+	x=dbus.Int64,
+	u=dbus.UInt32,
+	i=dbus.Int32,
+	n=dbus.Int16,
+	q=dbus.UInt16,
+	d=dbus.Double,
+	y=dbus.Byte,
+	b=dbus.Boolean)
+
+
+def _pass_through(v):
+	"""
+	If we have something which is not a simple type we return the original
+	value un-wrapped.
+	:param v:
+	:return:
+	"""
+	return v
+
+
+def _dbus_type(t, value):
+	return _type_map.get(t, _pass_through)(value)
+
+
+def dbus_property(interface_name, name, dbus_type, doc=None):
+	"""
+	Creates the get/set properties for the given name.  It assumes that the
+	actual attribute is '_' + name and the attribute metadata is stuffed in
+	_name_type.
+
+	There is probably a better way todo this.
+	:param interface_name:  Dbus interface this property is associated with
+	:param name:            Name of property
+	:param dbus_type:       dbus string type eg. s,t,i,x
+	:param doc:             Python __doc__ for the property
+	:return:
+	"""
+	attribute_name = '_' + name
+
+	def getter(self):
+		t = getattr(self, attribute_name + '_meta')[0]
+		return _dbus_type(t, getattr(self.state, attribute_name[1:]))
+
+	prop = property(getter, None, None, doc)
+
+	def decorator(cls):
+		setattr(cls, attribute_name + '_meta', (dbus_type, interface_name))
+		setattr(cls, name, prop)
+		return cls
+
+	return decorator
+
+
+def parse_tags(tags):
+	if len(tags):
+		if ',' in tags:
+			return tags.split(',')
+		return sorted([tags])
+	return dbus.Array([], signature='s')
+
+
+def _common_log(msg, *attributes):
+	cfg.stdout_lock.acquire()
+	tid = ctypes.CDLL('libc.so.6').syscall(186)
+
+	msg = "%d:%d - %s" % (os.getpid(), tid, msg)
+
+	if STDOUT_TTY and attributes:
+		print(color(msg, *attributes))
+	else:
+		print(msg)
+
+	cfg.stdout_lock.release()
+	sys.stdout.flush()
+
+
+# Serializes access to stdout to prevent interleaved output
+# @param msg    Message to output to stdout
+# @return None
+def log_debug(msg, *attributes):
+	if cfg.DEBUG:
+		_common_log(msg, *attributes)
+
+
+def log_error(msg, *attributes):
+	_common_log(msg, *attributes)
+
+
+# noinspection PyUnusedLocal
+def handler(signum, frame):
+	cfg.run.value = 0
+	log_debug('Signal handler called with signal %d' % signum)
+	if cfg.loop is not None:
+		cfg.loop.quit()
+
+
+def pv_obj_path_generate():
+	return cfg.PV_OBJ_PATH + "/%d" % next(cfg.pv_id)
+
+
+def vg_obj_path_generate():
+	return cfg.VG_OBJ_PATH + "/%d" % next(cfg.vg_id)
+
+
+def lv_object_path_method(name, meta):
+	if name[0] == '[':
+		return _hidden_lv_obj_path_generate
+	elif meta[0][0] == 't':
+		return _thin_pool_obj_path_generate
+	elif meta[0][0] == 'C' and 'pool' in meta[1]:
+		return _cache_pool_obj_path_generate
+
+	return _lv_obj_path_generate
+
+
+# Note: None of the individual LV path generate functions should be called
+# directly, they should only be dispatched through lv_object_path_method
+
+def _lv_obj_path_generate():
+	return cfg.LV_OBJ_PATH + "/%d" % next(cfg.lv_id)
+
+
+def _thin_pool_obj_path_generate():
+	return cfg.THIN_POOL_PATH + "/%d" % next(cfg.thin_id)
+
+
+def _cache_pool_obj_path_generate():
+	return cfg.CACHE_POOL_PATH + "/%d" % next(cfg.cache_pool_id)
+
+
+def _hidden_lv_obj_path_generate():
+	return cfg.HIDDEN_LV_PATH + "/%d" % next(cfg.hidden_lv)
+
+
+def job_obj_path_generate():
+	return cfg.JOB_OBJ_PATH + "/%d" % next(cfg.job_id)
+
+
+def color(text, *user_styles):
+	styles = {
+		# styles
+		'reset': '\033[0m',
+		'bold': '\033[01m',
+		'disabled': '\033[02m',
+		'underline': '\033[04m',
+		'reverse': '\033[07m',
+		'strike_through': '\033[09m',
+		'invisible': '\033[08m',
+		# text colors
+		'fg_black': '\033[30m',
+		'fg_red': '\033[31m',
+		'fg_green': '\033[32m',
+		'fg_orange': '\033[33m',
+		'fg_blue': '\033[34m',
+		'fg_purple': '\033[35m',
+		'fg_cyan': '\033[36m',
+		'fg_light_grey': '\033[37m',
+		'fg_dark_grey': '\033[90m',
+		'fg_light_red': '\033[91m',
+		'fg_light_green': '\033[92m',
+		'fg_yellow': '\033[93m',
+		'fg_light_blue': '\033[94m',
+		'fg_pink': '\033[95m',
+		'fg_light_cyan': '\033[96m',
+		# background colors
+		'bg_black': '\033[40m',
+		'bg_red': '\033[41m',
+		'bg_green': '\033[42m',
+		'bg_orange': '\033[43m',
+		'bg_blue': '\033[44m',
+		'bg_purple': '\033[45m',
+		'bg_cyan': '\033[46m',
+		'bg_light_grey': '\033[47m'
+	}
+
+	color_text = ''
+	for style in user_styles:
+		try:
+			color_text += styles[style]
+		except KeyError:
+			return 'def color: parameter {} does not exist'.format(style)
+	color_text += text
+	return '\033[0m{0}\033[0m'.format(color_text)
+
+
+def pv_range_append(cmd, device, start, end):
+	if (start, end) == (0, 0):
+		cmd.append(device)
+	else:
+		if start != 0 and end == 0:
+			cmd.append("%s:%d-" % (device, start))
+		else:
+			cmd.append(
+				"%s:%d-%d" %
+				(device, start, end))
+
+
+def pv_dest_ranges(cmd, pv_dest_range_list):
+	if len(pv_dest_range_list):
+		for i in pv_dest_range_list:
+			pv_range_append(cmd, *i)
+
+
+def round_size(size_bytes):
+	bs = 512
+	remainder = size_bytes % bs
+	if not remainder:
+		return size_bytes
+	return size_bytes + bs - remainder
+
+
+_ALLOWABLE_CH = string.ascii_letters + string.digits + '#+.:=@_\/%'
+_ALLOWABLE_CH_SET = set(_ALLOWABLE_CH)
+
+_ALLOWABLE_VG_LV_CH = string.ascii_letters + string.digits + '.-_+'
+_ALLOWABLE_VG_LV_CH_SET = set(_ALLOWABLE_VG_LV_CH)
+_LV_NAME_RESERVED = ("_cdata", "_cmeta", "_corig", "_mimage", "_mlog",
+	"_pmspare", "_rimage", "_rmeta", "_tdata", "_tmeta", "_vorigin")
+
+# Tags can have the characters, based on the code
+# a-zA-Z0-9._-+/=!:&#
+_ALLOWABLE_TAG_CH = string.ascii_letters + string.digits + "._-+/=!:&#"
+_ALLOWABLE_TAG_CH_SET = set(_ALLOWABLE_TAG_CH)
+
+
+def _allowable_tag(tag_name):
+	# LVM should impose a length restriction
+	return set(tag_name) <= _ALLOWABLE_TAG_CH_SET
+
+
+def _allowable_vg_name(vg_name):
+	if vg_name is None:
+		raise ValueError("VG name is None or empty")
+
+	vg_len = len(vg_name)
+	if vg_len == 0 or vg_len > 127:
+		raise ValueError("VG name (%s) length (%d) not in the domain 1..127" %
+			(vg_name, vg_len))
+
+	if not set(vg_name) <= _ALLOWABLE_VG_LV_CH_SET:
+		raise ValueError("VG name (%s) contains invalid character, "
+			"allowable set(%s)" % (vg_name, _ALLOWABLE_VG_LV_CH))
+
+	if vg_name == "." or vg_name == "..":
+		raise ValueError('VG name (%s) cannot be "." or ".."' % (vg_name))
+
+
+def _allowable_lv_name(vg_name, lv_name):
+
+	if lv_name is None:
+		raise ValueError("LV name is None or empty")
+
+	lv_len = len(lv_name)
+
+	# This length is derived from empirical testing
+	if lv_len == 0 or (len(vg_name) + lv_len) > 125:
+		raise ValueError("LV name (%s) length (%d) + VG name length "
+			"not in the domain 1..125" % (lv_name, lv_len))
+
+	if not set(lv_name) <= _ALLOWABLE_VG_LV_CH_SET:
+		raise ValueError("LV name (%s) contains invalid character, "
+			"allowable (%s)" % (lv_name, _ALLOWABLE_VG_LV_CH))
+
+	if any(x in lv_name for x in _LV_NAME_RESERVED):
+		raise ValueError("LV name (%s) contains a reserved word, "
+			"reserved set(%s)" % (lv_name, str(_LV_NAME_RESERVED)))
+
+	if lv_name.startswith("snapshot") or lv_name.startswith("pvmove"):
+		raise ValueError("LV name (%s) starts with a reserved word, "
+			"reserved set(%s)" % (lv_name, str(["snapshot", "pvmove"])))
+
+	if lv_name[0] == '-':
+		raise ValueError("LV name (%s) cannot start with a '-' "
+				"character" % lv_name)
+
+
+def validate_device_path(interface, device):
+	if not set(device) <= _ALLOWABLE_CH_SET:
+		raise dbus.exceptions.DBusException(
+			interface, 'Device path (%s) has invalid characters, '
+			'allowable (%s)' % (device, _ALLOWABLE_CH))
+
+
+def validate_vg_name(interface, vg_name):
+	try:
+		_allowable_vg_name(vg_name)
+	except ValueError as ve:
+		raise dbus.exceptions.DBusException(
+			interface, str(ve))
+
+
+def validate_lv_name(interface, vg_name, lv_name):
+	try:
+		_allowable_lv_name(vg_name, lv_name)
+	except ValueError as ve:
+		raise dbus.exceptions.DBusException(
+			interface, str(ve))
+
+
+def validate_tag(interface, tag):
+	if not _allowable_tag(tag):
+		raise dbus.exceptions.DBusException(
+			interface, 'tag (%s) contains invalid character, allowable set(%s)'
+			% (tag, _ALLOWABLE_TAG_CH))

daemons/lvmdbusd/vg.py

@@ -0,0 +1,955 @@
+# Copyright (C) 2015-2016 Red Hat, Inc. All rights reserved.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+from .automatedproperties import AutomatedProperties
+
+from . import utils
+from .utils import pv_obj_path_generate, vg_obj_path_generate, n
+import dbus
+from . import cfg
+from .cfg import VG_INTERFACE
+from . import cmdhandler
+from .request import RequestEntry
+from .loader import common
+from .state import State
+from . import background
+from .utils import round_size
+
+
+# noinspection PyUnusedLocal
+def vgs_state_retrieve(selection, cache_refresh=True):
+	rc = []
+
+	if cache_refresh:
+		cfg.db.refresh()
+
+	for v in cfg.db.fetch_vgs(selection):
+		rc.append(
+			VgState(
+				v['vg_uuid'], v['vg_name'], v['vg_fmt'], n(v['vg_size']),
+				n(v['vg_free']), v['vg_sysid'], n(v['vg_extent_size']),
+				n(v['vg_extent_count']), n(v['vg_free_count']),
+				v['vg_profile'], n(v['max_lv']), n(v['max_pv']),
+				n(v['pv_count']), n(v['lv_count']), n(v['snap_count']),
+				n(v['vg_seqno']), n(v['vg_mda_count']),
+				n(v['vg_mda_free']), n(v['vg_mda_size']),
+				n(v['vg_mda_used_count']), v['vg_attr'], v['vg_tags']))
+	return rc
+
+
+def load_vgs(vg_specific=None, object_path=None, refresh=False,
+		emit_signal=False, cache_refresh=True):
+	return common(vgs_state_retrieve, (Vg,), vg_specific, object_path, refresh,
+					emit_signal, cache_refresh)
+
+
+# noinspection PyPep8Naming,PyUnresolvedReferences,PyUnusedLocal
+class VgState(State):
+	@property
+	def lvm_id(self):
+		return self.Name
+
+	def identifiers(self):
+		return (self.Uuid, self.Name)
+
+	def _lv_paths_build(self):
+		rc = []
+		for lv in cfg.db.lvs_in_vg(self.Uuid):
+			(lv_name, meta, lv_uuid) = lv
+			full_name = "%s/%s" % (self.Name, lv_name)
+
+			gen = utils.lv_object_path_method(lv_name, meta)
+
+			lv_path = cfg.om.get_object_path_by_lvm_id(
+				lv_uuid, full_name, gen)
+			rc.append(lv_path)
+		return dbus.Array(rc, signature='o')
+
+	def _pv_paths_build(self):
+		rc = []
+		for p in cfg.db.pvs_in_vg(self.Uuid):
+			(pv_name, pv_uuid) = p
+			rc.append(cfg.om.get_object_path_by_lvm_id(
+				pv_uuid, pv_name, pv_obj_path_generate))
+		return dbus.Array(rc, signature='o')
+
+	def __init__(self, Uuid, Name, Fmt,
+			SizeBytes, FreeBytes, SysId, ExtentSizeBytes,
+			ExtentCount, FreeCount, Profile, MaxLv, MaxPv, PvCount,
+			LvCount, SnapCount, Seqno, MdaCount, MdaFree,
+			MdaSizeBytes, MdaUsedCount, attr, tags):
+		utils.init_class_from_arguments(self)
+		self.Pvs = self._pv_paths_build()
+		self.Lvs = self._lv_paths_build()
+
+	def create_dbus_object(self, path):
+		if not path:
+			path = cfg.om.get_object_path_by_lvm_id(
+				self.Uuid, self.Name, vg_obj_path_generate)
+		return Vg(path, self)
+
+	# noinspection PyMethodMayBeStatic
+	def creation_signature(self):
+		return (Vg, vg_obj_path_generate)
+
+
+# noinspection PyPep8Naming
+@utils.dbus_property(VG_INTERFACE, 'Uuid', 's')
+@utils.dbus_property(VG_INTERFACE, 'Name', 's')
+@utils.dbus_property(VG_INTERFACE, 'Fmt', 's')
+@utils.dbus_property(VG_INTERFACE, 'SizeBytes', 't', 0)
+@utils.dbus_property(VG_INTERFACE, 'FreeBytes', 't', 0)
+@utils.dbus_property(VG_INTERFACE, 'SysId', 's')
+@utils.dbus_property(VG_INTERFACE, 'ExtentSizeBytes', 't')
+@utils.dbus_property(VG_INTERFACE, 'ExtentCount', 't')
+@utils.dbus_property(VG_INTERFACE, 'FreeCount', 't')
+@utils.dbus_property(VG_INTERFACE, 'Profile', 's')
+@utils.dbus_property(VG_INTERFACE, 'MaxLv', 't')
+@utils.dbus_property(VG_INTERFACE, 'MaxPv', 't')
+@utils.dbus_property(VG_INTERFACE, 'PvCount', 't')
+@utils.dbus_property(VG_INTERFACE, 'LvCount', 't')
+@utils.dbus_property(VG_INTERFACE, 'SnapCount', 't')
+@utils.dbus_property(VG_INTERFACE, 'Seqno', 't')
+@utils.dbus_property(VG_INTERFACE, 'MdaCount', 't')
+@utils.dbus_property(VG_INTERFACE, 'MdaFree', 't')
+@utils.dbus_property(VG_INTERFACE, 'MdaSizeBytes', 't')
+@utils.dbus_property(VG_INTERFACE, 'MdaUsedCount', 't')
+class Vg(AutomatedProperties):
+	_Tags_meta = ("as", VG_INTERFACE)
+	_Pvs_meta = ("ao", VG_INTERFACE)
+	_Lvs_meta = ("ao", VG_INTERFACE)
+	_Writeable_meta = ("b", VG_INTERFACE)
+	_Readable_meta = ("b", VG_INTERFACE)
+	_Resizeable_meta = ("b", VG_INTERFACE)
+	_Exportable_meta = ('b', VG_INTERFACE)
+	_Partial_meta = ('b', VG_INTERFACE)
+	_AllocContiguous_meta = ('b', VG_INTERFACE)
+	_AllocCling_meta = ('b', VG_INTERFACE)
+	_AllocNormal_meta = ('b', VG_INTERFACE)
+	_AllocAnywhere_meta = ('b', VG_INTERFACE)
+	_Clustered_meta = ('b', VG_INTERFACE)
+
+	# noinspection PyUnusedLocal,PyPep8Naming
+	def __init__(self, object_path, object_state):
+		super(Vg, self).__init__(object_path, vgs_state_retrieve)
+		self.set_interface(VG_INTERFACE)
+		self._object_path = object_path
+		self.state = object_state
+
+	@staticmethod
+	def fetch_new_lv(vg_name, lv_name):
+		full_name = "%s/%s" % (vg_name, lv_name)
+
+		cfg.load()
+		l = cfg.om.get_object_by_lvm_id(full_name)
+		created_lv = l.dbus_object_path()
+
+		return created_lv
+
+	@staticmethod
+	def _rename(uuid, vg_name, new_name, rename_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.vg_rename(vg_name, new_name,
+												rename_options)
+			if rc == 0:
+				cfg.load()
+			else:
+				# Need to work on error handling, need consistent
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='sia{sv}', out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Rename(self, name, tmo, rename_options, cb, cbe):
+		utils.validate_vg_name(VG_INTERFACE, name)
+		r = RequestEntry(tmo, Vg._rename,
+				(self.state.Uuid, self.state.lvm_id, name,
+				rename_options), cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _remove(uuid, vg_name, remove_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			# Remove the VG, if successful then remove from the model
+			rc, out, err = cmdhandler.vg_remove(vg_name, remove_options)
+
+			if rc == 0:
+				# Remove the VG
+				cfg.om.remove_object(dbo, True)
+
+				# If an LV has hidden LVs, things can get quite involved,
+				# especially if it's the last thin pool to get removed, so
+				# lets refresh all
+				cfg.load()
+
+			else:
+				# Need to work on error handling, need consistent
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='ia{sv}', out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Remove(self, tmo, remove_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._remove,
+				(self.state.Uuid, self.state.lvm_id, remove_options),
+				cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _change(uuid, vg_name, change_options):
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.vg_change(change_options, vg_name)
+
+			# To use an example with d-feet (Method input)
+			# {"activate": __import__('gi.repository.GLib', globals(),
+			# locals(), ['Variant']).Variant("s", "n")}
+
+			if rc == 0:
+				cfg.load()
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+		return '/'
+
+	# TODO: This should be broken into a number of different methods
+	# instead of having one method that takes a hash for parameters.  Some of
+	# the changes that vgchange does works on entire system, not just a
+	# specfic vg, thus that should be in the Manager interface.
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='ia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Change(self, tmo, change_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._change,
+				(self.state.Uuid, self.state.lvm_id, change_options),
+				cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _reduce(uuid, vg_name, missing, pv_object_paths, reduce_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			pv_devices = []
+
+			# If pv_object_paths is not empty, then get the device paths
+			if pv_object_paths and len(pv_object_paths) > 0:
+				for pv_op in pv_object_paths:
+					pv = cfg.om.get_object_by_path(pv_op)
+					if pv:
+						pv_devices.append(pv.lvm_id)
+					else:
+						raise dbus.exceptions.DBusException(
+							VG_INTERFACE,
+							'PV Object path not found = %s!' % pv_op)
+
+			rc, out, err = cmdhandler.vg_reduce(vg_name, missing, pv_devices,
+												reduce_options)
+			if rc == 0:
+				cfg.load()
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE, 'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='baoia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Reduce(self, missing, pv_object_paths, tmo, reduce_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._reduce,
+				(self.state.Uuid, self.state.lvm_id, missing,
+				pv_object_paths, reduce_options), cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _extend(uuid, vg_name, pv_object_paths, extend_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			extend_devices = []
+
+			for i in pv_object_paths:
+				pv = cfg.om.get_object_by_path(i)
+				if pv:
+					extend_devices.append(pv.lvm_id)
+				else:
+					raise dbus.exceptions.DBusException(
+						VG_INTERFACE, 'PV Object path not found = %s!' % i)
+
+			if len(extend_devices):
+				rc, out, err = cmdhandler.vg_extend(vg_name, extend_devices,
+													extend_options)
+				if rc == 0:
+					cfg.load()
+				else:
+					raise dbus.exceptions.DBusException(
+						VG_INTERFACE,
+						'Exit code %s, stderr = %s' % (str(rc), err))
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE, 'No pv_object_paths provided!')
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+		return '/'
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='aoia{sv}', out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Extend(self, pv_object_paths, tmo, extend_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._extend,
+				(self.state.Uuid, self.state.lvm_id, pv_object_paths,
+				extend_options),
+				cb, cbe, False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='o(tt)a(ott)ia{sv}',
+		out_signature='o')
+	def Move(self, pv_src_obj, pv_source_range, pv_dests_and_ranges,
+			tmo, move_options):
+		return background.move(
+			VG_INTERFACE, None, pv_src_obj, pv_source_range,
+			pv_dests_and_ranges, move_options, tmo)
+
+	@staticmethod
+	def _lv_create(uuid, vg_name, name, size_bytes, pv_dests_and_ranges,
+			create_options):
+		# Make sure we have a dbus object representing it
+		pv_dests = []
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			if len(pv_dests_and_ranges):
+				for pr in pv_dests_and_ranges:
+					pv_dbus_obj = cfg.om.get_object_by_path(pr[0])
+					if not pv_dbus_obj:
+						raise dbus.exceptions.DBusException(
+							VG_INTERFACE,
+							'PV Destination (%s) not found' % pr[0])
+
+					pv_dests.append((pv_dbus_obj.lvm_id, pr[1], pr[2]))
+
+			rc, out, err = cmdhandler.vg_lv_create(
+				vg_name, create_options, name, size_bytes, pv_dests)
+
+			if rc == 0:
+				return Vg.fetch_new_lv(vg_name, name)
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='sta(ott)ia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def LvCreate(self, name, size_bytes, pv_dests_and_ranges,
+			tmo, create_options, cb, cbe):
+		"""
+		This one it for the advanced users that want to roll their own
+		:param name:            Name of the LV
+		:param size_bytes:      Size of LV in bytes
+		:param pv_dests_and_ranges:   Optional array of PV object paths and
+									ranges
+		:param tmo: -1 == Wait forever, 0 == return job immediately, > 0 ==
+							willing to wait that number of seconds before
+							getting a job
+		:param create_options:  hash of key/value pairs
+		:param cb: Internal, not accessible by dbus API user
+		:param cbe: Internal, not accessible by dbus API user
+		:return: (oo) First object path is newly created object, second is
+					job object path if created.  Each == '/' when it doesn't
+					apply.
+		"""
+		utils.validate_lv_name(VG_INTERFACE, self.Name, name)
+		r = RequestEntry(tmo, Vg._lv_create,
+				(self.state.Uuid, self.state.lvm_id,
+				name, round_size(size_bytes), pv_dests_and_ranges,
+				create_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _lv_create_linear(uuid, vg_name, name, size_bytes,
+			thin_pool, create_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.vg_lv_create_linear(
+				vg_name, create_options, name, size_bytes, thin_pool)
+
+			if rc == 0:
+				created_lv = Vg.fetch_new_lv(vg_name, name)
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+		return created_lv
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='stbia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def LvCreateLinear(self, name, size_bytes,
+			thin_pool, tmo, create_options, cb, cbe):
+		utils.validate_lv_name(VG_INTERFACE, self.Name, name)
+		r = RequestEntry(tmo, Vg._lv_create_linear,
+						(self.state.Uuid, self.state.lvm_id,
+						name, round_size(size_bytes), thin_pool,
+						create_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _lv_create_striped(uuid, vg_name, name, size_bytes, num_stripes,
+			stripe_size_kb, thin_pool, create_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.vg_lv_create_striped(
+				vg_name, create_options, name, size_bytes,
+				num_stripes, stripe_size_kb, thin_pool)
+			if rc == 0:
+				created_lv = Vg.fetch_new_lv(vg_name, name)
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE, 'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+		return created_lv
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='stuubia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def LvCreateStriped(self, name, size_bytes, num_stripes,
+						stripe_size_kb, thin_pool, tmo, create_options,
+						cb, cbe):
+		utils.validate_lv_name(VG_INTERFACE, self.Name, name)
+		r = RequestEntry(
+				tmo, Vg._lv_create_striped,
+				(self.state.Uuid, self.state.lvm_id, name,
+				round_size(size_bytes), num_stripes, stripe_size_kb,
+				thin_pool, create_options),
+				cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _lv_create_mirror(uuid, vg_name, name, size_bytes,
+			num_copies, create_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.vg_lv_create_mirror(
+				vg_name, create_options, name, size_bytes, num_copies)
+			if rc == 0:
+				created_lv = Vg.fetch_new_lv(vg_name, name)
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+		return created_lv
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='stuia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def LvCreateMirror(self, name, size_bytes, num_copies,
+			tmo, create_options, cb, cbe):
+		utils.validate_lv_name(VG_INTERFACE, self.Name, name)
+		r = RequestEntry(
+			tmo, Vg._lv_create_mirror,
+			(self.state.Uuid, self.state.lvm_id, name,
+			round_size(size_bytes), num_copies,
+			create_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _lv_create_raid(uuid, vg_name, name, raid_type, size_bytes,
+						num_stripes, stripe_size_kb, create_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.vg_lv_create_raid(
+				vg_name, create_options, name, raid_type, size_bytes,
+				num_stripes, stripe_size_kb)
+			if rc == 0:
+				created_lv = Vg.fetch_new_lv(vg_name, name)
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+		return created_lv
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='sstuuia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def LvCreateRaid(self, name, raid_type, size_bytes,
+			num_stripes, stripe_size_kb, tmo,
+			create_options, cb, cbe):
+		utils.validate_lv_name(VG_INTERFACE, self.Name, name)
+		r = RequestEntry(tmo, Vg._lv_create_raid,
+				(self.state.Uuid, self.state.lvm_id, name,
+				raid_type, round_size(size_bytes), num_stripes,
+				stripe_size_kb, create_options), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _create_pool(uuid, vg_name, meta_data_lv, data_lv,
+						create_options, create_method):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		# Retrieve the full names for the metadata and data lv
+		md = cfg.om.get_object_by_path(meta_data_lv)
+		data = cfg.om.get_object_by_path(data_lv)
+
+		if dbo and md and data:
+
+			new_name = data.Name
+
+			rc, out, err = create_method(
+				md.lv_full_name(), data.lv_full_name(), create_options)
+			if rc == 0:
+				cfg.om.remove_object(md, emit_signal=True)
+				cfg.om.remove_object(data, emit_signal=True)
+
+				cache_pool_lv = Vg.fetch_new_lv(vg_name, new_name)
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+
+		else:
+			msg = ""
+
+			if not dbo:
+				msg += 'VG with uuid %s and name %s not present!' % \
+					(uuid, vg_name)
+
+			if not md:
+				msg += 'Meta data LV with object path %s not present!' % \
+					(meta_data_lv)
+
+			if not data_lv:
+				msg += 'Data LV with object path %s not present!' % \
+					(meta_data_lv)
+
+			raise dbus.exceptions.DBusException(VG_INTERFACE, msg)
+
+		return cache_pool_lv
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='ooia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def CreateCachePool(self, meta_data_lv, data_lv, tmo, create_options,
+						cb, cbe):
+		r = RequestEntry(
+			tmo, Vg._create_pool,
+			(self.state.Uuid, self.state.lvm_id, meta_data_lv,
+			data_lv, create_options, cmdhandler.vg_create_cache_pool), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='ooia{sv}',
+		out_signature='(oo)',
+		async_callbacks=('cb', 'cbe'))
+	def CreateThinPool(self, meta_data_lv, data_lv, tmo, create_options,
+						cb, cbe):
+		r = RequestEntry(
+			tmo, Vg._create_pool,
+			(self.state.Uuid, self.state.lvm_id, meta_data_lv,
+			data_lv, create_options, cmdhandler.vg_create_thin_pool), cb, cbe)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _pv_add_rm_tags(uuid, vg_name, pv_object_paths, tags_add,
+						tags_del, tag_options):
+		pv_devices = []
+
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			# Check for existence of pv object paths
+			for p in pv_object_paths:
+				pv = cfg.om.get_object_by_path(p)
+				if pv:
+					pv_devices.append(pv.Name)
+				else:
+					raise dbus.exceptions.DBusException(
+						VG_INTERFACE, 'PV object path = %s not found' % p)
+
+			rc, out, err = cmdhandler.pv_tag(
+				pv_devices, tags_add, tags_del, tag_options)
+			if rc == 0:
+				cfg.load()
+				return '/'
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='aoasia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def PvTagsAdd(self, pvs, tags, tmo, tag_options, cb, cbe):
+
+		for t in tags:
+			utils.validate_tag(VG_INTERFACE, t)
+
+		r = RequestEntry(tmo, Vg._pv_add_rm_tags,
+				(self.state.Uuid, self.state.lvm_id,
+				pvs, tags, None, tag_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='aoasia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def PvTagsDel(self, pvs, tags, tmo, tag_options, cb, cbe):
+
+		for t in tags:
+			utils.validate_tag(VG_INTERFACE, t)
+
+		r = RequestEntry(
+			tmo, Vg._pv_add_rm_tags,
+			(self.state.Uuid, self.state.lvm_id,
+			pvs, None, tags, tag_options),
+			cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _vg_add_rm_tags(uuid, vg_name, tags_add, tags_del, tag_options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+
+			rc, out, err = cmdhandler.vg_tag(
+				vg_name, tags_add, tags_del, tag_options)
+			if rc == 0:
+				dbo.refresh()
+				return '/'
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='asia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def TagsAdd(self, tags, tmo, tag_options, cb, cbe):
+
+		for t in tags:
+			utils.validate_tag(VG_INTERFACE, t)
+
+		r = RequestEntry(tmo, Vg._vg_add_rm_tags,
+				(self.state.Uuid, self.state.lvm_id,
+				tags, None, tag_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='asia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def TagsDel(self, tags, tmo, tag_options, cb, cbe):
+
+		for t in tags:
+			utils.validate_tag(VG_INTERFACE, t)
+
+		r = RequestEntry(tmo, Vg._vg_add_rm_tags,
+				(self.state.Uuid, self.state.lvm_id,
+				None, tags, tag_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _vg_change_set(uuid, vg_name, method, value, options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = method(vg_name, value, options)
+			if rc == 0:
+				dbo.refresh()
+				return '/'
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='sia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def AllocationPolicySet(self, policy, tmo, policy_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._vg_change_set,
+				(self.state.Uuid, self.state.lvm_id,
+				cmdhandler.vg_allocation_policy,
+				policy, policy_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='tia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def MaxPvSet(self, number, tmo, max_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._vg_change_set,
+				(self.state.Uuid, self.state.lvm_id,
+				cmdhandler.vg_max_pv, number, max_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='ia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def UuidGenerate(self, tmo, options, cb, cbe):
+		r = RequestEntry(tmo, Vg._vg_change_set,
+				(self.state.Uuid, self.state.lvm_id,
+				cmdhandler.vg_uuid_gen, None, options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	def _attribute(self, pos, ch):
+		if self.state.attr[pos] == ch:
+			return True
+		return False
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='tia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def MaxLvSet(self, number, tmo, max_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._vg_change_set,
+				(self.state.Uuid, self.state.lvm_id,
+				cmdhandler.vg_max_lv, number, max_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@staticmethod
+	def _vg_activate_deactivate(uuid, vg_name, activate, control_flags,
+								options):
+		# Make sure we have a dbus object representing it
+		dbo = cfg.om.get_object_by_uuid_lvm_id(uuid, vg_name)
+
+		if dbo:
+			rc, out, err = cmdhandler.activate_deactivate(
+				'vgchange', vg_name, activate, control_flags, options)
+			if rc == 0:
+				cfg.load()
+				return '/'
+			else:
+				raise dbus.exceptions.DBusException(
+					VG_INTERFACE,
+					'Exit code %s, stderr = %s' % (str(rc), err))
+		else:
+			raise dbus.exceptions.DBusException(
+				VG_INTERFACE,
+				'VG with uuid %s and name %s not present!' %
+				(uuid, vg_name))
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='tia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Activate(self, control_flags, tmo, activate_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._vg_activate_deactivate,
+				(self.state.Uuid, self.state.lvm_id, True,
+				control_flags, activate_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@dbus.service.method(
+		dbus_interface=VG_INTERFACE,
+		in_signature='tia{sv}',
+		out_signature='o',
+		async_callbacks=('cb', 'cbe'))
+	def Deactivate(self, control_flags, tmo, activate_options, cb, cbe):
+		r = RequestEntry(tmo, Vg._vg_activate_deactivate,
+				(self.state.Uuid, self.state.lvm_id, False,
+				control_flags, activate_options),
+				cb, cbe, return_tuple=False)
+		cfg.worker_q.put(r)
+
+	@property
+	def Tags(self):
+		return utils.parse_tags(self.state.tags)
+
+	@property
+	def Pvs(self):
+		return self.state.Pvs
+
+	@property
+	def Lvs(self):
+		return self.state.Lvs
+
+	@property
+	def lvm_id(self):
+		return self.state.lvm_id
+
+	@property
+	def Writeable(self):
+		return self._attribute(0, 'w')
+
+	@property
+	def Readable(self):
+		return self._attribute(0, 'r')
+
+	@property
+	def Resizeable(self):
+		return self._attribute(1, 'z')
+
+	@property
+	def Exportable(self):
+		return self._attribute(2, 'x')
+
+	@property
+	def Partial(self):
+		return self._attribute(3, 'p')
+
+	@property
+	def AllocContiguous(self):
+		return self._attribute(4, 'c')
+
+	@property
+	def AllocCling(self):
+		return self._attribute(4, 'l')
+
+	@property
+	def AllocNormal(self):
+		return self._attribute(4, 'n')
+
+	@property
+	def AllocAnywhere(self):
+		return self._attribute(4, 'a')
+
+	@property
+	def Clustered(self):
+		return self._attribute(5, 'c')

daemons/lvmetad/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/lvmetad/lvmetactl.c

@@ -77,7 +77,7 @@ int main(int argc, char **argv)
 		val = atoi(argv[2]);
 
 		reply = daemon_send_simple(h, "set_global_info",
-					   "global_invalid = %d", val,
+					   "global_invalid = " FMTd64, (int64_t) val,
 					   "token = %s", "skip",
 					   NULL);
 		print_reply(reply);
@@ -106,21 +106,21 @@ int main(int argc, char **argv)
 			reply = daemon_send_simple(h, "set_vg_info",
 						   "uuid = %s", uuid,
 						   "name = %s", name,
-						   "version = %d", ver,
-						    "token = %s", "skip",
-						    NULL);
+						   "version = " FMTd64, (int64_t) ver,
+						   "token = %s", "skip",
+						   NULL);
 		} else if (uuid) {
 			reply = daemon_send_simple(h, "set_vg_info",
 						   "uuid = %s", uuid,
-						   "version = %d", ver,
-						    "token = %s", "skip",
-						    NULL);
+						   "version = " FMTd64, (int64_t) ver,
+						   "token = %s", "skip",
+						   NULL);
 		} else if (name) {
 			reply = daemon_send_simple(h, "set_vg_info",
 						   "name = %s", name,
-						   "version = %d", ver,
-						    "token = %s", "skip",
-						    NULL);
+						   "version = " FMTd64, (int64_t) ver,
+						   "token = %s", "skip",
+						   NULL);
 		} else {
 			printf("name or uuid required\n");
 			return -1;

daemons/lvmetad/lvmetad-client.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef _LVM_LVMETAD_CLIENT_H

daemons/lvmetad/testclient.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "tool.h"
 

daemons/lvmlockd/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/lvmlockd/lvmlockctl.c

@@ -18,7 +18,6 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <syslog.h>
-#include <sys/wait.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
@@ -456,7 +455,7 @@ static int do_able(const char *req_name)
 
 	reply = _lvmlockd_send(req_name,
 				"cmd = %s", "lvmlockctl",
-				"pid = %d", getpid(),
+				"pid = " FMTd64, (int64_t) getpid(),
 				"vg_name = %s", arg_vg_name,
 				NULL);
 
@@ -487,7 +486,7 @@ static int do_stop_lockspaces(void)
 
 	reply = _lvmlockd_send("stop_all",
 				"cmd = %s", "lvmlockctl",
-				"pid = %d", getpid(),
+				"pid = " FMTd64, (int64_t) getpid(),
 				"opts = %s", opts[0] ? opts : "none",
 				NULL);
 
@@ -522,7 +521,7 @@ static int do_kill(void)
 
 	reply = _lvmlockd_send("kill_vg",
 				"cmd = %s", "lvmlockctl",
-				"pid = %d", getpid(),
+				"pid = " FMTd64, (int64_t) getpid(),
 				"vg_name = %s", arg_vg_name,
 				NULL);
 
@@ -568,7 +567,7 @@ static int do_drop(void)
 
 	reply = _lvmlockd_send("drop_vg",
 				"cmd = %s", "lvmlockctl",
-				"pid = %d", getpid(),
+				"pid = " FMTd64, (int64_t) getpid(),
 				"vg_name = %s", arg_vg_name,
 				NULL);
 

daemons/lvmlockd/lvmlockd-core.c

@@ -16,7 +16,6 @@
 
 #include "daemon-io.h"
 #include "daemon-server.h"
-#include "daemon-log.h"
 #include "lvm-version.h"
 #include "lvmetad-client.h"
 #include "lvmlockd-client.h"
@@ -318,7 +317,7 @@ static void log_save_line(int len, char *line,
 	unsigned int w = *wrap;
 	int i;
 
-	if (len < LOG_DUMP_SIZE - p) {
+	if (len < (int) (LOG_DUMP_SIZE - p)) {
 		memcpy(log_buf + p, line, len);
 		p += len;
 
@@ -742,24 +741,6 @@ static const char *op_str(int x)
 	};
 }
 
-static const char *mode_str(int x)
-{
-	switch (x) {
-	case LD_LK_IV:
-		return "iv";
-	case LD_LK_UN:
-		return "un";
-	case LD_LK_NL:
-		return "nl";
-	case LD_LK_SH:
-		return "sh";
-	case LD_LK_EX:
-		return "ex";
-	default:
-		return ".";
-	};
-}
-
 int last_string_from_args(char *args_in, char *last)
 {
 	const char *args = args_in;
@@ -1021,6 +1002,43 @@ static void add_work_action(struct action *act)
 	pthread_mutex_unlock(&worker_mutex);
 }
 
+static daemon_reply send_lvmetad(const char *id, ...)
+{
+	daemon_reply reply;
+	va_list ap;
+	int retries = 0;
+
+	va_start(ap, id);
+
+	/*
+	 * mutex is used because all threads share a single
+	 * lvmetad connection/handle.
+	 */
+	pthread_mutex_lock(&lvmetad_mutex);
+retry:
+	reply = daemon_send_simple_v(lvmetad_handle, id, ap);
+
+	/* lvmetad may have been restarted */
+	if ((reply.error == ECONNRESET) && (retries < 2)) {
+		daemon_close(lvmetad_handle);
+		lvmetad_connected = 0;
+
+		lvmetad_handle = lvmetad_open(NULL);
+		if (lvmetad_handle.error || lvmetad_handle.socket_fd < 0) {
+			log_error("lvmetad_open reconnect error %d", lvmetad_handle.error);
+		} else {
+			log_debug("lvmetad reconnected");
+			lvmetad_connected = 1;
+		}
+		retries++;
+		goto retry;
+	}
+	pthread_mutex_unlock(&lvmetad_mutex);
+
+	va_end(ap);
+	return reply;
+}
+
 static int res_lock(struct lockspace *ls, struct resource *r, struct action *act, int *retry)
 {
 	struct lock *lk;
@@ -1247,14 +1265,12 @@ static int res_lock(struct lockspace *ls, struct resource *r, struct action *act
 		else
 			uuid = ls->vg_uuid;
 
-		pthread_mutex_lock(&lvmetad_mutex);
-		reply = daemon_send_simple(lvmetad_handle, "set_vg_info",
-					   "token = %s", "skip",
-					   "uuid = %s", uuid,
-					   "name = %s", ls->vg_name,
-					   "version = %d", (int)new_version,
-					   NULL);
-			pthread_mutex_unlock(&lvmetad_mutex);
+		reply = send_lvmetad("set_vg_info",
+				     "token = %s", "skip",
+				     "uuid = %s", uuid,
+				     "name = %s", ls->vg_name,
+				     "version = " FMTd64, (int64_t)new_version,
+				     NULL);
 
 		if (reply.error || strcmp(daemon_reply_str(reply, "response", ""), "OK"))
 			log_error("set_vg_info in lvmetad failed %d", reply.error);
@@ -1267,12 +1283,10 @@ static int res_lock(struct lockspace *ls, struct resource *r, struct action *act
 		log_debug("S %s R %s res_lock set lvmetad global invalid",
 			  ls->name, r->name);
 
-		pthread_mutex_lock(&lvmetad_mutex);
-		reply = daemon_send_simple(lvmetad_handle, "set_global_info",
-						   "token = %s", "skip",
-						   "global_invalid = %d", 1,
-						   NULL);
-		pthread_mutex_unlock(&lvmetad_mutex);
+		reply = send_lvmetad("set_global_info",
+				     "token = %s", "skip",
+				     "global_invalid = " FMTd64, INT64_C(1),
+				     NULL);
 
 		if (reply.error || strcmp(daemon_reply_str(reply, "response", ""), "OK"))
 			log_error("set_global_info in lvmetad failed %d", reply.error);
@@ -1333,7 +1347,7 @@ static int res_convert(struct lockspace *ls, struct resource *r,
 
 	r->last_client_id = act->client_id;
 
-	log_debug("S %s R %s res_convert cl %u mode %d", ls->name, r->name, act->client_id, act->mode);
+	log_debug("S %s R %s res_convert cl %u mode %s", ls->name, r->name, act->client_id, mode_str(act->mode));
 
 	if (act->mode == LD_LK_EX && lk->mode == LD_LK_SH && r->sh_count > 1)
 		return -EAGAIN;
@@ -1347,12 +1361,16 @@ static int res_convert(struct lockspace *ls, struct resource *r,
 		r->version++;
 		lk->version = r->version;
 		r_version = r->version;
+		r->version_zero_valid = 0;
+
 		log_debug("S %s R %s res_convert r_version inc %u",
 			  ls->name, r->name, r_version);
 
 	} else if ((r->type == LD_RT_VG) && (r->mode == LD_LK_EX) && (lk->version > r->version)) {
 		r->version = lk->version;
 		r_version = r->version;
+		r->version_zero_valid = 0;
+
 		log_debug("S %s R %s res_convert r_version new %u", ls->name, r->name, r_version);
 	} else {
 		r_version = 0;
@@ -1547,8 +1565,23 @@ static int res_update(struct lockspace *ls, struct resource *r,
 
 	if (act->flags & LD_AF_NEXT_VERSION)
 		lk->version = r->version + 1;
-	else
+	else {
+		if (r->version >= act->version) {
+			/*
+			 * This update is done from vg_write. If the metadata with
+			 * this seqno is not committed by vg_commit, then next
+			 * vg_write can use the same seqno, causing us to see no
+			 * increase in seqno here as expected.
+			 * FIXME: In this case, do something like setting the lvb
+			 * version to 0 to instead of the same seqno which will
+			 * force an invalidation on other hosts.  The next change
+			 * will return to using the seqno again.
+			 */
+			log_error("S %s R %s res_update cl %u old version %u new version %u too small",
+			  	  ls->name, r->name, act->client_id, r->version, act->version);
+		}
 		lk->version = act->version;
+	}
 
 	log_debug("S %s R %s res_update cl %u lk version to %u", ls->name, r->name, act->client_id, lk->version);
 
@@ -2236,6 +2269,7 @@ static void *lockspace_thread_main(void *arg_in)
 	struct action *act_op_free = NULL;
 	struct list_head tmp_act;
 	struct list_head act_close;
+	char tmp_name[MAX_NAME+1];
 	int free_vg = 0;
 	int drop_vg = 0;
 	int error = 0;
@@ -2601,6 +2635,10 @@ out_act:
 	ls->drop_vg = drop_vg;
 	if (ls->lm_type == LD_LM_DLM && !strcmp(ls->name, gl_lsname_dlm))
 		global_dlm_lockspace_exists = 0;
+	/* Avoid a name collision of the same lockspace is added again before this thread is cleaned up. */
+	memset(tmp_name, 0, sizeof(tmp_name));
+	snprintf(tmp_name, MAX_NAME, "REM:%s", ls->name);
+	memcpy(ls->name, tmp_name, MAX_NAME);
 	pthread_mutex_unlock(&lockspaces_mutex);
 
 	/* worker_thread will join this thread, and free the ls */
@@ -3030,6 +3068,7 @@ static int for_each_lockspace(int do_stop, int do_free, int do_force)
 	int free_count = 0;
 	int done;
 	int stop;
+	int perrno;
 
 	pthread_mutex_lock(&lockspaces_mutex);
 
@@ -3072,11 +3111,15 @@ static int for_each_lockspace(int do_stop, int do_free, int do_force)
 			 * thread touches the ls struct under lockspaces_mutex.
 			 */
 			if (done) {
-				pthread_join(ls->thread, NULL);
+				if ((perrno = pthread_join(ls->thread, NULL)))
+					log_error("pthread_join error %d", perrno);
+
 				list_del(&ls->list);
 
 				/* FIXME: will free_vg ever not be set? */
 
+				log_debug("free ls %s", ls->name);
+
 				if (ls->free_vg) {
 					/* In future we may need to free ls->actions here */
 					free_ls_resources(ls);
@@ -3329,6 +3372,11 @@ static void *worker_thread_main(void *arg_in)
 			int run_sanlock = lm_is_running_sanlock();
 			int run_dlm = lm_is_running_dlm();
 
+			if (daemon_test) {
+				run_sanlock = gl_use_sanlock;
+				run_dlm = gl_use_dlm;
+			}
+
 			if (run_sanlock && run_dlm)
 				act->result = -EXFULL;
 			else if (!run_sanlock && !run_dlm)
@@ -3592,12 +3640,15 @@ static int client_send_result(struct client *cl, struct action *act)
 			strcat(result_flags, "NO_LOCKSPACES,");
 		pthread_mutex_unlock(&lockspaces_mutex);
 
-		if (gl_use_sanlock && !gl_lsname_sanlock[0])
-			strcat(result_flags, "NO_GL_LS,");
-		else if (gl_use_dlm && !gl_lsname_dlm[0])
-			strcat(result_flags, "NO_GL_LS,");
-		else
+		if (gl_use_sanlock) {
+			if (!gl_lsname_sanlock[0])
+				strcat(result_flags, "NO_GL_LS,");
+		} else if (gl_use_dlm) {
+			if (!gl_lsname_dlm[0])
+				strcat(result_flags, "NO_GL_LS,");
+		} else {
 			strcat(result_flags, "NO_GL_LS,");
+		}
 	}
 
 	if (act->flags & LD_AF_DUP_GL_LS)
@@ -3626,9 +3677,9 @@ static int client_send_result(struct client *cl, struct action *act)
 			  act->result, vg_args ? vg_args : "", lv_args ? lv_args : "");
 
 		res = daemon_reply_simple("OK",
-					  "op = %d", act->op,
-					  "op_result = %d", act->result,
-					  "lm_result = %d", act->lm_rv,
+					  "op = " FMTd64, (int64_t)act->op,
+					  "op_result = " FMTd64, (int64_t) act->result,
+					  "lm_result = " FMTd64, (int64_t) act->lm_rv,
 					  "vg_lock_args = %s", vg_args,
 					  "lv_lock_args = %s", lv_args,
 					  "result_flags = %s", result_flags[0] ? result_flags : "none",
@@ -3657,8 +3708,8 @@ static int client_send_result(struct client *cl, struct action *act)
 			  act->result, dump_len);
 
 		res = daemon_reply_simple("OK",
-					  "result = %d", act->result,
-					  "dump_len = %d", dump_len,
+					  "result = " FMTd64, (int64_t) act->result,
+					  "dump_len = " FMTd64, (int64_t) dump_len,
 					  NULL);
 	} else {
 		/*
@@ -3671,10 +3722,10 @@ static int client_send_result(struct client *cl, struct action *act)
 			  act->result, (act->result == -ENOLS) ? "ENOLS" : "", result_flags);
 
 		res = daemon_reply_simple("OK",
-					  "op = %d", act->op,
+					  "op = " FMTd64, (int64_t) act->op,
 					  "lock_type = %s", lm_str(act->lm_type),
-					  "op_result = %d", act->result,
-					  "lm_result = %d", act->lm_rv,
+					  "op_result = " FMTd64, (int64_t) act->result,
+					  "lm_result = " FMTd64, (int64_t) act->lm_rv,
 					  "result_flags = %s", result_flags[0] ? result_flags : "none",
 					  NULL);
 	}
@@ -4401,9 +4452,9 @@ static void client_recv_action(struct client *cl)
 		buffer_init(&res.buffer);
 
 		res = daemon_reply_simple("OK",
-					  "result = %d", result,
+					  "result = " FMTd64, (int64_t) result,
 					  "protocol = %s", lvmlockd_protocol,
-					  "version = %d", lvmlockd_protocol_version,
+					  "version = " FMTd64, (int64_t) lvmlockd_protocol_version,
 					  NULL);
 		buffer_write(cl->fd, &res.buffer);
 		buffer_destroy(&res.buffer);
@@ -4742,15 +4793,11 @@ static int get_lockd_vgs(struct list_head *vg_lockd)
 	const char *lock_type;
 	const char *lock_args;
 	char find_str_path[PATH_MAX];
-	int mutex_unlocked = 0;
 	int rv = 0;
 
 	INIT_LIST_HEAD(&update_vgs);
 
-	pthread_mutex_lock(&lvmetad_mutex);
-	reply = daemon_send_simple(lvmetad_handle, "vg_list",
-				   "token = %s", "skip",
-				   NULL);
+	reply = send_lvmetad("vg_list", "token = %s", "skip", NULL);
 
 	if (reply.error || strcmp(daemon_reply_str(reply, "response", ""), "OK")) {
 		log_error("vg_list from lvmetad failed %d", reply.error);
@@ -4787,10 +4834,10 @@ static int get_lockd_vgs(struct list_head *vg_lockd)
 	/* get vg_name and lock_type for each vg uuid entry in update_vgs */
 
 	list_for_each_entry(ls, &update_vgs, list) {
-		reply = daemon_send_simple(lvmetad_handle, "vg_lookup",
-					   "token = %s", "skip",
-					   "uuid = %s", ls->vg_uuid,
-					   NULL);
+		reply = send_lvmetad("vg_lookup",
+				     "token = %s", "skip",
+				     "uuid = %s", ls->vg_uuid,
+				     NULL);
 
 		if (reply.error || strcmp(daemon_reply_str(reply, "response", ""), "OK")) {
 			log_error("vg_lookup from lvmetad failed %d", reply.error);
@@ -4879,8 +4926,6 @@ static int get_lockd_vgs(struct list_head *vg_lockd)
 		if (rv < 0)
 			break;
 	}
-	pthread_mutex_unlock(&lvmetad_mutex);
-	mutex_unlocked = 1;
 out:
 	/* Return lockd VG's on the vg_lockd list. */
 
@@ -4893,9 +4938,6 @@ out:
 			free(ls);
 	}
 
-	if (!mutex_unlocked)
-		pthread_mutex_unlock(&lvmetad_mutex);
-
 	return rv;
 }
 
@@ -5123,13 +5165,17 @@ static void adopt_locks(void)
 	 * This is expected for at least one of them.
 	 */
 
-	rv = lm_get_lockspaces_dlm(&ls_found);
-	if ((rv < 0) && (rv != -ECONNREFUSED))
-		goto fail;
+	if (lm_support_dlm()) {
+		rv = lm_get_lockspaces_dlm(&ls_found);
+		if ((rv < 0) && (rv != -ECONNREFUSED))
+			goto fail;
+	}
 
-	rv = lm_get_lockspaces_sanlock(&ls_found);
-	if ((rv < 0) && (rv != -ECONNREFUSED))
-		goto fail;
+	if (lm_support_sanlock()) {
+		rv = lm_get_lockspaces_sanlock(&ls_found);
+		if ((rv < 0) && (rv != -ECONNREFUSED))
+			goto fail;
+	}
 
 	if (list_empty(&ls_found)) {
 		log_debug("No lockspaces found to adopt");
@@ -5891,7 +5937,7 @@ static int main_loop(daemon_state *ds_arg)
 	close_client_thread();
 	closelog();
 	daemon_close(lvmetad_handle);
-	return 0;
+	return 1; /* libdaemon uses 1 for success */
 }
 
 static void usage(char *prog, FILE *file)
@@ -5998,7 +6044,7 @@ int main(int argc, char *argv[])
 			else if (lm == LD_LM_SANLOCK && lm_support_sanlock())
 				gl_use_sanlock = 1;
 			else {
-				fprintf(stderr, "invalid gl-type option");
+				fprintf(stderr, "invalid gl-type option\n");
 				exit(EXIT_FAILURE);
 			}
 			break;

daemons/lvmlockd/lvmlockd-dlm.c

@@ -14,7 +14,6 @@
 #include "tool.h"
 
 #include "daemon-server.h"
-#include "daemon-log.h"
 #include "xlate.h"
 
 #include "lvmlockd-internal.h"
@@ -26,7 +25,6 @@
  */
 #include "libdlm.h"
 
-#include <pthread.h>
 #include <stddef.h>
 #include <poll.h>
 #include <errno.h>
@@ -35,7 +33,6 @@
 #include <byteswap.h>
 #include <syslog.h>
 #include <dirent.h>
-#include <sys/socket.h>
 
 struct lm_dlm {
 	dlm_lshandle_t *dh;
@@ -166,6 +163,9 @@ int lm_prepare_lockspace_dlm(struct lockspace *ls)
 	struct lm_dlm *lmd;
 	int rv;
 
+	if (daemon_test)
+		goto skip_args;
+
 	memset(sys_clustername, 0, sizeof(sys_clustername));
 	memset(arg_clustername, 0, sizeof(arg_clustername));
 
@@ -473,7 +473,11 @@ int lm_lock_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
 	log_debug("S %s R %s lock_dlm", ls->name, r->name);
 
 	if (daemon_test) {
-		memset(vb_out, 0, sizeof(struct val_blk));
+		if (rdd->vb) {
+			vb_out->version = le16_to_cpu(rdd->vb->version);
+			vb_out->flags = le16_to_cpu(rdd->vb->flags);
+			vb_out->r_version = le32_to_cpu(rdd->vb->r_version);
+		}
 		return 0;
 	}
 
@@ -689,6 +693,9 @@ int lm_hosts_dlm(struct lockspace *ls, int notify)
 	DIR *ls_dir;
 	int count = 0;
 
+	if (daemon_test)
+		return 0;
+
 	memset(ls_nodes_path, 0, sizeof(ls_nodes_path));
 	snprintf(ls_nodes_path, PATH_MAX-1, "%s/%s/nodes",
 		 DLM_LOCKSPACES_PATH, ls->name);
@@ -757,6 +764,9 @@ int lm_is_running_dlm(void)
 	char sys_clustername[MAX_ARGS+1];
 	int rv;
 
+	if (daemon_test)
+		return gl_use_dlm;
+
 	memset(sys_clustername, 0, sizeof(sys_clustername));
 
 	rv = read_cluster_name(sys_clustername);

daemons/lvmlockd/lvmlockd-internal.h

@@ -351,6 +351,23 @@ int lockspaces_empty(void);
 int last_string_from_args(char *args_in, char *last);
 int version_from_args(char *args, unsigned int *major, unsigned int *minor, unsigned int *patch);
 
+static inline const char *mode_str(int x)
+{
+	switch (x) {
+	case LD_LK_IV:
+		return "iv";
+	case LD_LK_UN:
+		return "un";
+	case LD_LK_NL:
+		return "nl";
+	case LD_LK_SH:
+		return "sh";
+	case LD_LK_EX:
+		return "ex";
+	default:
+		return ".";
+	};
+}
 
 #ifdef LOCKDDLM_SUPPORT
 

daemons/lvmlockd/lvmlockd-sanlock.c

@@ -14,7 +14,6 @@
 #include "tool.h"
 
 #include "daemon-server.h"
-#include "daemon-log.h"
 #include "xlate.h"
 
 #include "lvmlockd-internal.h"
@@ -25,12 +24,10 @@
 #include "sanlock_admin.h"
 #include "sanlock_resource.h"
 
-#include <pthread.h>
 #include <stddef.h>
 #include <poll.h>
 #include <errno.h>
 #include <syslog.h>
-#include <sys/socket.h>
 
 /*
 -------------------------------------------------------------------------------
@@ -205,9 +202,11 @@ int lm_data_size_sanlock(void)
  */
 
 #define LS_BEGIN 0
-#define GL_LOCK_BEGIN 65
-#define VG_LOCK_BEGIN 66
-#define LV_LOCK_BEGIN 67
+#define GL_LOCK_BEGIN UINT64_C(65)
+#define VG_LOCK_BEGIN UINT64_C(66)
+#define LV_LOCK_BEGIN UINT64_C(67)
+
+static unsigned int daemon_test_lv_count;
 
 static int lock_lv_name_from_args(char *vg_args, char *lock_lv_name)
 {
@@ -341,6 +340,7 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	if (daemon_test) {
 		if (!gl_lsname_sanlock[0])
 			strncpy(gl_lsname_sanlock, ls_name, MAX_NAME);
+		snprintf(vg_args, MAX_ARGS, "%s:%s", lock_args_version, lock_lv_name);
 		return 0;
 	}
 
@@ -492,6 +492,15 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 	snprintf(lock_args_version, MAX_ARGS, "%u.%u.%u",
 		 LV_LOCK_ARGS_MAJOR, LV_LOCK_ARGS_MINOR, LV_LOCK_ARGS_PATCH);
 
+	if (daemon_test) {
+		align_size = 1048576;
+		snprintf(lv_args, MAX_ARGS, "%s:%llu",
+			 lock_args_version,
+			 (unsigned long long)((align_size * LV_LOCK_BEGIN) + (align_size * daemon_test_lv_count)));
+		daemon_test_lv_count++;
+		return 0;
+	}
+
 	strncpy(rd.rs.lockspace_name, ls_name, SANLK_NAME_LEN);
 	rd.rs.num_disks = 1;
 	snprintf(rd.rs.disks[0].path, SANLK_PATH_LEN-1, "/dev/mapper/%s-%s", vg_name, lock_lv_name);
@@ -508,12 +517,6 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 		offset = align_size * LV_LOCK_BEGIN;
 	rd.rs.disks[0].offset = offset;
 
-	if (daemon_test) {
-		snprintf(lv_args, MAX_ARGS, "%s:%llu",
-			 lock_args_version, (unsigned long long)1111);
-		return 0;
-	}
-
 	while (1) {
 		rd.rs.disks[0].offset = offset;
 
@@ -762,6 +765,9 @@ int lm_ex_disable_gl_sanlock(struct lockspace *ls)
 	struct sanlk_resource **rs_args;
 	int rv;
 
+	if (daemon_test)
+		return 0;
+
 	rs_args = malloc(2 * sizeof(struct sanlk_resource *));
 	if (!rs_args)
 		return -ENOMEM;
@@ -831,6 +837,9 @@ int lm_able_gl_sanlock(struct lockspace *ls, int enable)
 	else
 		gl_name = R_NAME_GL_DISABLED;
 
+	if (daemon_test)
+		goto out;
+
 	memset(&rd, 0, sizeof(rd));
 
 	strncpy(rd.rs.lockspace_name, ls->name, SANLK_NAME_LEN);
@@ -846,7 +855,7 @@ int lm_able_gl_sanlock(struct lockspace *ls, int enable)
 			  ls->name, enable, rv, rd.rs.disks[0].path);
 		return rv;
 	}
-
+out:
 	log_debug("S %s able_gl %s", ls->name, gl_name);
 
 	ls->sanlock_gl_enabled = enable;
@@ -867,6 +876,9 @@ static int gl_is_enabled(struct lockspace *ls, struct lm_sanlock *lms)
 	uint64_t offset;
 	int rv;
 
+	if (daemon_test)
+		return 1;
+
 	memset(&rd, 0, sizeof(rd));
 
 	strncpy(rd.rs.lockspace_name, ls->name, SANLK_NAME_LEN);
@@ -925,8 +937,10 @@ int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
 	uint64_t offset;
 	int rv;
 
-	if (daemon_test)
+	if (daemon_test) {
+		*free_offset = (1048576 * LV_LOCK_BEGIN) + (1048576 * (daemon_test_lv_count + 1));
 		return 0;
+	}
 
 	memset(&rd, 0, sizeof(rd));
 
@@ -1175,6 +1189,11 @@ int lm_add_lockspace_sanlock(struct lockspace *ls, int adopt)
 	struct lm_sanlock *lms = (struct lm_sanlock *)ls->lm_data;
 	int rv;
 
+	if (daemon_test) {
+		sleep(2);
+		goto out;
+	}
+
 	rv = sanlock_add_lockspace_timeout(&lms->ss, 0, sanlock_io_timeout);
 	if (rv == -EEXIST && adopt) {
 		/* We could alternatively just skip the sanlock call for adopt. */
@@ -1243,10 +1262,10 @@ int lm_rem_lockspace_sanlock(struct lockspace *ls, int free_vg)
 				  ls->name, rv, lms->ss.host_id_disk.path);
 		}
 	}
-out:
+
 	if (close(lms->sock))
 		log_error("failed to close sanlock daemon socket connection");
-
+out:
 	free(lms);
 	ls->lm_data = NULL;
 
@@ -1305,6 +1324,7 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 	struct lm_sanlock *lms = (struct lm_sanlock *)ls->lm_data;
 	struct rd_sanlock *rds = (struct rd_sanlock *)r->lm_data;
 	struct sanlk_resource *rs;
+	struct sanlk_options opt;
 	uint64_t lock_lv_offset;
 	uint32_t flags = 0;
 	struct val_blk vb;
@@ -1378,12 +1398,16 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 
 	rs->flags |= SANLK_RES_PERSISTENT;
 
-	log_debug("S %s R %s lock_san acquire %s:%llu",
-		  ls->name, r->name, rs->disks[0].path,
+	log_debug("S %s R %s lock_san %s at %s:%llu",
+		  ls->name, r->name, mode_str(ld_mode), rs->disks[0].path,
 		  (unsigned long long)rs->disks[0].offset);
 
 	if (daemon_test) {
-		memset(vb_out, 0, sizeof(struct val_blk));
+		if (rds->vb) {
+			vb_out->version = le16_to_cpu(rds->vb->version);
+			vb_out->flags = le16_to_cpu(rds->vb->flags);
+			vb_out->r_version = le32_to_cpu(rds->vb->r_version);
+		}
 		return 0;
 	}
 
@@ -1392,16 +1416,17 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 	if (adopt)
 		flags |= SANLK_ACQUIRE_ORPHAN_ONLY;
 
-#ifdef SANLOCK_HAS_ACQUIRE_OWNER_NOWAIT
 	/*
 	 * Don't block waiting for a failed lease to expire since it causes
 	 * sanlock_acquire to block for a long time, which would prevent this
 	 * thread from processing other lock requests.
 	 */
 	flags |= SANLK_ACQUIRE_OWNER_NOWAIT;
-#endif
 
-	rv = sanlock_acquire(lms->sock, -1, flags, 1, &rs, NULL);
+	memset(&opt, 0, sizeof(opt));
+	sprintf(opt.owner_name, "%s", "lvmlockd");
+
+	rv = sanlock_acquire(lms->sock, -1, flags, 1, &rs, &opt);
 
 	if (rv == -EAGAIN) {
 		/*
@@ -1471,7 +1496,6 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 		return -EAGAIN;
 	}
 
-#ifdef SANLOCK_HAS_ACQUIRE_OWNER_NOWAIT
 	if (rv == SANLK_ACQUIRE_OWNED_RETRY) {
 		/*
 		 * The lock is held by a failed host, and will eventually
@@ -1490,7 +1514,7 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 		*retry = 0;
 		return -EAGAIN;
 	}
-#endif
+
 	if (rv < 0) {
 		log_error("S %s R %s lock_san acquire error %d",
 			  ls->name, r->name, rv);
@@ -1561,7 +1585,8 @@ int lm_convert_sanlock(struct lockspace *ls, struct resource *r,
 	uint32_t flags = 0;
 	int rv;
 
-	log_debug("S %s R %s convert_san", ls->name, r->name);
+	log_debug("S %s R %s convert_san %s to %s",
+		  ls->name, r->name, mode_str(r->mode), mode_str(ld_mode));
 
 	if (daemon_test)
 		goto rs_flag;
@@ -1665,11 +1690,18 @@ int lm_unlock_sanlock(struct lockspace *ls, struct resource *r,
 	struct val_blk vb;
 	int rv;
 
-	log_debug("S %s R %s unlock_san r_version %u flags %x",
-		  ls->name, r->name, r_version, lmu_flags);
+	log_debug("S %s R %s unlock_san %s r_version %u flags %x",
+		  ls->name, r->name, mode_str(r->mode), r_version, lmu_flags);
 
-	if (daemon_test)
+	if (daemon_test) {
+		if (rds->vb && r_version && (r->mode == LD_LK_EX)) {
+			if (!rds->vb->version)
+				rds->vb->version = cpu_to_le16(VAL_BLK_VERSION);
+			if (r_version)
+				rds->vb->r_version = cpu_to_le32(r_version);
+		}
 		return 0;
+	}
 
 	if (rds->vb && r_version && (r->mode == LD_LK_EX)) {
 		if (!rds->vb->version) {
@@ -1719,6 +1751,9 @@ int lm_hosts_sanlock(struct lockspace *ls, int notify)
 	int found_others = 0;
 	int i, rv;
 
+	if (daemon_test)
+		return 0;
+
 	rv = sanlock_get_hosts(ls->name, 0, &hss, &hss_count, 0);
 	if (rv < 0) {
 		log_error("S %s hosts_san get_hosts error %d", ls->name, rv);
@@ -1818,6 +1853,9 @@ int lm_is_running_sanlock(void)
 	uint32_t daemon_proto;
 	int rv;
 
+	if (daemon_test)
+		return gl_use_sanlock;
+
 	rv = sanlock_version(0, &daemon_version, &daemon_proto);
 	if (rv < 0)
 		return 0;

daemons/lvmpolld/Makefile.in

@@ -9,7 +9,7 @@
 #
 # 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@

daemons/lvmpolld/lvmpolld-cmd-utils.c

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "lvmpolld-common.h"

daemons/lvmpolld/lvmpolld-cmd-utils.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #ifndef _LVM_LVMPOLLD_CMD_UTILS_H

daemons/lvmpolld/lvmpolld-common.h

@@ -9,7 +9,7 @@
  *
  * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 /*