Merge remote-tracking branch 'origin/master' into dev-dct-lvmlockd-test

* origin/master:
  tests: workaround udev problem
  snapshot: add synchronization point
  commands: --withspaces also for config and lvmconfig cmd aliases
  make: use lvmconfig ... --withspaces when generating lvm.conf and lvmlocal.conf
  lvmconfig: add --withspaces option
  WHATS_NEW: recent commits - config value format flags
  config: regenerate configure.in to accomodate all recent changes
  config: devices/filter and devices/global_filter setting have 'a/.*/' as default value
  config: allow empty values for {thin,cache}_{check,repair}_options
  configure: add DEFAULT_USE_BLKID_WIPING
  config: display global/umask in octal form
  config: use proper unconfigured default values for use_lvmetad and use_lvmpolld settings
  config: cleanup default values for some configuration settings with array values
  config: add support for config value formatting flags

.gitignore

@@ -1,16 +1,13 @@
 *.5
-*.7
 *.8
 *.a
 *.d
 *.o
-*.orig
 *.pc
 *.pot
-*.rej
 *.so
 *.so.*
-*.sw*
+*.swp
 *~
 
 .export.sym
@@ -20,11 +17,11 @@
 Makefile
 make.tmpl
 
+configure.h
+version.h
+
 /autom4te.cache/
-/autoscan.log
 /config.log
 /config.status
-/configure.scan
 /cscope.out
-/tags
 /tmp/

Makefile.in

@@ -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 unit: all
 	$(MAKE) -C test $(@)
 
 conf.generate: tools
@@ -131,9 +131,6 @@ rpm: dist
 generate: conf.generate
 	$(MAKE) -C conf generate
 
-all_man:
-	$(MAKE) -C man all_man
-
 install_system_dirs:
 	$(INSTALL_DIR) $(DESTDIR)$(DEFAULT_SYS_DIR)
 	$(INSTALL_ROOT_DIR) $(DESTDIR)$(DEFAULT_ARCHIVE_DIR)
@@ -153,9 +150,6 @@ install_systemd_generators:
 install_systemd_units:
 	$(MAKE) -C scripts install_systemd_units
 
-install_all_man:
-	$(MAKE) -C man install_all_man
-
 ifeq ("@PYTHON_BINDINGS@", "yes")
 install_python_bindings:
 	$(MAKE) -C liblvm/python install_python_bindings
@@ -229,12 +223,3 @@ memcheck: test-programs
 ruby-test:
 	$(RUBY) report-generators/test/ts.rb
 endif
-
-ifneq ($(shell which ctags),)
-.PHONY: tags
-tags:
-	test -z "$(shell find $(top_srcdir) -type f -name '*.[ch]' -newer tags 2>/dev/null | head -1)" || $(RM) tags
-	test -f tags || find $(top_srcdir) -maxdepth 5 -type f -name '*.[ch]' -exec ctags -a '{}' +
-
-CLEAN_TARGETS += tags
-endif

VERSION

@@ -1 +1 @@
-2.02.134(2)-git (2015-10-30)
+2.02.123(2)-git (2015-06-20)

VERSION_DM

@@ -1 +1 @@
-1.02.111-git (2015-10-30)
+1.02.100-git (2015-06-20)

WHATS_NEW

@@ -1,148 +1,7 @@
-Version 2.02.134 - 
-====================================
-
-Version 2.02.133 - 30th October 2015
-====================================
-  Support repeated -o|--options for reporting commands.
-  Support -o- and -o# for reporting commands to remove and compact fields.
-  Fix missing PVs from pvs output if vgremove is run concurrently.
-  Remove unwanted error message when running pvs/vgs/lvs and vgremove at once.
-  Check newly created VG's metadata do not overlap in metadata ring buffer.
-  Check metadata area size is at least the minimum size defined for the format.
-  Thin pool targets uses low_water_mark from profile.
-  Dropping 'yet' from error of unsupported thick snapshot of snapshots.
-  Do not support unpartitioned DASD devices with CDL formatted with pvcreate.
-  For thins use flush for suspend only when volume size is reduced.
-  Enable code which detects the need of flush during suspend.
-  Ensure --use-policy will resize volume to fit below threshold.
-  Correct percentage evaluation when checking thin-pool over threshold.
-  Fix lvmcache to move PV from VG to orphans if VG is removed and lvmetad used.
-  Fix lvmcache to not cache even invalid info about PV which got removed.
-  Support checking of memlock daemon counter.
-  Allow all log levels to be used with the lvmetad -l option.
-  Add optional shutdown when idle support for lvmetad.
-  Fix missing in-sync progress info while lvconvert used with lvmpolld.
-  Add report/compact_output_cols to lvm.conf to define report cols to compact.
-  Do not change logging in lvm2 library when it's already set.
-  Check for enough space in thin-pool in command before creating new thin.
-  Make libblkid detect all copies of the same signature if use_blkid_wiping=1.
-  Fix vgimportclone with -n to not add number unnecessarily to base VG name.
-  Cleanup vgimportclone script and remove dependency on awk, grep, cut and tr.
-  Add vg_missing_pv_count report field to report number of missing PVs in a VG.
-  Properly identify internal LV holding sanlock locks within lv_role field.
-  Add metadata_devices and seg_metadata_le_ranges report fields for raid vols.
-  Fix lvm2-{activation,clvmd,cmirrord,monitor} service to exec before mounting.
-
-Version 2.02.132 - 22nd September 2015
-======================================
-  Fix lvmconf to set locking_type=2 if external locking library is requested.
-  Remove verbose message when rescanning an unchanged device. (2.02.119)
-  Add origin_uuid, mirror_log_uuid, move_pv_uuid, convert_lv_uuid report fields.
-  Add pool_lv_uuid, metadata_lv_uuid, data_lv_uuid reporting fields.
-  Fix PV label processing failure after pvcreate in lvm shell with lvmetad.
-
-Version 2.02.131 - 15th September 2015
-======================================
-  Rename 'make install_full_man' to install_all_man and add all_man target.
-  Fix vgimportclone cache_dir path name (2.02.115).
-  Swapping of LV identifiers handles more complex LVs.
-  Use passed list of PVS when allocating space in lvconvert --thinpool.
-  Disallow usage of --stripe and --stripesize when creating cache pool.
-  Warn user when caching raid or thin pool data LV.
-  When layering LV, move LV flags with segments.
-  Ignore persistent cache if configuration changed. (2.02.127)
-  Fix devices/filter to be applied before disk-accessing filters. (2.02.112)
-  Make tags only when requested via 'make tags'.
-  Configure supports --disable-dependency-tracking for one-time builds.
-  Fix usage of configure.h when building in srcdir != builddir.
-
-Version 2.02.130 - 5th September 2015
-=====================================
-  Fix use of uninitialized device status if reading outdated .cache record.
-  Restore support for --monitor option in lvcreate (2.02.112).
-  Read thin-pool data and metadata percent without flush.
-  Detect blocked thin-pool and avoid scanning their thin volumes.
-  Check if dm device is usable before checking its size (2.02.116).
-  Extend parsing of cache_check version in configure.
-  Make lvpoll error messages visible in lvmpolld's stderr and in syslog.
-  Add 'make install_full_man' to install all man pages regardless of config.
-
-Version 2.02.129 - 26th August 2015
-===================================
-  Drop error message when vgdisplay encounters an exported VG. (2.02.27)
-  Fix shared library generation to stop exporting internal functions.(2.02.120)
-  Accept --cachemode with lvconvert.
-  Fix and improve reporting properties of cache-pool.
-  Enable usage of --cachepolicy and --cachesetting with lvconvert.
-  Don't allow to reduce size of thin-pool metadata.
-  Fix debug buffer overflows in cmirrord logging.
-  Add --foreground and --help to cmirrord.
-
-Version 2.02.128 - 17th August 2015
-===================================
-  Allocation setting cache_pool_cachemode is replaced by cache_mode.
-  Don't attempt to close config file that couldn't be opened.
-  Check for valid cache mode in validation of cache segment.
-  Change internal interface handling cache mode and policy.
-  When no cache policy specified, prefer smq (if available) over mq.
-  Add demo cache-mq and cache-smq profiles.
-  Add cmd profilable allocation/cache_policy,cache_settings,cache_mode.
-  Require cache_check 0.5.4 for use of --clear-needs-check-flag.
-  Fix lvmetad udev rules to not override SYSTEMD_WANTS, add the service instead.
-
-Version 2.02.127 - 10th August 2015
-===================================
-  Do not init filters, locking, lvmetad, lvmpolld if command doesn't use it.
-  Order fields in struct cmd_context more logically.
-  Add lock_type to lvmcache VG summary and info structs.
-  Fix regression in cache causing some PVs to bypass filters (2.02.105).
-  Make configure --enable-realtime the default now.
-  Update .gitignore and configure.in files to reflect usage of current tree.
-
-Version 2.02.126 - 24th July 2015
+Version 2.02.123 - 
 =================================
-  Fix long option hyphen removal. (2.02.122)
-  Fix clvmd freeze if client disappears without first releasing its locks.
-  Fix lvconvert segfaults while performing snapshots merge.
-  Ignore errors during detection if use_blkid_wiping=1 and --force is used.
-  Recognise DM_ABORT_ON_INTERNAL_ERRORS env var override in lvm logging fn.
-  Fix alloc segfault when extending LV with fewer stripes than in first seg.
-  Fix handling of cache policy name.
-  Set cache policy before with the first lvm2 cache pool metadata commit.
-  Fix detection of thin-pool overprovisioning (2.02.124).
-  Fix lvmpolld segfaults on 32 bit architectures.
-  Add lvmlockd lock_args validation to vg_validate.
-  Fix ignored --startstopservices option if running lvmconf with systemd.
-  Hide sanlock LVs when processing LVs in VG unless named or --all used.
-
-Version 2.02.125 - 7th July 2015
-================================
-  Fix getline memory usage in lvmpolld.
-  Add support --clear-needs-check-flag for cache_check of cache pool metadata.
-  Add lvmetactl for developer use only.
-  Rename global/lock_retries to lvmlockd_retries.
-  Replace --enable-lvmlockd by --enable-lockd-sanlock and --enable-lockd-dlm.
-
-Version 2.02.124 - 3rd July 2015
-================================
-  Move sending thin pool messages from resume to suspend phase.
-  Report warning when pool is overprovisioned and not auto resized.
-  Recognize free-form date/time values for lv_time field in selection criteria.
-  Added experimental lvmlockd with configure --enable-lvmlockd.
-  Fix regression in select to match string fields if using synonyms (2.02.123).
-  Fix regression when printing more lv names via display_lvname (2.02.122).
-  Add missing error logging to unlock_vg and sync_local_dev_names callers.
-
-Version 2.02.123 - 30th June 2015
-=================================
-  Add report/time_format lvm.conf option to define time format for report.
-  Fix makefile shell compare == when building lvmetad lvmpolld (2.02.120).
-  Add --type full to lvmconfig for full configuration tree view.
-  Add undocumented environment variables to lvm man page. (2.02.119)
   Add device synchronization point before activating a new snapshot.
   Add --withspaces to lvmconfig to add spaces in output for better readability.
-  Add custom main function to libdaemon.
-  Use lvmetad to track out-of-date metadata discovered.
 
 Version 2.02.122 - 20th June 2015
 =================================

WHATS_NEW_DM

@@ -1,134 +1,5 @@
-Version 1.02.111 - 
-====================================
-
-Version 1.02.110 - 30th October 2015
-====================================
-  Disable thin monitoring plugin when it fails too often (>10 times).
-  Fix/restore parsing of empty field '-' when processing dmeventd event.
-  Enhance dm_tree_node_size_changed() to recognize size reduction.
-  Support exit on idle for dmenventd (1 hour).
-  Add support to allow unmonitor device from plugin itself.
-  New design for thread co-operation in dmeventd.
-  Dmeventd read device status with 'noflush'.
-  Dmeventd closes control device when no device is monitored.
-  Thin plugin for dmeventd improved percentage usage.
-  Snapshot plugin for dmeventd improved percentage usage.
-  Add dm_hold_control_dev to allow holding of control device open.
-  Add dm_report_compact_given_fields to remove given empty fields from report.
-  Use libdm status parsing and local mem raid dmeventd plugin.
-  Use local mem pool and lock only lvm2 execution for mirror dmeventd plugin.
-  Lock protect only lvm2 execution for snapshot and thin dmeventd plugin.
-  Use local mempool for raid and mirror plugins.
-  Reworked thread initialization for dmeventd plugins.
-  Dmeventd handles snapshot overflow for now equally as invalid.
-  Convert dmeventd to use common logging macro system from libdm.
-  Return -ENOMEM when device registration fails instead of 0 (=success).
-  Enforce writethrough mode for cleaner policy.
-  Add support for recognition and deactivation of MD devices to blkdeactivate.
-  Move target status functions out of libdm-deptree.
-  Correct use of max_write_behind parameter when generating raid target line.
-  Fix dm-event systemd service to make sure it is executed before mounting.
-
-Version 1.02.109 - 22nd September 2016
-======================================
-  Update man pages for dmsetup and dmstats.
-  Improve help text for dmsetup.
-  Use --noflush and --nolockfs when removing device with --force.
-  Parse new Overflow status string for snapshot target.
-  Check dir path components are valid if using dm_create_dir, error out if not.
-  Fix /dev/mapper handling to remove dangling entries if symlinks are found.
-  Make it possible to use blank value as selection for string list report field.
-
-Version 1.02.108 - 15th September 2015
-======================================
-  Do not check for full thin pool when activating without messages (1.02.107).
-
-Version 1.02.107 - 5th September 2015
-=====================================
-  Parse thin-pool status with one single routine internally.
-  Add --histogram to select default histogram fields for list and report.
-  Add report fields for displaying latency histogram configuration and data.
-  Add dmstats --bounds to specify histogram boundaries for a new region.
-  Add dm_histogram_to_string() to format histogram data in string form.
-  Add public methods to libdm to access numerical histogram config and data.
-  Parse and store histogram data in dm_stats_list() and dm_stats_populate().
-  Add an argument to specify histogram bounds to dm_stats_create_region().
-  Add dm_histogram_bounds_from_{string,uint64_t}() to parse histogram bounds.
-  Add dm_histogram handle type to represent a latency histogram and its bounds.
-  Fix devmapper.pc pkgconfig file to not reference non-existent rt.pc file.
-  Reinstate dm_task_get_info@Base to libdevmapper exports. (1.02.106)
-
-Version 1.02.106 - 26th August 2015
-===================================
-  Add 'precise' column to statistics reports.
-  Add --precise switch to 'dmstats create' to request nanosecond counters.
-  Add precise argument to dm_stats_create_region().
-  Add support to libdm-stats for precise_timestamps
-
-Version 1.02.105 - 17th August 2015
-===================================
-  Fix 'dmstats list -o all' segfault.
-  Separate dmstats statistics fields from region information fields.
-  Add interval and interval_ns fields to dmstats reports.
-  Do not include internal glibc headers in libdm-timestamp.c (1.02.104)
-  Exit immediately if no device is supplied to dmsetup wipe_table.
-  Suppress dmsetup report headings when no data is output. (1.02.104)
-  Adjust dmsetup usage/help output selection to match command invoked.
-  Fix dmsetup -o all to select correct fields in splitname report.
-  Restructure internal dmsetup argument handling across all commands.
-  Add dm_report_is_empty() to indicate there is no data awaiting output.
-  Add more arg validation for dm_tree_node_add_cache_target().
-  Add --alldevices switch to replace use of --force for stats create / delete.
-
-Version 1.02.104 - 10th August 2015
-===================================
-  Add dmstats.8 man page
-  Add dmstats --segments switch to create one region per device segment.
-  Add dmstats --regionid, --allregions to specify a single / all stats regions.
-  Add dmstats --allprograms for stats commands that filter by program ID.
-  Add dmstats --auxdata and --programid args to specify aux data and program ID.
-  Add report stats sub-command to provide repeating stats reports.
-  Add clear, delete, list, and print stats sub-commands.
-  Add create stats sub-command and --start, --length, --areas and --areasize.
-  Recognize 'dmstats' as an alias for 'dmsetup stats' when run with this name.
-  Add a 'stats' command to dmsetup to configure, manage and report stats data.
-  Add statistics fields to dmsetup -o.
-  Add libdm-stats library to allow management of device-mapper statistics.
-  Add --nosuffix to suppress dmsetup unit suffixes in report output.
-  Add --units to control dmsetup report field output units.
-  Add support to redisplay column headings for repeating column reports.
-  Fix report header and row resource leaks.
-  Report timestamps of ioctls with dmsetup -vvv.
-  Recognize report field name variants without any underscores too.
-  Add dmsetup --interval and --count to repeat reports at specified intervals.
-  Add dm_timestamp functions to libdevmapper.
-  Recognise vg/lv name format in dmsetup.
-  Move size display code to libdevmapper as dm_size_to_string.
-
-Version 1.02.103 - 24th July 2015
-=================================
-  Introduce libdevmapper wrappers for all malloc-related functions.
-
-Version 1.02.102 - 7th July 2015
+Version 1.02.100 - 
 ================================
-  Include tool.h for default non-library use.
-  Introduce format macros with embedded % such as FMTu64.
-
-Version 1.02.101 - 3rd July 2015
-================================
-  Add experimental support to passing messages in suspend tree.
-  Add dm_report_value_cache_{set,get} to support caching during report/select.
-  Add dm_report_reserved_handler to handle report reserved value actions.
-  Support dynamic value in select: DM_REPORT_FIELD_RESERVED_VALUE_DYNAMIC_VALUE.
-  Support fuzzy names in select: DM_REPORT_FIELD_RESERVED_VALUE_FUZZY_NAMES.
-  Thin pool trace messages show a device name and major:minor.
-
-Version 1.02.100 - 30th June 2015
-=================================
-  Add since, after, until and before time operators to be used in selection.
-  Add support for time in reports and selection: DM_REPORT_FIELD_TYPE_TIME.
-  Support report reserved value ranges: DM_REPORT_FIELD_RESERVED_VALUE_RANGE.
-  Support report reserved value names: DM_REPORT_FIELD_RESERVED_VALUE_NAMED.
   Add DM_CONFIG_VALUE_FMT_{INT_OCTAL,STRING_NO_QUOTES} config value format flag.
   Add DM_CONFIG_VALUE_FMT_COMMON_{ARRAY,EXTRA_SPACE} config value format flag.
   Add dm_config_value_{get,set}_format_flags to get and set config value format.

aclocal.m4

@@ -15,7 +15,7 @@ m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun
 # 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

conf/.gitignore

@@ -1,6 +0,0 @@
-command_profile_template.profile
-example.conf
-lvmlocal.conf
-metadata_profile_template.profile
-configure.h
-lvm-version.h

conf/Makefile.in

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.
+# Copyright (C) 2004-2010 Red Hat, Inc. All rights reserved.
 #
 # This file is part of LVM2.
 #
@@ -20,11 +20,7 @@ CONFDEST=lvm.conf
 CONFLOCAL=lvmlocal.conf
 
 PROFILE_TEMPLATES=command_profile_template.profile metadata_profile_template.profile
-PROFILES=$(PROFILE_TEMPLATES) \
-	$(srcdir)/cache-mq.profile \
-	$(srcdir)/cache-smq.profile \
-	$(srcdir)/thin-generic.profile \
-	$(srcdir)/thin-performance.profile
+PROFILES=$(PROFILE_TEMPLATES) $(srcdir)/thin-generic.profile $(srcdir)/thin-performance.profile
 
 include $(top_builddir)/make.tmpl
 

conf/cache-mq.profile

@@ -1,20 +0,0 @@
-# Demo configuration 'mq' cache policy
-#
-# Note: This policy has been deprecated in favor of the smq policy
-# keyword "default" means, setting is left with kernel defaults.
-#
-
-allocation {
-	cache_pool_chunk_size = 64
-	cache_mode = "writethrough"
-	cache_policy = "mq"
-	cache_settings {
-		mq {
-			sequential_threshold = "default"	#  #nr_sequential_ios
-			random_threshold = "default"		#  #nr_random_ios
-			read_promote_adjustment = "default"
-			write_promote_adjustment = "default"
-			discard_promote_adjustment = "default"
-		}
-	}
-}

conf/cache-smq.profile

@@ -1,14 +0,0 @@
-# Demo configuration 'smq' cache policy
-#
-# The stochastic multi-queue (smq) policy addresses some of the problems
-# with the multiqueue (mq) policy and uses less memory.
-#
-
-allocation {
-	cache_pool_chunk_size = 64
-	cache_mode = "writethrough"
-	cache_policy = "smq"
-	cache_settings {
-	        # currently no settins for "smq" policy
-	}
-}

conf/lvmlocal.conf.in

@@ -24,33 +24,29 @@ local {
 
 	# Configuration option local/system_id.
 	# Defines the local system ID for lvmlocal mode.
-	# This is used when global/system_id_source is set to 'lvmlocal' in the
-	# main configuration file, e.g. lvm.conf. When used, it must be set to
-	# a unique value among all hosts sharing access to the storage,
+	# This is used when global/system_id_source is set
+	# to 'lvmlocal' in the main configuration file,
+	# e.g. lvm.conf.
+	# When used, it must be set to a unique value
+	# among all hosts sharing access to the storage,
 	# e.g. a host name.
-	# 
-	# Example
-	# Set no system ID:
+	# Example:
+	# Set no system ID.
 	# system_id = ""
-	# Set the system_id to a specific name:
+	# Example:
+	# Set the system_id to the string 'host1'.
 	# system_id = "host1"
-	# 
-	# This configuration option has an automatic default value.
 	# system_id = ""
 
 	# Configuration option local/extra_system_ids.
 	# A list of extra VG system IDs the local host can access.
-	# VGs with the system IDs listed here (in addition to the host's own
-	# system ID) can be fully accessed by the local host. (These are
-	# system IDs that the host sees in VGs, not system IDs that identify
-	# the local host, which is determined by system_id_source.)
-	# Use this only after consulting 'man lvmsystemid' to be certain of
-	# correct usage and possible dangers.
+	# VGs with the system IDs listed here (in addition
+	# to the host's own system ID) can be fully accessed
+	# by the local host.  (These are system IDs that the
+	# host sees in VGs, not system IDs that identify the
+	# local host, which is determined by system_id_source.)
+	# Use this only after consulting 'man lvmsystemid'
+	# to be certain of correct usage and possible dangers.
 	# This configuration option does not have a default value defined.
-
-	# Configuration option local/host_id.
-	# The lvmlockd sanlock host_id.
-	# This must be unique among all hosts, and must be between 1 and 2000.
-	# This configuration option has an automatic default value.
-	# host_id = 0
+	# extra_system_ids = [ ]
 }

configure.in

@@ -16,7 +16,7 @@ AC_PREREQ(2.61)
 dnl -- Process this file with autoconf to produce a configure script.
 AC_INIT
 AC_CONFIG_SRCDIR([lib/device/dev-cache.h])
-AC_CONFIG_HEADERS([include/configure.h])
+AC_CONFIG_HEADERS([lib/misc/configure.h])
 
 ################################################################################
 dnl -- Setup the directory where autoconf has auxilary files
@@ -40,8 +40,6 @@ case "$host_os" in
 		LVMETAD=no
 		LVMPOLLD=no
 		LVMLOCKD=no
-		LOCKDSANLOCK=no
-		LOCKDDLM=no
 		ODIRECT=yes
 		DM_IOCTLS=yes
 		SELINUX=yes
@@ -91,19 +89,14 @@ AC_PATH_TOOL(CSCOPE_CMD, cscope)
 dnl -- Check for header files.
 AC_HEADER_DIRENT
 AC_HEADER_MAJOR
-AC_HEADER_STDBOOL
 AC_HEADER_STDC
 AC_HEADER_SYS_WAIT
 AC_HEADER_TIME
 
-AC_CHECK_HEADERS([assert.h ctype.h dirent.h errno.h fcntl.h float.h \
-  getopt.h inttypes.h langinfo.h libgen.h limits.h locale.h paths.h \
-  signal.h stdarg.h stddef.h stdio.h stdlib.h string.h sys/file.h \
-  sys/ioctl.h syslog.h sys/mman.h sys/param.h sys/resource.h sys/stat.h \
-  sys/time.h sys/types.h sys/utsname.h sys/wait.h time.h \
-  unistd.h], , [AC_MSG_ERROR(bailing out)])
-
-AC_CHECK_HEADERS(termios.h sys/statvfs.h sys/timerfd.h)
+AC_CHECK_HEADERS([locale.h stddef.h syslog.h sys/file.h sys/time.h assert.h \
+  langinfo.h libgen.h signal.h sys/mman.h sys/resource.h sys/utsname.h \
+  sys/wait.h time.h], ,
+  [AC_MSG_ERROR(bailing out)])
 
 case "$host_os" in
 	linux*)
@@ -112,13 +105,16 @@ case "$host_os" in
 		AC_CHECK_HEADERS(machine/endian.h sys/disk.h,,AC_MSG_ERROR(bailing out)) ;;
 esac
 
+AC_CHECK_HEADERS([ctype.h dirent.h errno.h fcntl.h getopt.h inttypes.h limits.h \
+  stdarg.h stdio.h stdlib.h string.h sys/ioctl.h sys/param.h sys/stat.h \
+  sys/types.h unistd.h], , [AC_MSG_ERROR(bailing out)])
+AC_CHECK_HEADERS(termios.h sys/statvfs.h)
+
 ################################################################################
 dnl -- Check for typedefs, structures, and compiler characteristics.
 AC_C_CONST
 AC_C_INLINE
 AC_CHECK_MEMBERS([struct stat.st_rdev])
-AC_CHECK_TYPES([ptrdiff_t])
-AC_STRUCT_TM
 AC_TYPE_OFF_T
 AC_TYPE_PID_T
 AC_TYPE_SIGNAL
@@ -134,13 +130,15 @@ AC_TYPE_UINT8_T
 AC_TYPE_UINT16_T
 AC_TYPE_UINT32_T
 AC_TYPE_UINT64_T
+AC_CHECK_MEMBERS([struct stat.st_rdev])
+AC_STRUCT_TM
 
 ################################################################################
 dnl -- Check for functions
-AC_CHECK_FUNCS([ftruncate gethostname getpagesize gettimeofday localtime_r \
-  memchr memset mkdir mkfifo munmap nl_langinfo realpath rmdir setenv \
-  setlocale strcasecmp strchr strcspn strdup strerror strncasecmp strndup \
-  strrchr strspn strstr strtol strtoul uname], , [AC_MSG_ERROR(bailing out)])
+AC_CHECK_FUNCS([ftruncate gethostname getpagesize \
+  gettimeofday memset mkdir mkfifo rmdir munmap nl_langinfo setenv setlocale \
+  strcasecmp strchr strcspn strspn strdup strncasecmp strerror strrchr \
+  strstr strtol strtoul uname], , [AC_MSG_ERROR(bailing out)])
 AC_FUNC_ALLOCA
 AC_FUNC_CLOSEDIR_VOID
 AC_FUNC_CHOWN
@@ -148,22 +146,12 @@ AC_FUNC_FORK
 AC_FUNC_LSTAT
 AC_FUNC_MALLOC
 AC_FUNC_MEMCMP
-AC_FUNC_MKTIME
 AC_FUNC_MMAP
 AC_FUNC_REALLOC
 AC_FUNC_STAT
 AC_FUNC_STRTOD
 AC_FUNC_VPRINTF
 
-################################################################################
-dnl -- Disable dependency tracking
-AC_MSG_CHECKING(whether to enable dependency tracking)
-AC_ARG_ENABLE(dependency-tracking,
-	      AC_HELP_STRING([--disable-dependency-tracking],
-			     [speeds up one-time build.]),
-	      USE_TRACKING=$enableval, USE_TRACKING=yes)
-AC_MSG_RESULT($USE_TRACKING)
-
 ################################################################################
 dnl -- Enables statically-linked tools
 AC_MSG_CHECKING(whether to use static linking)
@@ -184,9 +172,6 @@ AC_SUBST(HAVE_FULL_RELRO)
 ################################################################################
 dnl -- Prefix is /usr by default, the exec_prefix default is setup later
 AC_PREFIX_DEFAULT(/usr)
-if test "$prefix" = NONE; then
-  datarootdir=${ac_default_prefix}/share
-fi
 
 ################################################################################
 dnl -- Setup the ownership of the files
@@ -279,13 +264,8 @@ AC_ARG_ENABLE(lvm1_fallback,
 AC_MSG_RESULT($LVM1_FALLBACK)
 
 if test "$LVM1_FALLBACK" = yes; then
-	DEFAULT_FALLBACK_TO_LVM1=1
 	AC_DEFINE([LVM1_FALLBACK], 1, [Define to 1 if 'lvm' should fall back to using LVM1 binaries if device-mapper is missing from the kernel])
-else
-	DEFAULT_FALLBACK_TO_LVM1=0
 fi
-AC_DEFINE_UNQUOTED(DEFAULT_FALLBACK_TO_LVM1, [$DEFAULT_FALLBACK_TO_LVM1],
-		   [Fall back to LVM1 by default if device-mapper is missing from the kernel.])
 
 ################################################################################
 dnl -- format1 inclusion type
@@ -573,12 +553,6 @@ case "$CACHE" in
  *) AC_MSG_ERROR([--with-cache parameter invalid]) ;;
 esac
 
-dnl -- cache_check needs-check flag
-AC_ARG_ENABLE(cache_check_needs_check,
-	      AC_HELP_STRING([--disable-cache_check_needs_check],
-			     [required if cache_check version is < 0.5]),
-	      CACHE_CHECK_NEEDS_CHECK=$enableval, CACHE_CHECK_NEEDS_CHECK=yes)
-
 # Test if necessary cache tools are available
 # if not - use plain defaults and warn user
 case "$CACHE" in
@@ -592,28 +566,6 @@ case "$CACHE" in
 			CACHE_CONFIGURE_WARN=y
 		fi
 	fi
-	if test "$CACHE_CHECK_NEEDS_CHECK" = yes; then
-		$CACHE_CHECK_CMD -V 2>/dev/null >conftest.tmp
-		read -r CACHE_CHECK_VSN < conftest.tmp
-		IFS=.- read -r CACHE_CHECK_VSN_MAJOR CACHE_CHECK_VSN_MINOR CACHE_CHECK_VSN_PATCH LEFTOVER < conftest.tmp
-		rm -f conftest.tmp
-
-		# Require version >= 0.5.4 for --clear-needs-check-flag
-		if test -z "$CACHE_CHECK_VSN_MAJOR" \
-			|| test -z "$CACHE_CHECK_VSN_MINOR" \
-			|| test -z "$CACHE_CHECK_VSN_PATCH"; then
-			AC_MSG_WARN([$CACHE_CHECK_CMD: Bad version "$CACHE_CHECK_VSN" found])
-			CACHE_CHECK_VERSION_WARN=y
-			CACHE_CHECK_NEEDS_CHECK=no
-		elif test "$CACHE_CHECK_VSN_MAJOR" -eq 0 ; then
-			if test "$CACHE_CHECK_VSN_MINOR" -lt 5 \
-				|| test "$CACHE_CHECK_VSN_MINOR" -eq 5 -a "$CACHE_CHECK_VSN_PATCH" -lt 4; then
-				AC_MSG_WARN([$CACHE_CHECK_CMD: Old version "$CACHE_CHECK_VSN" found])
-				CACHE_CHECK_VERSION_WARN=y
-				CACHE_CHECK_NEEDS_CHECK=no
-			fi
-		fi
-	fi
 	# Empty means a config way to ignore cache dumping
 	if test "$CACHE_DUMP_CMD" = "autodetect"; then
 		AC_PATH_TOOL(CACHE_DUMP_CMD, cache_dump)
@@ -641,12 +593,6 @@ case "$CACHE" in
 			CACHE_CONFIGURE_WARN=y
 		}
 	fi
-
-	AC_MSG_CHECKING([whether cache_check supports the needs-check flag])
-	AC_MSG_RESULT([$CACHE_CHECK_NEEDS_CHECK])
-	if test "$CACHE_CHECK_NEEDS_CHECK" = yes; then
-		AC_DEFINE([CACHE_CHECK_NEEDS_CHECK], 1, [Define to 1 if the external 'cache_check' tool requires the --clear-needs-check-flag option])
-	fi
 	;;
 esac
 
@@ -675,8 +621,8 @@ AC_MSG_RESULT($READLINE)
 dnl -- Disable realtime clock support
 AC_MSG_CHECKING(whether to enable realtime support)
 AC_ARG_ENABLE(realtime,
-	      AC_HELP_STRING([--disable-realtime], [disable realtime clock support]),
-	      REALTIME=$enableval, REALTIME=yes)
+	      AC_HELP_STRING([--enable-realtime], [enable realtime clock support]),
+	      REALTIME=$enableval)
 AC_MSG_RESULT($REALTIME)
 
 ################################################################################
@@ -1081,13 +1027,6 @@ if test "$TESTING" = yes; then
 	PKG_CHECK_MODULES(CUNIT, cunit >= 2.0)
 fi
 
-################################################################################
-dnl -- Set LVM2 testsuite data
-TESTSUITE_DATA='${datarootdir}/lvm2-testsuite'
-# double eval needed ${datarootdir} -> ${prefix}/share -> real path
-AC_DEFINE_UNQUOTED(TESTSUITE_DATA, ["$(eval echo $(eval echo $TESTSUITE_DATA))"], [Path to testsuite data])
-
-
 ################################################################################
 dnl -- Enable valgrind awareness of memory pools
 AC_MSG_CHECKING(whether to enable valgrind awareness of pools)
@@ -1133,96 +1072,6 @@ AC_MSG_RESULT($LVMETAD)
 
 BUILD_LVMETAD=$LVMETAD
 
-################################################################################
-dnl -- Build lvmpolld
-AC_MSG_CHECKING(whether to build lvmpolld)
-AC_ARG_ENABLE(lvmpolld,
-	      AC_HELP_STRING([--enable-lvmpolld],
-			     [enable the LVM Polling Daemon]),
-	      LVMPOLLD=$enableval)
-AC_MSG_RESULT($LVMPOLLD)
-
-BUILD_LVMPOLLD=$LVMPOLLD
-
-################################################################################
-dnl -- Build lockdsanlock
-AC_MSG_CHECKING(whether to build lockdsanlock)
-AC_ARG_ENABLE(lockd-sanlock,
-	      AC_HELP_STRING([--enable-lockd-sanlock],
-			     [enable the LVM lock daemon using sanlock]),
-	      LOCKDSANLOCK=$enableval)
-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)
-	BUILD_LVMLOCKD=yes
-fi
-
-################################################################################
-dnl -- Build lockddlm
-AC_MSG_CHECKING(whether to build lockddlm)
-AC_ARG_ENABLE(lockd-dlm,
-	      AC_HELP_STRING([--enable-lockd-dlm],
-			     [enable the LVM lock daemon using dlm]),
-	      LOCKDDLM=$enableval)
-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)
-	BUILD_LVMLOCKD=yes
-fi
-
-################################################################################
-dnl -- Build lvmlockd
-
-AC_MSG_CHECKING(whether to build lvmlockd)
-AC_MSG_RESULT($BUILD_LVMLOCKD)
-
-if test "$BUILD_LVMLOCKD" = yes; then
-	AS_IF([test -n "$BUILD_LVMPOLLD"], [BUILD_LVMPOLLD=yes; AC_MSG_WARN([Enabling lvmpolld - required by lvmlockd.])])
-	AS_IF([test -n "$BUILD_LVMETAD"], [BUILD_LVMETAD=yes; AC_MSG_WARN([Enabling lvmetad - required by lvmlockd.])])
-	AC_MSG_CHECKING([defaults for use_lvmlockd])
-	AC_ARG_ENABLE(use_lvmlockd,
-		      AC_HELP_STRING([--disable-use-lvmlockd],
-				     [disable usage of LVM lock daemon]),
-		      [case ${enableval} in
-		       yes) DEFAULT_USE_LVMLOCKD=1 ;;
-		       *) DEFAULT_USE_LVMLOCKD=0 ;;
-		       esac], DEFAULT_USE_LVMLOCKD=1)
-	AC_MSG_RESULT($DEFAULT_USE_LVMLOCKD)
-	AC_DEFINE([LVMLOCKD_SUPPORT], 1, [Define to 1 to include code that uses lvmlockd.])
-
-	AC_ARG_WITH(lvmlockd-pidfile,
-		    AC_HELP_STRING([--with-lvmlockd-pidfile=PATH],
-				   [lvmlockd pidfile [PID_DIR/lvmlockd.pid]]),
-		    LVMLOCKD_PIDFILE=$withval,
-		    LVMLOCKD_PIDFILE="$DEFAULT_PID_DIR/lvmlockd.pid")
-	AC_DEFINE_UNQUOTED(LVMLOCKD_PIDFILE, ["$LVMLOCKD_PIDFILE"],
-			   [Path to lvmlockd pidfile.])
-else
-	DEFAULT_USE_LVMLOCKD=0
-fi
-AC_DEFINE_UNQUOTED(DEFAULT_USE_LVMLOCKD, [$DEFAULT_USE_LVMLOCKD],
-		   [Use lvmlockd by default.])
-
-################################################################################
-dnl -- Check lvmetad
 if test "$BUILD_LVMETAD" = yes; then
 	AC_MSG_CHECKING([defaults for use_lvmetad])
 	AC_ARG_ENABLE(use_lvmetad,
@@ -1249,7 +1098,16 @@ AC_DEFINE_UNQUOTED(DEFAULT_USE_LVMETAD, [$DEFAULT_USE_LVMETAD],
 		   [Use lvmetad by default.])
 
 ################################################################################
-dnl -- Check lvmpolld
+dnl -- Build lvmpolld
+AC_MSG_CHECKING(whether to build lvmpolld)
+AC_ARG_ENABLE(lvmpolld,
+	      AC_HELP_STRING([--enable-lvmpolld],
+			     [enable the LVM Polling Daemon]),
+	      LVMPOLLD=$enableval)
+AC_MSG_RESULT($LVMPOLLD)
+
+BUILD_LVMPOLLD=$LVMPOLLD
+
 if test "$BUILD_LVMPOLLD" = yes; then
 	AC_MSG_CHECKING([defaults for use_lvmpolld])
 	AC_ARG_ENABLE(use_lvmpolld,
@@ -1275,6 +1133,49 @@ fi
 AC_DEFINE_UNQUOTED(DEFAULT_USE_LVMPOLLD, [$DEFAULT_USE_LVMPOLLD],
 		   [Use lvmpolld by default.])
 
+################################################################################
+dnl -- Build lvmlockd
+AC_MSG_CHECKING(whether to build lvmlockd)
+AC_ARG_ENABLE(lvmlockd,
+	      AC_HELP_STRING([--enable-lvmlockd],
+			     [enable the LVM lock daemon]),
+	      LVMLOCKD=$enableval)
+AC_MSG_RESULT($LVMLOCKD)
+
+BUILD_LVMLOCKD=$LVMLOCKD
+
+if test "$BUILD_LVMLOCKD" = yes; then
+	AC_MSG_CHECKING([defaults for use_lvmlockd])
+	AC_ARG_ENABLE(use_lvmlockd,
+		      AC_HELP_STRING([--disable-use-lvmlockd],
+				     [disable usage of LVM lock daemon]),
+		      [case ${enableval} in
+		       yes) DEFAULT_USE_LVMLOCKD=1 ;;
+		       *) DEFAULT_USE_LVMLOCKD=0 ;;
+		       esac], DEFAULT_USE_LVMLOCKD=1)
+	AC_MSG_RESULT($DEFAULT_USE_LVMLOCKD)
+	AC_DEFINE([LVMLOCKD_SUPPORT], 1, [Define to 1 to include code that uses lvmlockd.])
+
+	AC_ARG_WITH(lvmlockd-pidfile,
+		    AC_HELP_STRING([--with-lvmlockd-pidfile=PATH],
+				   [lvmlockd pidfile [PID_DIR/lvmlockd.pid]]),
+		    LVMLOCKD_PIDFILE=$withval,
+		    LVMLOCKD_PIDFILE="$DEFAULT_PID_DIR/lvmlockd.pid")
+	AC_DEFINE_UNQUOTED(LVMLOCKD_PIDFILE, ["$LVMLOCKD_PIDFILE"],
+			   [Path to lvmlockd pidfile.])
+else
+	DEFAULT_USE_LVMLOCKD=0
+fi
+AC_DEFINE_UNQUOTED(DEFAULT_USE_LVMLOCKD, [$DEFAULT_USE_LVMLOCKD],
+		   [Use lvmlockd by default.])
+
+################################################################################
+dnl -- Look for sanlock and dlm libraries
+if test "$BUILD_LVMLOCKD" = yes; then
+	PKG_CHECK_MODULES(LOCKD_SANLOCK, libsanlock_client, [HAVE_LOCKD_SANLOCK=yes], $bailout)
+	PKG_CHECK_MODULES(LOCKD_DLM, libdlm, [HAVE_LOCKD_DLM=yes], $bailout)
+fi
+
 ################################################################################
 
 dnl -- Enable blkid wiping functionality
@@ -1546,10 +1447,6 @@ if [[ \( "$LVM1" = shared -o "$POOL" = shared -o "$CLUSTER" = shared \
 	AC_MSG_ERROR([Features cannot be 'shared' when building statically])
 fi
 
-################################################################################
-AC_CHECK_LIB(m, log10,
-	[M_LIBS="-lm"], hard_bailout)
-
 ################################################################################
 AC_CHECK_LIB([pthread], [pthread_mutex_lock],
 	[PTHREAD_LIBS="-lpthread"], hard_bailout)
@@ -1590,7 +1487,6 @@ if test "$REALTIME" = yes; then
 	if test "$HAVE_REALTIME" = yes; then
 		AC_DEFINE([HAVE_REALTIME], 1, [Define to 1 to include support for realtime clock.])
 		LIBS="-lrt $LIBS"
-		RT_LIB="-lrt"
 	else
 		AC_MSG_WARN(Disabling realtime clock)
 	fi
@@ -1741,19 +1637,6 @@ if test "$READLINE" = yes; then
 	AC_CHECK_HEADERS(readline/readline.h readline/history.h,,hard_bailout)
 fi
 
-if test "$BUILD_CMIRRORD" = yes; then
-	AC_CHECK_FUNCS(atexit,,hard_bailout)
-fi
-
-if test "$BUILD_LVMLOCKD" = yes; then
-	AC_CHECK_FUNCS(clock_gettime strtoull,,hard_bailout)
-fi
-
-if test "$BUILD_LVMPOLLD" = yes; then
-	AC_CHECK_FUNCS(strpbrk,,hard_bailout)
-	AC_FUNC_STRERROR_R
-fi
-
 if test "$CLVMD" != none; then
 	AC_CHECK_HEADERS(mntent.h netdb.h netinet/in.h pthread.h search.h sys/mount.h sys/socket.h sys/uio.h sys/un.h utmpx.h,,AC_MSG_ERROR(bailing out))
 	AC_CHECK_FUNCS(dup2 getmntent memmove select socket,,hard_bailout)
@@ -1796,10 +1679,12 @@ test "$lvm_exec_prefix" = NONE && lvm_exec_prefix=$ac_default_prefix
 LVM_PATH="$lvm_exec_prefix/sbin/lvm"
 AC_DEFINE_UNQUOTED(LVM_PATH, ["$LVM_PATH"], [Path to lvm binary.])
 
-clvmd_prefix=$ac_default_prefix
-test "$prefix" != NONE && clvmd_prefix=$prefix
-CLVMD_PATH="$clvmd_prefix/sbin/clvmd"
-AC_DEFINE_UNQUOTED(CLVMD_PATH, ["$CLVMD_PATH"], [Path to clvmd binary.])
+if  test "$CLVMD" != none; then
+	clvmd_prefix=$ac_default_prefix
+	test "$prefix" != NONE && clvmd_prefix=$prefix
+	CLVMD_PATH="$clvmd_prefix/sbin/clvmd"
+	AC_DEFINE_UNQUOTED(CLVMD_PATH, ["$CLVMD_PATH"], [Path to clvmd binary.])
+fi
 
 ################################################################################
 dnl -- dmeventd pidfile and executable path
@@ -1888,14 +1773,14 @@ test "$interface" != ioctl && AC_MSG_ERROR([--with-interface=ioctl required. fs
 AC_MSG_RESULT($interface)
 
 ################################################################################
-read DM_LIB_VERSION < "$srcdir"/VERSION_DM 2>/dev/null || DM_LIB_VERSION=Unknown
-AC_DEFINE_UNQUOTED(DM_LIB_VERSION, "$DM_LIB_VERSION", [Library version])
+DM_LIB_VERSION="\"`cat "$srcdir"/VERSION_DM 2>/dev/null || echo Unknown`\""
+AC_DEFINE_UNQUOTED(DM_LIB_VERSION, $DM_LIB_VERSION, [Library version])
 
 DM_LIB_PATCHLEVEL=`cat "$srcdir"/VERSION_DM | $AWK -F '[[-. ]]' '{printf "%s.%s.%s",$1,$2,$3}'`
 
-read VER < "$srcdir"/VERSION 2>/dev/null || VER=Unknown
+LVM_VERSION="\"`cat "$srcdir"/VERSION 2>/dev/null || echo Unknown`\""
 
-LVM_VERSION=\"$VER\"
+VER=`cat "$srcdir"/VERSION`
 LVM_RELEASE_DATE="\"`echo $VER | $SED 's/.* (//;s/).*//'`\""
 VER=`echo "$VER" | $AWK '{print $1}'`
 LVM_RELEASE="\"`echo "$VER" | $AWK -F '-' '{print $2}'`\""
@@ -1914,8 +1799,6 @@ AC_SUBST(BUILD_DMEVENTD)
 AC_SUBST(BUILD_LVMETAD)
 AC_SUBST(BUILD_LVMPOLLD)
 AC_SUBST(BUILD_LVMLOCKD)
-AC_SUBST(BUILD_LOCKDSANLOCK)
-AC_SUBST(BUILD_LOCKDDLM)
 AC_SUBST(CACHE)
 AC_SUBST(CFLAGS)
 AC_SUBST(CFLOW_CMD)
@@ -1945,7 +1828,6 @@ AC_SUBST(DEFAULT_CACHE_SUBDIR)
 AC_SUBST(DEFAULT_DATA_ALIGNMENT)
 AC_SUBST(DEFAULT_DM_RUN_DIR)
 AC_SUBST(DEFAULT_LOCK_DIR)
-AC_SUBST(DEFAULT_FALLBACK_TO_LVM1)
 AC_SUBST(DEFAULT_MIRROR_SEGTYPE)
 AC_SUBST(DEFAULT_PID_DIR)
 AC_SUBST(DEFAULT_PROFILE_SUBDIR)
@@ -1963,6 +1845,7 @@ AC_SUBST(DLM_LIBS)
 AC_SUBST(DL_LIBS)
 AC_SUBST(DMEVENTD)
 AC_SUBST(DMEVENTD_PATH)
+AC_SUBST(DM_LIB_VERSION)
 AC_SUBST(DM_LIB_PATCHLEVEL)
 AC_SUBST(ELDFLAGS)
 AC_SUBST(FSADM)
@@ -1993,7 +1876,6 @@ AC_SUBST(OCF)
 AC_SUBST(OCFDIR)
 AC_SUBST(PKGCONFIG)
 AC_SUBST(POOL)
-AC_SUBST(M_LIBS)
 AC_SUBST(PTHREAD_LIBS)
 AC_SUBST(PYTHON)
 AC_SUBST(PYTHON_BINDINGS)
@@ -2002,7 +1884,6 @@ AC_SUBST(PYTHON_LIBDIRS)
 AC_SUBST(QUORUM_CFLAGS)
 AC_SUBST(QUORUM_LIBS)
 AC_SUBST(RAID)
-AC_SUBST(RT_LIB)
 AC_SUBST(READLINE_LIBS)
 AC_SUBST(REPLICATORS)
 AC_SUBST(SACKPT_CFLAGS)
@@ -2015,7 +1896,6 @@ AC_SUBST(SNAPSHOTS)
 AC_SUBST(STATICDIR)
 AC_SUBST(STATIC_LINK)
 AC_SUBST(TESTING)
-AC_SUBST(TESTSUITE_DATA)
 AC_SUBST(THIN)
 AC_SUBST(THIN_CHECK_CMD)
 AC_SUBST(THIN_DUMP_CMD)
@@ -2031,7 +1911,6 @@ AC_SUBST(UDEV_SYNC)
 AC_SUBST(UDEV_SYSTEMD_BACKGROUND_JOBS)
 AC_SUBST(UDEV_RULE_EXEC_DETECTION)
 AC_SUBST(UDEV_HAS_BUILTIN_BLKID)
-AC_SUBST(USE_TRACKING)
 AC_SUBST(VALGRIND_POOL)
 AC_SUBST(WRITE_INSTALL)
 AC_SUBST(DMEVENTD_PIDFILE)
@@ -2086,7 +1965,7 @@ lib/format_pool/Makefile
 lib/locking/Makefile
 lib/mirror/Makefile
 lib/replicator/Makefile
-include/lvm-version.h
+lib/misc/lvm-version.h
 lib/raid/Makefile
 lib/snapshot/Makefile
 lib/thin/Makefile
@@ -2148,3 +2027,9 @@ AS_IF([test -n "$CACHE_CONFIGURE_WARN"],
 
 AS_IF([test "$ODIRECT" != yes],
       [AC_MSG_WARN([O_DIRECT disabled: low-memory pvmove may lock up])])
+
+AS_IF([test "$BUILD_LVMLOCKD" == yes && test "$BUILD_LVMPOLLD" == no],
+      [AC_MSG_WARN([lvmlockd requires lvmpolld])])
+
+AS_IF([test "$BUILD_LVMLOCKD" == yes && test "$BUILD_LVMETAD" == no],
+      [AC_MSG_WARN([lvmlockd requires lvmetad])])

daemons/clvmd/.gitignore

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

daemons/clvmd/clvmd-command.c

@@ -323,7 +323,6 @@ void cmd_client_cleanup(struct local_client *client)
 	int lkid;
 	char *lockname;
 
-	DEBUGLOG("Client thread cleanup (%p)\n", client);
 	if (!client->bits.localsock.private)
 		return;
 
@@ -332,7 +331,7 @@ void cmd_client_cleanup(struct local_client *client)
 	dm_hash_iterate(v, lock_hash) {
 		lkid = (int)(long)dm_hash_get_data(lock_hash, v);
 		lockname = dm_hash_get_key(lock_hash, v);
-		DEBUGLOG("Cleanup (%p): Unlocking lock %s %x\n", client, lockname, lkid);
+		DEBUGLOG("cleanup: Unlocking lock %s %x\n", lockname, lkid);
 		(void) sync_unlock(lockname, lkid);
 	}
 
@@ -340,6 +339,7 @@ void cmd_client_cleanup(struct local_client *client)
 	client->bits.localsock.private = NULL;
 }
 
+
 static int restart_clvmd(void)
 {
 	const char **argv;

daemons/clvmd/clvmd-common.h

@@ -18,10 +18,15 @@
 #ifndef _LVM_CLVMD_COMMON_H
 #define _LVM_CLVMD_COMMON_H
 
+#include "configure.h"
+
 #define _REENTRANT
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
 
-#include "tool.h"
-
+#include "libdevmapper.h"
 #include "lvm-logging.h"
 
+#include <unistd.h>
+
 #endif

daemons/clvmd/clvmd-openais.c

@@ -243,7 +243,7 @@ static void openais_cpg_confchg_callback(cpg_handle_t handle,
 	struct node_info *ninfo;
 
 	DEBUGLOG("confchg callback. %" PRIsize_t " joined, "
-		 FMTsize_t " left, %" PRIsize_t " members\n",
+		 "%" PRIsize_t " left, %" PRIsize_t " members\n",
 		 joined_list_entries, left_list_entries, member_list_entries);
 
 	for (i=0; i<joined_list_entries; i++) {

daemons/clvmd/clvmd.c

@@ -154,7 +154,7 @@ static void usage(const char *prog, FILE *file)
 {
 	fprintf(file, "Usage: %s [options]\n"
 		"   -C       Sets debug level (from -d) on all clvmd instances clusterwide\n"
-		"   -d[<n>]  Set debug logging (0:none, 1:stderr (implies -f option), 2:syslog)\n"
+		"   -d[n]    Set debug logging (0:none, 1:stderr (implies -f option), 2:syslog)\n"
 		"   -E<uuid> Take this lock uuid as exclusively locked resource (for restart)\n"
 		"   -f       Don't fork, run in the foreground\n"
 		"   -h       Show this help information\n"
@@ -223,7 +223,6 @@ void debuglog(const char *fmt, ...)
 		fprintf(stderr, "CLVMD[%x]: %.15s ", (int)pthread_self(), ctime_r(&P, buf_ctime) + 4);
 		vfprintf(stderr, fmt, ap);
 		va_end(ap);
-		fflush(stderr);
 		break;
 	case DEBUG_SYSLOG:
 		if (!syslog_init) {
@@ -599,9 +598,7 @@ int main(int argc, char *argv[])
 
 	/* This needs to be started after cluster initialisation
 	   as it may need to take out locks */
-	DEBUGLOG("Starting LVM thread\n");
-	DEBUGLOG("Main cluster socket fd %d (%p) with local socket %d (%p)\n",
-		 local_client_head.fd, &local_client_head, newfd->fd, newfd);
+	DEBUGLOG("starting LVM thread\n");
 
 	/* Don't let anyone else to do work until we are started */
 	pthread_create(&lvm_thread, &stack_attr, lvm_thread_fn, &lvm_params);
@@ -701,7 +698,7 @@ static int local_rendezvous_callback(struct local_client *thisfd, char *buf,
 		newfd->type = LOCAL_SOCK;
 		newfd->callback = local_sock_callback;
 		newfd->bits.localsock.all_success = 1;
-		DEBUGLOG("Got new connection on fd %d (%p)\n", newfd->fd, newfd);
+		DEBUGLOG("Got new connection on fd %d\n", newfd->fd);
 		*new_client = newfd;
 	}
 	return 1;
@@ -853,48 +850,18 @@ static void main_loop(int cmd_timeout)
 		struct local_client *thisfd;
 		struct timeval tv = { cmd_timeout, 0 };
 		int quorate = clops->is_quorate();
-		int client_count = 0;
-		int max_fd = 0;
-		struct local_client *lastfd = &local_client_head;
-		struct local_client *nextfd = local_client_head.next;
 
 		/* Wait on the cluster FD and all local sockets/pipes */
 		local_client_head.fd = clops->get_main_cluster_fd();
 		FD_ZERO(&in);
-
 		for (thisfd = &local_client_head; thisfd; thisfd = thisfd->next) {
-			client_count++;
-			max_fd = max(max_fd, thisfd->fd);
-		}
-
-		if (max_fd > FD_SETSIZE - 32) {
-			fprintf(stderr, "WARNING: There are too many connections to clvmd.  Investigate and take action now!\n");
- 			fprintf(stderr, "WARNING: Your cluster may freeze up if the number of clvmd file descriptors (%d) exceeds %d.\n", max_fd + 1, FD_SETSIZE);
-		}
-
-		for (thisfd = &local_client_head; thisfd; thisfd = nextfd, nextfd = thisfd ? thisfd->next : NULL) {
-
-			if (thisfd->removeme && !cleanup_zombie(thisfd)) {
-				struct local_client *free_fd = thisfd;
-				lastfd->next = nextfd;
-				DEBUGLOG("removeme set for %p with %d monitored fds remaining\n", free_fd, client_count - 1);
-
-				/* Queue cleanup, this also frees the client struct */
-				add_to_lvmqueue(free_fd, NULL, 0, NULL);
-
-				continue;
-			}
-
-			lastfd = thisfd;
-
 			if (thisfd->removeme)
 				continue;
 
 			/* if the cluster is not quorate then don't listen for new requests */
 			if ((thisfd->type != LOCAL_RENDEZVOUS &&
 			     thisfd->type != LOCAL_SOCK) || quorate)
-				if (thisfd->fd < FD_SETSIZE)
-					FD_SET(thisfd->fd, &in);
+				FD_SET(thisfd->fd, &in);
 		}
 
 		select_status = select(FD_SETSIZE, &in, NULL, NULL, &tv);
@@ -910,20 +877,31 @@ static void main_loop(int cmd_timeout)
 		}
 
 		if (select_status > 0) {
+			struct local_client *lastfd = NULL;
 			char csid[MAX_CSID_LEN];
 			char buf[max_cluster_message];
 
 			for (thisfd = &local_client_head; thisfd; thisfd = thisfd->next) {
-				if (thisfd->fd < FD_SETSIZE && FD_ISSET(thisfd->fd, &in)) {
+				if (thisfd->removeme && !cleanup_zombie(thisfd)) {
+					struct local_client *free_fd = thisfd;
+					lastfd->next = thisfd->next;
+					DEBUGLOG("removeme set for fd %d\n", free_fd->fd);
+
+					/* Queue cleanup, this also frees the client struct */
+					add_to_lvmqueue(free_fd, NULL, 0, NULL);
+					break;
+				}
+
+				if (FD_ISSET(thisfd->fd, &in)) {
 					struct local_client *newfd = NULL;
 					int ret;
 
-					/* FIXME Remove from main thread in case it blocks! */
 					/* Do callback */
 					ret = thisfd->callback(thisfd, buf, sizeof(buf),
 							       csid, &newfd);
 					/* Ignore EAGAIN */
 					if (ret < 0 && (errno == EAGAIN || errno == EINTR)) {
+						lastfd = thisfd;
 						continue;
                                         }
 
@@ -939,16 +917,17 @@ static void main_loop(int cmd_timeout)
 						DEBUGLOG("ret == %d, errno = %d. removing client\n",
 							 ret, errno);
 						thisfd->removeme = 1;
-						continue;
+						break;
 					}
 
 					/* New client...simply add it to the list */
 					if (newfd) {
 						newfd->next = thisfd->next;
 						thisfd->next = newfd;
-						thisfd = newfd;
+						break;
 					}
 				}
+				lastfd = thisfd;
 			}
 		}
 
@@ -1441,7 +1420,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 	thisfd->bits.localsock.in_progress = TRUE;
 	thisfd->bits.localsock.state = PRE_COMMAND;
 	thisfd->bits.localsock.cleanup_needed = 1;
-	DEBUGLOG("Creating pre&post thread for pipe fd %d (%p)\n", newfd->fd, newfd);
+	DEBUGLOG("Creating pre&post thread\n");
 	status = pthread_create(&thisfd->bits.localsock.threadid,
 				&stack_attr, pre_and_post_thread, thisfd);
 	DEBUGLOG("Created pre&post thread, state = %d\n", status);
@@ -1695,7 +1674,7 @@ static __attribute__ ((noreturn)) void *pre_and_post_thread(void *arg)
 	sigset_t ss;
 	int pipe_fd = client->bits.localsock.pipe;
 
-	DEBUGLOG("Pre&post thread (%p), pipe fd %d\n", client, pipe_fd);
+	DEBUGLOG("Pre&post thread (%p), pipe %d\n", client, pipe_fd);
 	pthread_mutex_lock(&client->bits.localsock.mutex);
 
 	/* Ignore SIGUSR1 (handled by master process) but enable
@@ -1715,7 +1694,7 @@ static __attribute__ ((noreturn)) void *pre_and_post_thread(void *arg)
 		if ((status = do_pre_command(client)))
 			client->bits.localsock.all_success = 0;
 
-		DEBUGLOG("Pre&post thread (%p) writes status %d down to pipe fd %d\n",
+		DEBUGLOG("Pre&post thread (%p) writes status %d down to pipe %d\n",
 			 client, status, pipe_fd);
 
 		/* Tell the parent process we have finished this bit */
@@ -1997,7 +1976,7 @@ static int process_work_item(struct lvm_thread_cmd *cmd)
 {
 	/* If msg is NULL then this is a cleanup request */
 	if (cmd->msg == NULL) {
-		DEBUGLOG("process_work_item: free %p\n", cmd->client);
+		DEBUGLOG("process_work_item: free fd %d\n", cmd->client->fd);
 		cmd_client_cleanup(cmd->client);
 		pthread_mutex_destroy(&cmd->client->bits.localsock.mutex);
 		pthread_cond_destroy(&cmd->client->bits.localsock.cond);

daemons/clvmd/lvm-functions.c

@@ -510,7 +510,7 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 	DEBUGLOG("do_lock_lv: resource '%s', cmd = %s, flags = %s, critical_section = %d\n",
 		 resource, decode_locking_cmd(command), decode_flags(lock_flags), critical_section());
 
-	if (!cmd->initialized.config || config_files_changed(cmd)) {
+	if (!cmd->config_initialized || config_files_changed(cmd)) {
 		/* Reinitialise various settings inc. logging, filters */
 		if (do_refresh_cache()) {
 			log_error("Updated config file invalid. Aborting.");
@@ -899,7 +899,7 @@ int init_clvm(struct dm_hash_table *excl_uuid)
 	if (!get_initial_state(excl_uuid))
 		log_error("Cannot load initial lock states.");
 
-	if (!(cmd = create_toolcontext(1, NULL, 0, 1, 1, 1))) {
+	if (!(cmd = create_toolcontext(1, NULL, 0, 1))) {
 		log_error("Failed to allocate command context");
 		return 0;
 	}

daemons/cmirrord/.gitignore

@@ -1 +0,0 @@
-cmirrord

daemons/cmirrord/clogd.c

@@ -15,7 +15,6 @@
 #include "link_mon.h"
 #include "local.h"
 
-#include <getopt.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/socket.h>
@@ -33,49 +32,14 @@ static void daemonize(void);
 static void init_all(void);
 static void cleanup_all(void);
 
-static void usage (FILE *dest)
+int main(int argc __attribute__((unused)), char *argv[] __attribute__((unused)))
 {
-	fprintf (dest, "Usage: cmirrord [options]\n"
-		 "   -f, --foreground    stay in the foreground, log to the terminal\n"
-		 "   -h, --help          print this help\n");
-}
-
-int main(int argc, char *argv[])
-{
-	int foreground_mode = 0;
-	struct option longopts[] = {
-		{ "foreground", no_argument, NULL, 'f' },
-		{ "help"      , no_argument, NULL, 'h' },
-		{ 0, 0, 0, 0 }
-	};
-	int opt;
-
-	while ((opt = getopt_long (argc, argv, "fh", longopts, NULL)) != -1) {
-		switch (opt) {
-		case 'f':
-			foreground_mode = 1;
-			break;
-		case 'h':
-			usage (stdout);
-			exit (0);
-		default:
-			usage (stderr);
-			exit (2);
-		}
-	}
-	if (optind < argc) {
-		usage (stderr);
-		exit (2);
-	}
-
-	if (!foreground_mode)
-		daemonize();
+	daemonize();
 
 	init_all();
 
 	/* Parent can now exit, we're ready to handle requests */
-	if (!foreground_mode)
-		kill(getppid(), SIGTERM);
+	kill(getppid(), SIGTERM);
 
 	LOG_PRINT("Starting cmirrord:");
 	LOG_PRINT(" Built: "__DATE__" "__TIME__"\n");
@@ -245,16 +209,6 @@ static void daemonize(void)
 	}
 
 	LOG_OPEN("cmirrord", LOG_PID, LOG_DAEMON);
-}
-
-/*
- * init_all
- *
- * Initialize modules.  Exit on failure.
- */
-static void init_all(void)
-{
-	int r;
 
 	(void) dm_prepare_selinux_context(CMIRRORD_PIDFILE, S_IFREG);
 	if (dm_create_lockfile(CMIRRORD_PIDFILE) == 0)
@@ -273,6 +227,16 @@ static void init_all(void)
 	signal(SIGUSR2, &sig_handler);
 	sigemptyset(&signal_mask);
 	signal_received = 0;
+}
+
+/*
+ * init_all
+ *
+ * Initialize modules.  Exit on failure.
+ */
+static void init_all(void)
+{
+	int r;
 
 	if ((r = init_local()) ||
 	    (r = init_cluster())) {

daemons/cmirrord/cluster.c

@@ -104,11 +104,10 @@ static SaVersionT version = { 'B', 1, 1 };
 #endif
 
 #define DEBUGGING_HISTORY 100
-#define DEBUGGING_BUFLEN 128
 #define LOG_SPRINT(cc, f, arg...) do {				\
 		cc->idx++;					\
 		cc->idx = cc->idx % DEBUGGING_HISTORY;		\
-		snprintf(cc->debugging[cc->idx], DEBUGGING_BUFLEN, f, ## arg); \
+		sprintf(cc->debugging[cc->idx], f, ## arg);	\
 	} while (0)
 
 static int log_resp_rec = 0;
@@ -151,7 +150,7 @@ struct clog_cpg {
 	uint32_t checkpoint_requesters[MAX_CHECKPOINT_REQUESTERS];
 	struct checkpoint_data *checkpoint_list;
 	int idx;
-	char debugging[DEBUGGING_HISTORY][DEBUGGING_BUFLEN];
+	char debugging[DEBUGGING_HISTORY][128];
 };
 
 static struct dm_list clog_cpg_list;
@@ -1295,9 +1294,7 @@ static void cpg_join_callback(struct clog_cpg *match,
 	uint32_t my_pid = (uint32_t)getpid();
 	uint32_t lowest = match->lowest_id;
 	struct clog_request *rq;
-	char dbuf[64] = { 0 };
-	char *dbuf_p = dbuf;
-	size_t dbuf_rem = sizeof dbuf;
+	char dbuf[32] = { 0 };
 
 	/* Assign my_cluster_id */
 	if ((my_cluster_id == 0xDEAD) && (joined->pid == my_pid))
@@ -1313,17 +1310,9 @@ static void cpg_join_callback(struct clog_cpg *match,
 	if (joined->nodeid == my_cluster_id)
 		goto out;
 
-	for (i = 0; i < member_list_entries - 1; i++) {
-		int written = snprintf(dbuf_p, dbuf_rem, "%u-", member_list[i].nodeid);
-		if (written < 0) continue; /* impossible */
-		if ((unsigned)written >= dbuf_rem) {
-			dbuf_rem = 0;
-			break;
-		}
-		dbuf_rem -= written;
-		dbuf_p += written;
-	}
-	snprintf(dbuf_p, dbuf_rem, "(%u)", joined->nodeid);
+	for (i = 0; i < member_list_entries - 1; i++)
+		sprintf(dbuf+strlen(dbuf), "%u-", member_list[i].nodeid);
+	sprintf(dbuf+strlen(dbuf), "(%u)", joined->nodeid);
 	LOG_COND(log_checkpoint, "[%s] Joining node, %u needs checkpoint [%s]",
 		 SHORT_UUID(match->name.value), joined->nodeid, dbuf);
 

daemons/cmirrord/functions.c

@@ -32,13 +32,12 @@
 #define LOG_OFFSET 2
 
 #define RESYNC_HISTORY 50
-#define RESYNC_BUFLEN 128
 //static char resync_history[RESYNC_HISTORY][128];
 //static int idx = 0;
 #define LOG_SPRINT(_lc, f, arg...) do {					\
 		lc->idx++;						\
 		lc->idx = lc->idx % RESYNC_HISTORY;			\
-		snprintf(lc->resync_history[lc->idx], RESYNC_BUFLEN, f, ## arg); \
+		sprintf(lc->resync_history[lc->idx], f, ## arg);	\
 	} while (0)
 
 struct log_header {
@@ -89,7 +88,7 @@ struct log_c {
 	size_t disk_size;       /* size of disk_buffer in bytes */
 	void *disk_buffer;      /* aligned memory for O_DIRECT */
 	int idx;
-	char resync_history[RESYNC_HISTORY][RESYNC_BUFLEN];
+	char resync_history[RESYNC_HISTORY][128];
 };
 
 struct mark_entry {
@@ -1445,7 +1444,7 @@ static int disk_status_info(struct log_c *lc, struct dm_ulog_request *rq)
 	char *data = (char *)rq->data;
 	struct stat statbuf;
 
-	if (fstat(lc->disk_fd, &statbuf)) {
+	if(fstat(lc->disk_fd, &statbuf)) {
 		rq->error = -errno;
 		return -errno;
 	}
@@ -1508,7 +1507,7 @@ static int disk_status_table(struct log_c *lc, struct dm_ulog_request *rq)
 	char *data = (char *)rq->data;
 	struct stat statbuf;
 
-	if (fstat(lc->disk_fd, &statbuf)) {
+	if(fstat(lc->disk_fd, &statbuf)) {
 		rq->error = -errno;
 		return -errno;
 	}

daemons/dmeventd/.gitignore

@@ -1 +0,0 @@
-dmeventd

daemons/dmeventd/libdevmapper-event.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2005-2007 Red Hat, Inc. All rights reserved.
  *
  * This file is part of the device-mapper userspace tools.
  *
@@ -12,22 +12,23 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "dm-logging.h"
 #include "dmlib.h"
 #include "libdevmapper-event.h"
+//#include "libmultilog.h"
 #include "dmeventd.h"
 
+#include <errno.h>
 #include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <sys/file.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <unistd.h>
 #include <sys/wait.h>
 #include <arpa/inet.h>		/* for htonl, ntohl */
-#include <pthread.h>
-#include <syslog.h>
 
-static int _debug_level = 0;
-static int _use_syslog = 0;
 static int _sequence_nr = 0;
 
 struct dm_event_handler {
@@ -198,7 +199,7 @@ static int _check_message_id(struct dm_event_daemon_message *msg)
 	if ((sscanf(msg->data, "%d:%d", &pid, &seq_nr) != 2) ||
 	    (pid != getpid()) || (seq_nr != _sequence_nr)) {
 		log_error("Ignoring out-of-sequence reply from dmeventd. "
-			  "Expected %d:%d but received %s.", getpid(),
+			  "Expected %d:%d but received %s", getpid(),
 			  _sequence_nr, msg->data);
 		return 0;
 	}
@@ -233,7 +234,7 @@ static int _daemon_read(struct dm_event_fifos *fifos,
 			FD_SET(fifos->server, &fds);
 			ret = select(fifos->server + 1, &fds, NULL, NULL, &tval);
 			if (ret < 0 && errno != EINTR) {
-				log_error("Unable to read from event server.");
+				log_error("Unable to read from event server");
 				return 0;
 			}
 			if ((ret == 0) && (i > 4) && !bytes) {
@@ -299,7 +300,7 @@ static int _daemon_write(struct dm_event_fifos *fifos,
 		if (ret < 0) {
 			if (errno == EINTR)
 				continue;
-			log_error("Unable to talk to event daemon.");
+			log_error("Unable to talk to event daemon");
 			return 0;
 		}
 		if (ret == 0)
@@ -308,7 +309,7 @@ static int _daemon_write(struct dm_event_fifos *fifos,
 		if (ret < 0) {
 			if ((errno == EINTR) || (errno == EAGAIN))
 				continue;
-			log_error("Unable to talk to event daemon.");
+			log_error("Unable to talk to event daemon");
 			return 0;
 		}
 	}
@@ -320,7 +321,7 @@ static int _daemon_write(struct dm_event_fifos *fifos,
 			FD_SET(fifos->client, &fds);
 			ret = select(fifos->client + 1, NULL, &fds, NULL, NULL);
 			if ((ret < 0) && (errno != EINTR)) {
-				log_error("Unable to talk to event daemon.");
+				log_error("Unable to talk to event daemon");
 				return 0;
 			}
 		} while (ret < 1);
@@ -330,7 +331,7 @@ static int _daemon_write(struct dm_event_fifos *fifos,
 			if ((errno == EINTR) || (errno == EAGAIN))
 				continue;
 			else {
-				log_error("Unable to talk to event daemon.");
+				log_error("Unable to talk to event daemon");
 				return 0;
 			}
 		}
@@ -360,7 +361,7 @@ int daemon_talk(struct dm_event_fifos *fifos,
 			  getpid(), _sequence_nr,
 			  dso_name ? : "-", dev_name ? : "-", evmask, timeout)))
 	    < 0) {
-		log_error("_daemon_talk: message allocation failed.");
+		log_error("_daemon_talk: message allocation failed");
 		return -ENOMEM;
 	}
 	msg->cmd = cmd;
@@ -448,11 +449,11 @@ static int _start_daemon(char *dmeventd_path, struct dm_event_fifos *fifos)
 
 	else if (!pid) {
 		execvp(args[0], args);
-		log_error("Unable to exec dmeventd: %s.", strerror(errno));
+		log_error("Unable to exec dmeventd: %s", strerror(errno));
 		_exit(EXIT_FAILURE);
 	} else {
 		if (waitpid(pid, &status, 0) < 0)
-			log_error("Unable to start dmeventd: %s.",
+			log_error("Unable to start dmeventd: %s",
 				  strerror(errno));
 		else if (WEXITSTATUS(status))
 			log_error("Unable to start dmeventd.");
@@ -525,7 +526,7 @@ static struct dm_task *_get_device_info(const struct dm_event_handler *dmevh)
 	struct dm_info info;
 
 	if (!(dmt = dm_task_create(DM_DEVICE_INFO))) {
-		log_error("_get_device_info: dm_task creation for info failed.");
+		log_error("_get_device_info: dm_task creation for info failed");
 		return NULL;
 	}
 
@@ -543,17 +544,17 @@ static struct dm_task *_get_device_info(const struct dm_event_handler *dmevh)
 
 	/* FIXME Add name or uuid or devno to messages */
 	if (!dm_task_run(dmt)) {
-		log_error("_get_device_info: dm_task_run() failed.");
+		log_error("_get_device_info: dm_task_run() failed");
 		goto bad;
 	}
 
 	if (!dm_task_get_info(dmt, &info)) {
-		log_error("_get_device_info: failed to get info for device.");
+		log_error("_get_device_info: failed to get info for device");
 		goto bad;
 	}
 
 	if (!info.exists) {
-		log_error("_get_device_info: %s%s%s%.0d%s%.0d%s%s: device not found.",
+		log_error("_get_device_info: %s%s%s%.0d%s%.0d%s%s: device not found",
 			  dmevh->uuid ? : "",
 			  (!dmevh->uuid && dmevh->dev_name) ? dmevh->dev_name : "",
 			  (!dmevh->uuid && !dmevh->dev_name && dmevh->major > 0) ? "(" : "",
@@ -622,12 +623,12 @@ int dm_event_register_handler(const struct dm_event_handler *dmevh)
 	    !strstr(dmevh->dso, "libdevmapper-event-lvm2snapshot.so") &&
 	    !strstr(dmevh->dso, "libdevmapper-event-lvm2mirror.so") &&
 	    !strstr(dmevh->dso, "libdevmapper-event-lvm2raid.so"))
-		log_warn("WARNING: %s: dmeventd plugins are deprecated.", dmevh->dso);
+		log_warn("WARNING: %s: dmeventd plugins are deprecated", dmevh->dso);
 
 
 	if ((err = _do_event(DM_EVENT_CMD_REGISTER_FOR_EVENT, dmevh->dmeventd_path, &msg,
 			     dmevh->dso, uuid, dmevh->mask, dmevh->timeout)) < 0) {
-		log_error("%s: event registration failed: %s.",
+		log_error("%s: event registration failed: %s",
 			  dm_task_get_name(dmt),
 			  msg.data ? msg.data : strerror(-err));
 		ret = 0;
@@ -654,7 +655,7 @@ int dm_event_unregister_handler(const struct dm_event_handler *dmevh)
 
 	if ((err = _do_event(DM_EVENT_CMD_UNREGISTER_FOR_EVENT, dmevh->dmeventd_path, &msg,
 			    dmevh->dso, uuid, dmevh->mask, dmevh->timeout)) < 0) {
-		log_error("%s: event deregistration failed: %s.",
+		log_error("%s: event deregistration failed: %s",
 			  dm_task_get_name(dmt),
 			  msg.data ? msg.data : strerror(-err));
 		ret = 0;
@@ -827,79 +828,6 @@ int dm_event_get_version(struct dm_event_fifos *fifos, int *version) {
 	return 1;
 }
 
-void dm_event_log_set(int debug_level, int use_syslog)
-{
-	_debug_level = debug_level;
-	_use_syslog = use_syslog;
-}
-
-void dm_event_log(const char *subsys, int level, const char *file,
-		  int line, int dm_errno_or_class,
-		  const char *format, va_list ap)
-{
-	static pthread_mutex_t _log_mutex = PTHREAD_MUTEX_INITIALIZER;
-	static time_t start = 0;
-	const char *indent = "";
-	FILE *stream = stdout;
-	int prio = -1;
-	time_t now;
-
-	switch (level & ~(_LOG_STDERR | _LOG_ONCE)) {
-	case _LOG_DEBUG:
-		if (_debug_level < 3)
-			return;
-		prio = LOG_DEBUG;
-		indent = "      ";
-		break;
-	case _LOG_INFO:
-		if (_debug_level < 2)
-			return;
-		prio = LOG_INFO;
-		indent = "    ";
-		break;
-	case _LOG_NOTICE:
-		if (_debug_level < 1)
-			return;
-		prio = LOG_NOTICE;
-		indent = "  ";
-		break;
-	case _LOG_WARN:
-		prio = LOG_WARNING;
-		break;
-	case _LOG_ERR:
-		prio = LOG_ERR;
-		stream = stderr;
-		break;
-	default:
-		prio = LOG_CRIT;
-	}
-
-	/* Serialize to keep lines readable */
-	pthread_mutex_lock(&_log_mutex);
-
-	if (_use_syslog) {
-		vsyslog(prio, format, ap);
-	} else {
-		now = time(NULL);
-		if (!start)
-			start = now;
-		now -= start;
-		fprintf(stream, "[%2d:%02d] %8x:%-6s%s",
-			(int)now / 60, (int)now % 60,
-			// TODO: Maybe use shorter ID
-			// ((int)(pthread_self()) >> 6) & 0xffff,
-			(int)pthread_self(), subsys,
-			(_debug_level > 3) ? "" : indent);
-		if (_debug_level > 3)
-			fprintf(stream, "%28s:%4d %s", file, line, indent);
-		vfprintf(stream, _(format), ap);
-		fputc('\n', stream);
-		fflush(stream);
-	}
-
-	pthread_mutex_unlock(&_log_mutex);
-}
-
 #if 0				/* left out for now */
 
 static char *_skip_string(char *src, const int delimiter)
@@ -933,7 +861,7 @@ int dm_event_get_timeout(const char *device_path, uint32_t *timeout)
 			     0, 0))) {
 		char *p = _skip_string(msg.data, ' ');
 		if (!p) {
-			log_error("Malformed reply from dmeventd '%s'.",
+			log_error("malformed reply from dmeventd '%s'\n",
 				  msg.data);
 			dm_free(msg.data);
 			return -EIO;

daemons/dmeventd/libdevmapper-event.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2005-2007 Red Hat, Inc. All rights reserved.
  *
  * This file is part of the device-mapper userspace tools.
  *
@@ -105,25 +105,6 @@ int dm_event_get_registered_device(struct dm_event_handler *dmevh, int next);
 int dm_event_register_handler(const struct dm_event_handler *dmevh);
 int dm_event_unregister_handler(const struct dm_event_handler *dmevh);
 
-/* Set debug level for logging, and whether to log on stdout/stderr or syslog */
-void dm_event_log_set(int debug_level, int use_syslog);
-
-/* Log messages acroding to current debug level  */
-__attribute__((format(printf, 6, 0)))
-void dm_event_log(const char *subsys, int level, const char *file,
-		  int line, int dm_errno_or_class,
-		  const char *format, va_list ap);
-/* Macro to route print_log do dm_event_log() */
-#define DM_EVENT_LOG_FN(subsys) \
-void print_log(int level, const char *file, int line, int dm_errno_or_class,\
-	       const char *format, ...)\
-{\
-	va_list ap;\
-	va_start(ap, format);\
-	dm_event_log(subsys, level, file, line, dm_errno_or_class, format, ap);\
-	va_end(ap);\
-}
-
 /* Prototypes for DSO interface, see dmeventd.c, struct dso_data for
    detailed descriptions. */
 // FIXME  misuse of bitmask as enum

daemons/dmeventd/plugins/lvm2/dmeventd_lvm.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2010 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -13,11 +13,15 @@
  */
 
 #include "lib.h"
-#include "dmeventd_lvm.h"
-#include "libdevmapper-event.h"
+#include "log.h"
+
 #include "lvm2cmd.h"
+#include "dmeventd_lvm.h"
 
 #include <pthread.h>
+#include <syslog.h>
+
+extern int dmeventd_debug;
 
 /*
  * register_device() is called first and performs initialisation.
@@ -32,19 +36,48 @@ static int _register_count = 0;
 static struct dm_pool *_mem_pool = NULL;
 static void *_lvm_handle = NULL;
 
-DM_EVENT_LOG_FN("lvm")
-
-static void _lvm2_print_log(int level, const char *file, int line,
-			    int dm_errno_or_class, const char *msg)
-{
-	print_log(level, file, line, dm_errno_or_class, "%s", msg);
-}
-
 /*
  * Currently only one event can be processed at a time.
  */
 static pthread_mutex_t _event_mutex = PTHREAD_MUTEX_INITIALIZER;
 
+/*
+ * FIXME Do not pass things directly to syslog, rather use the existing logging
+ * facilities to sort logging ... however that mechanism needs to be somehow
+ * configurable and we don't have that option yet
+ */
+static void _temporary_log_fn(int level,
+			      const char *file __attribute__((unused)),
+			      int line __attribute__((unused)),
+			      int dm_errno __attribute__((unused)),
+			      const char *message)
+{
+	level &= ~(_LOG_STDERR | _LOG_ONCE);
+
+	switch (level) {
+	case _LOG_DEBUG:
+		if (dmeventd_debug >= 3)
+			syslog(LOG_DEBUG, "%s", message);
+		break;
+	case _LOG_INFO:
+		if (dmeventd_debug >= 2)
+			syslog(LOG_INFO, "%s", message);
+		break;
+	case _LOG_NOTICE:
+		if (dmeventd_debug >= 1)
+			syslog(LOG_NOTICE, "%s", message);
+		break;
+	case _LOG_WARN:
+		syslog(LOG_WARNING, "%s", message);
+		break;
+	case _LOG_ERR:
+		syslog(LOG_ERR, "%s", message);
+		break;
+	default:
+		syslog(LOG_CRIT, "%s", message);
+	}
+}
+
 void dmeventd_lvm2_lock(void)
 {
 	pthread_mutex_lock(&_event_mutex);
@@ -61,26 +94,24 @@ int dmeventd_lvm2_init(void)
 
 	pthread_mutex_lock(&_register_mutex);
 
+	/*
+	 * Need some space for allocations.  1024 should be more
+	 * than enough for what we need (device mapper name splitting)
+	 */
+	if (!_mem_pool && !(_mem_pool = dm_pool_create("mirror_dso", 1024)))
+		goto out;
+
 	if (!_lvm_handle) {
-		lvm2_log_fn(_lvm2_print_log);
-
-		if (!(_lvm_handle = lvm2_init()))
-			goto out;
-
-		/*
-		 * Need some space for allocations.  1024 should be more
-		 * than enough for what we need (device mapper name splitting)
-		 */
-		if (!_mem_pool && !(_mem_pool = dm_pool_create("mirror_dso", 1024))) {
-			lvm2_exit(_lvm_handle);
-			_lvm_handle = NULL;
+		if (!getenv("LVM_LOG_FILE_EPOCH"))
+			lvm2_log_fn(_temporary_log_fn);
+		if (!(_lvm_handle = lvm2_init())) {
+			dm_pool_destroy(_mem_pool);
+			_mem_pool = NULL;
 			goto out;
 		}
-
 		lvm2_disable_dmeventd_monitoring(_lvm_handle);
 		/* FIXME Temporary: move to dmeventd core */
 		lvm2_run(_lvm_handle, "_memlock_inc");
-		log_debug("lvm plugin initilized.");
 	}
 
 	_register_count++;
@@ -96,13 +127,11 @@ void dmeventd_lvm2_exit(void)
 	pthread_mutex_lock(&_register_mutex);
 
 	if (!--_register_count) {
-		log_debug("lvm plugin shuting down.");
 		lvm2_run(_lvm_handle, "_memlock_dec");
 		dm_pool_destroy(_mem_pool);
 		_mem_pool = NULL;
 		lvm2_exit(_lvm_handle);
 		_lvm_handle = NULL;
-		log_debug("lvm plugin exited.");
 	}
 
 	pthread_mutex_unlock(&_register_mutex);
@@ -125,8 +154,8 @@ int dmeventd_lvm2_command(struct dm_pool *mem, char *buffer, size_t size,
 	int r;
 
 	if (!dm_split_lvm_name(mem, device, &vg, &lv, &layer)) {
-		log_error("Unable to determine VG name from %s.",
-			  device);
+		syslog(LOG_ERR, "Unable to determine VG name from %s.\n",
+		       device);
 		return 0;
 	}
 
@@ -140,7 +169,7 @@ int dmeventd_lvm2_command(struct dm_pool *mem, char *buffer, size_t size,
 	dm_pool_free(mem, vg);
 
 	if (r < 0) {
-		log_error("Unable to form LVM command. (too long).");
+		syslog(LOG_ERR, "Unable to form LVM command. (too long).\n");
 		return 0;
 	}
 

daemons/dmeventd/plugins/lvm2/dmeventd_lvm.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2010 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -39,36 +39,4 @@ struct dm_pool *dmeventd_lvm2_pool(void);
 int dmeventd_lvm2_command(struct dm_pool *mem, char *buffer, size_t size,
 			  const char *cmd, const char *device);
 
-#define dmeventd_lvm2_run_with_lock(cmdline) \
-	({\
-		int rc;\
-		dmeventd_lvm2_lock();\
-		rc = dmeventd_lvm2_run(cmdline);\
-		dmeventd_lvm2_unlock();\
-		rc;\
-	})
-
-#define dmeventd_lvm2_init_with_pool(name, st) \
-	({\
-		struct dm_pool *mem;\
-		st = NULL;\
-		if (dmeventd_lvm2_init()) {\
-			if ((mem = dm_pool_create(name, 2048)) &&\
-			    (st = dm_pool_zalloc(mem, sizeof(*st))))\
-				st->mem = mem;\
-			else {\
-				if (mem)\
-					dm_pool_destroy(mem);\
-				dmeventd_lvm2_exit();\
-			}\
-		}\
-		st;\
-	})
-
-#define dmeventd_lvm2_exit_with_pool(pool) \
-	do {\
-		dm_pool_destroy(pool->mem);\
-		dmeventd_lvm2_exit();\
-	} while(0)
-
 #endif /* _DMEVENTD_LVMWRAP_H */

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2005-2012 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -13,24 +13,20 @@
  */
 
 #include "lib.h"
+
 #include "libdevmapper-event.h"
 #include "dmeventd_lvm.h"
 #include "defaults.h"
 
+#include <syslog.h> /* FIXME Replace syslog with multilog */
+/* FIXME Missing openlog? */
+/* FIXME Replace most syslogs with log_error() style messages and add complete context. */
 /* FIXME Reformat to 80 char lines. */
 
 #define ME_IGNORE    0
 #define ME_INSYNC    1
 #define ME_FAILURE   2
 
-struct dso_state {
-	struct dm_pool *mem;
-	char cmd_lvscan[512];
-	char cmd_lvconvert[512];
-};
-
-DM_EVENT_LOG_FN("mirr")
-
 static int _process_status_code(const char status_code, const char *dev_name,
 				const char *dev_type, int r)
 {
@@ -43,15 +39,18 @@ static int _process_status_code(const char status_code, const char *dev_name,
 	 *    U => Unclassified failure (bug)
 	 */ 
 	if (status_code == 'F') {
-		log_error("%s device %s flush failed.", dev_type, dev_name);
+		syslog(LOG_ERR, "%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);
+		syslog(LOG_ERR, "%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);
+		syslog(LOG_ERR, "%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);
+		syslog(LOG_ERR, "%s device %s has failed (%c).",
+		       dev_type, dev_name, status_code);
 		r = ME_FAILURE;
 	}
 
@@ -126,49 +125,62 @@ out:
 
 out_parse:
 	dm_free(args);
-	log_error("Unable to parse mirror status string.");
-
+	syslog(LOG_ERR, "Unable to parse mirror status string.");
 	return ME_IGNORE;
 }
 
-static int _remove_failed_devices(const char *cmd_lvscan, const char *cmd_lvconvert)
+static int _remove_failed_devices(const char *device)
 {
 	int r;
+#define CMD_SIZE 256	/* FIXME Use system restriction */
+	char cmd_str[CMD_SIZE];
 
-	if (!dmeventd_lvm2_run_with_lock(cmd_lvscan))
-		log_info("Re-scan of mirrored device failed.");
+	if (!dmeventd_lvm2_command(dmeventd_lvm2_pool(), cmd_str, sizeof(cmd_str),
+				   "lvscan --cache", device))
+		return -1;
+
+	r = dmeventd_lvm2_run(cmd_str);
+
+	if (!r)
+		syslog(LOG_INFO, "Re-scan of mirror device %s failed.", device);
+
+	if (!dmeventd_lvm2_command(dmeventd_lvm2_pool(), cmd_str, sizeof(cmd_str),
+				  "lvconvert --config devices{ignore_suspended_devices=1} "
+				  "--repair --use-policies", device))
+		return -ENAMETOOLONG; /* FIXME Replace with generic error return - reason for failure has already got logged */
 
 	/* if repair goes OK, report success even if lvscan has failed */
-	r = dmeventd_lvm2_run_with_lock(cmd_lvconvert);
+	r = dmeventd_lvm2_run(cmd_str);
 
-	log_info("Repair of mirrored device %s.",
-		 (r) ? "finished successfully" : "failed");
+	syslog(LOG_INFO, "Repair of mirrored device %s %s.", device,
+	       (r) ? "finished successfully" : "failed");
 
-	return r;
+	return (r) ? 0 : -1;
 }
 
 void process_event(struct dm_task *dmt,
 		   enum dm_event_mask event __attribute__((unused)),
-		   void **user)
+		   void **unused __attribute__((unused)))
 {
-	struct dso_state *state = *user;
 	void *next = NULL;
 	uint64_t start, length;
 	char *target_type = NULL;
 	char *params;
 	const char *device = dm_task_get_name(dmt);
 
+	dmeventd_lvm2_lock();
+
 	do {
 		next = dm_get_next_target(dmt, next, &start, &length,
 					  &target_type, &params);
 
 		if (!target_type) {
-			log_info("%s mapping lost.", device);
+			syslog(LOG_INFO, "%s mapping lost.", device);
 			continue;
 		}
 
 		if (strcmp(target_type, "mirror")) {
-			log_info("%s has unmirrored portion.", device);
+			syslog(LOG_INFO, "%s has unmirrored portion.", device);
 			continue;
 		}
 
@@ -178,75 +190,54 @@ void process_event(struct dm_task *dmt,
 			   _part_ of the device is in sync
 			   Also, this is not an error
 			*/
-			log_notice("%s is now in-sync.", device);
+			syslog(LOG_NOTICE, "%s is now in-sync.", device);
 			break;
 		case ME_FAILURE:
-			log_error("Device failure in %s.", device);
-			if (!_remove_failed_devices(state->cmd_lvscan,
-						    state->cmd_lvconvert))
+			syslog(LOG_ERR, "Device failure in %s.", device);
+			if (_remove_failed_devices(device))
 				/* FIXME Why are all the error return codes unused? Get rid of them? */
-				log_error("Failed to remove faulty devices in %s.",
-					  device);
+				syslog(LOG_ERR, "Failed to remove faulty devices in %s.",
+				       device);
 			/* Should check before warning user that device is now linear
 			else
-				log_notice("%s is now a linear device.",
-					   device);
+				syslog(LOG_NOTICE, "%s is now a linear device.\n",
+					device);
 			*/
 			break;
 		case ME_IGNORE:
 			break;
 		default:
 			/* FIXME Provide value then! */
-			log_info("Unknown event received.");
+			syslog(LOG_INFO, "Unknown event received.");
 		}
 	} while (next);
+
+	dmeventd_lvm2_unlock();
 }
 
 int register_device(const char *device,
 		    const char *uuid __attribute__((unused)),
 		    int major __attribute__((unused)),
 		    int minor __attribute__((unused)),
-		    void **user)
+		    void **unused __attribute__((unused)))
 {
-	struct dso_state *state;
+	if (!dmeventd_lvm2_init())
+		return 0;
 
-	if (!dmeventd_lvm2_init_with_pool("mirror_state", state))
-		goto_bad;
-
-	if (!dmeventd_lvm2_command(state->mem, state->cmd_lvscan, sizeof(state->cmd_lvscan),
-				   "lvscan --cache", device)) {
-		dmeventd_lvm2_exit_with_pool(state);
-		goto_bad;
-	}
-
-	if (!dmeventd_lvm2_command(state->mem, state->cmd_lvconvert, sizeof(state->cmd_lvconvert),
-				   "lvconvert --repair --use-policies", device)) {
-		dmeventd_lvm2_exit_with_pool(state);
-		goto_bad;
-	}
-
-	*user = state;
-
-	log_info("Monitoring mirror device %s for events.", device);
+	syslog(LOG_INFO, "Monitoring mirror device %s for events.", device);
 
 	return 1;
-bad:
-	log_error("Failed to monitor mirror %s.", device);
-
-	return 0;
 }
 
 int unregister_device(const char *device,
 		      const char *uuid __attribute__((unused)),
 		      int major __attribute__((unused)),
 		      int minor __attribute__((unused)),
-		      void **user)
+		      void **unused __attribute__((unused)))
 {
-	struct dso_state *state = *user;
-
-	dmeventd_lvm2_exit_with_pool(state);
-	log_info("No longer monitoring mirror device %s for events.",
-		 device);
+	syslog(LOG_INFO, "No longer monitoring mirror device %s for events.",
+	       device);
+	dmeventd_lvm2_exit();
 
 	return 1;
 }

daemons/dmeventd/plugins/raid/dmeventd_raid.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2005-2011 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -13,133 +13,168 @@
  */
 
 #include "lib.h"
-#include "dmeventd_lvm.h"
+
 #include "libdevmapper-event.h"
+#include "dmeventd_lvm.h"
 
-struct dso_state {
-	struct dm_pool *mem;
-	char cmd_lvscan[512];
-	char cmd_lvconvert[512];
-	int failed;
-};
-
-DM_EVENT_LOG_FN("raid")
-
+#include <syslog.h> /* FIXME Replace syslog with multilog */
+/* FIXME Missing openlog? */
+/* FIXME Replace most syslogs with log_error() style messages and add complete context. */
 /* FIXME Reformat to 80 char lines. */
 
-static int _process_raid_event(struct dso_state *state, char *params, const char *device)
+/*
+ * run_repair is a close copy to
+ * plugins/mirror/dmeventd_mirror.c:_remove_failed_devices()
+ */
+static int run_repair(const char *device)
 {
-	struct dm_status_raid *status;
-	const char *d;
+	int r;
+#define CMD_SIZE 256	/* FIXME Use system restriction */
+	char cmd_str[CMD_SIZE];
 
-	if (!dm_get_status_raid(state->mem, params, &status)) {
-		log_error("Failed to process status line for %s.", device);
-		return 0;
+	if (!dmeventd_lvm2_command(dmeventd_lvm2_pool(), cmd_str, sizeof(cmd_str),
+				  "lvscan --cache", device))
+		return -1;
+
+	r = dmeventd_lvm2_run(cmd_str);
+
+	if (!r)
+		syslog(LOG_INFO, "Re-scan of RAID device %s failed.", device);
+
+	if (!dmeventd_lvm2_command(dmeventd_lvm2_pool(), cmd_str, sizeof(cmd_str),
+				  "lvconvert --config devices{ignore_suspended_devices=1} "
+				  "--repair --use-policies", device))
+		return -1;
+
+	/* if repair goes OK, report success even if lvscan has failed */
+	r = dmeventd_lvm2_run(cmd_str);
+
+	if (!r)
+		syslog(LOG_INFO, "Repair of RAID device %s failed.", device);
+
+	return (r) ? 0 : -1;
+}
+
+static int _process_raid_event(char *params, const char *device)
+{
+	int i, n, failure = 0;
+	char *p, *a[4];
+	char *raid_type;
+	char *num_devices;
+	char *health_chars;
+	char *resync_ratio;
+
+	/*
+	 * RAID parms:     <raid_type> <#raid_disks> \
+	 *                 <health chars> <resync ratio>
+	 */
+	if (!dm_split_words(params, 4, 0, a)) {
+		syslog(LOG_ERR, "Failed to process status line for %s\n",
+		       device);
+		return -EINVAL;
+	}
+	raid_type = a[0];
+	num_devices = a[1];
+	health_chars = a[2];
+	resync_ratio = a[3];
+
+	if (!(n = atoi(num_devices))) {
+		syslog(LOG_ERR, "Failed to parse number of devices for %s: %s",
+		       device, num_devices);
+		return -EINVAL;
 	}
 
-	if ((d = strchr(status->dev_health, 'D'))) {
-		if (state->failed)
-			goto out; /* already reported */
-
-		log_error("Device #%d of %s array, %s, has failed.",
-			  (int)(d - status->dev_health),
-			  status->raid_type, device);
-
-		state->failed = 1;
-		if (!dmeventd_lvm2_run_with_lock(state->cmd_lvscan))
-			log_warn("WARNING: Re-scan of RAID device %s failed.", device);
-
-		/* if repair goes OK, report success even if lvscan has failed */
-		if (!dmeventd_lvm2_run_with_lock(state->cmd_lvconvert)) {
-			log_info("Repair of RAID device %s failed.", device);
-			dm_pool_free(state->mem, status);
-			return 0;
+	for (i = 0; i < n; i++) {
+		switch (health_chars[i]) {
+		case 'A':
+			/* Device is 'A'live and well */
+		case 'a':
+			/* Device is 'a'live, but not yet in-sync */
+			break;
+		case 'D':
+			syslog(LOG_ERR,
+			       "Device #%d of %s array, %s, has failed.",
+			       i, raid_type, device);
+			failure++;
+			break;
+		default:
+			/* Unhandled character returned from kernel */
+			break;
 		}
-	} else {
-		state->failed = 0;
-		log_info("%s array, %s, is %s in-sync.",
-			 status->raid_type, device,
-			 (status->insync_regions == status->total_regions) ? "now" : "not");
+		if (failure)
+			return run_repair(device);
 	}
-out:
-	dm_pool_free(state->mem, status);
 
-	return 1;
+	p = strstr(resync_ratio, "/");
+	if (!p) {
+		syslog(LOG_ERR, "Failed to parse resync_ratio for %s: %s",
+		       device, resync_ratio);
+		return -EINVAL;
+	}
+	p[0] = '\0';
+	syslog(LOG_INFO, "%s array, %s, is %s in-sync.",
+	       raid_type, device, strcmp(resync_ratio, p+1) ? "not" : "now");
+
+	return 0;
 }
 
 void process_event(struct dm_task *dmt,
 		   enum dm_event_mask event __attribute__((unused)),
-		   void **user)
+		   void **unused __attribute__((unused)))
 {
-	struct dso_state *state = *user;
 	void *next = NULL;
 	uint64_t start, length;
 	char *target_type = NULL;
 	char *params;
 	const char *device = dm_task_get_name(dmt);
 
+	dmeventd_lvm2_lock();
+
 	do {
 		next = dm_get_next_target(dmt, next, &start, &length,
 					  &target_type, &params);
 
 		if (!target_type) {
-			log_info("%s mapping lost.", device);
+			syslog(LOG_INFO, "%s mapping lost.", device);
 			continue;
 		}
 
 		if (strcmp(target_type, "raid")) {
-			log_info("%s has non-raid portion.", device);
+			syslog(LOG_INFO, "%s has non-raid portion.", device);
 			continue;
 		}
 
-		if (!_process_raid_event(state, params, device))
-			log_error("Failed to process event for %s.",
-				  device);
+		if (_process_raid_event(params, device))
+			syslog(LOG_ERR, "Failed to process event for %s",
+			       device);
 	} while (next);
+
+	dmeventd_lvm2_unlock();
 }
 
 int register_device(const char *device,
 		    const char *uuid __attribute__((unused)),
 		    int major __attribute__((unused)),
 		    int minor __attribute__((unused)),
-		    void **user)
+		    void **unused __attribute__((unused)))
 {
-	struct dso_state *state;
+	if (!dmeventd_lvm2_init())
+		return 0;
 
-	if (!dmeventd_lvm2_init_with_pool("raid_state", state))
-		goto_bad;
-
-	if (!dmeventd_lvm2_command(state->mem, state->cmd_lvscan, sizeof(state->cmd_lvscan),
-				   "lvscan --cache", device) ||
-	    !dmeventd_lvm2_command(state->mem, state->cmd_lvconvert, sizeof(state->cmd_lvconvert),
-				   "lvconvert --config devices{ignore_suspended_devices=1} "
-				   "--repair --use-policies", device)) {
-		dmeventd_lvm2_exit_with_pool(state);
-		goto_bad;
-	}
-
-	*user = state;
-
-	log_info("Monitoring RAID device %s for events.", device);
+	syslog(LOG_INFO, "Monitoring RAID device %s for events.", device);
 
 	return 1;
-bad:
-	log_error("Failed to monitor RAID %s.", device);
-
-	return 0;
 }
 
 int unregister_device(const char *device,
 		      const char *uuid __attribute__((unused)),
 		      int major __attribute__((unused)),
 		      int minor __attribute__((unused)),
-		      void **user)
+		      void **unused __attribute__((unused)))
 {
-	struct dso_state *state = *user;
-
-	dmeventd_lvm2_exit_with_pool(state);
-	log_info("No longer monitoring RAID device %s for events.",
-		 device);
+	syslog(LOG_INFO, "No longer monitoring RAID device %s for events.",
+	       device);
+	dmeventd_lvm2_exit();
 
 	return 1;
 }

daemons/dmeventd/plugins/snapshot/dmeventd_snapshot.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2007-2011 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -13,31 +13,31 @@
  */
 
 #include "lib.h"
-#include "dmeventd_lvm.h"
+
 #include "libdevmapper-event.h"
+#include "dmeventd_lvm.h"
 
 #include <sys/wait.h>
+#include <syslog.h> /* FIXME Replace syslog with multilog */
 #include <stdarg.h>
-#include <pthread.h>
+/* FIXME Missing openlog? */
 
 /* First warning when snapshot is 80% full. */
-#define WARNING_THRESH	(DM_PERCENT_1 * 80)
+#define WARNING_THRESH 80
 /* Run a check every 5%. */
-#define CHECK_STEP	(DM_PERCENT_1 *  5)
+#define CHECK_STEP 5
 /* Do not bother checking snapshots less than 50% full. */
-#define CHECK_MINIMUM	(DM_PERCENT_1 * 50)
+#define CHECK_MINIMUM 50
 
 #define UMOUNT_COMMAND "/bin/umount"
 
 struct dso_state {
 	struct dm_pool *mem;
-	dm_percent_t percent_check;
+	int percent_check;
 	uint64_t known_size;
-	char cmd_lvextend[512];
+	char cmd_str[1024];
 };
 
-DM_EVENT_LOG_FN("snap")
-
 static int _run(const char *cmd, ...)
 {
         va_list ap;
@@ -62,7 +62,7 @@ static int _run(const char *cmd, ...)
                 va_end(ap);
 
                 execvp(cmd, (char **)argv);
-                log_sys_error("exec", cmd);
+                syslog(LOG_ERR, "Failed to execute %s: %s.\n", cmd, strerror(errno));
                 exit(127);
         }
 
@@ -81,56 +81,18 @@ static int _run(const char *cmd, ...)
 
 static int _extend(const char *cmd)
 {
-	log_debug("Extending snapshot via %s.", cmd);
-	return dmeventd_lvm2_run_with_lock(cmd);
+	return dmeventd_lvm2_run(cmd);
 }
 
-#ifdef SNAPSHOT_REMOVE
-/* Remove invalid snapshot from dm-table */
-/* Experimental for now and not used by default */
-static int _remove(const char *uuid)
-{
-	int r = 1;
-	uint32_t cookie = 0;
-	struct dm_task *dmt;
-
-	if (!(dmt = dm_task_create(DM_DEVICE_REMOVE)))
-		return 0;
-
-	if (!dm_task_set_uuid(dmt, uuid)) {
-		r = 0;
-		goto_out;
-	}
-
-	dm_task_retry_remove(dmt);
-
-	if (!dm_task_set_cookie(dmt, &cookie, 0)) {
-		r = 0;
-		goto_out;
-	}
-
-	if (!dm_task_run(dmt)) {
-		r = 0;
-		goto_out;
-	}
-out:
-	dm_task_destroy(dmt);
-
-	return r;
-}
-#endif /* SNAPSHOT_REMOVE */
-
 static void _umount(const char *device, int major, int minor)
 {
 	FILE *mounts;
 	char buffer[4096];
 	char *words[3];
 	struct stat st;
-	const char procmounts[] = "/proc/mounts";
 
-	if (!(mounts = fopen(procmounts, "r"))) {
-		log_sys_error("fopen", procmounts);
-		log_error("Not umounting %s.", device);
+	if (!(mounts = fopen("/proc/mounts", "r"))) {
+		syslog(LOG_ERR, "Could not read /proc/mounts. Not umounting %s.\n", device);
 		return;
 	}
 
@@ -150,22 +112,21 @@ static void _umount(const char *device, int major, int minor)
 		if (S_ISBLK(st.st_mode) &&
 		    major(st.st_rdev) == major &&
 		    minor(st.st_rdev) == minor) {
-			log_error("Unmounting invalid snapshot %s from %s.", device, words[1]);
-			if (!_run(UMOUNT_COMMAND, "-fl", words[1], NULL))
-				log_error("Failed to umount snapshot %s from %s: %s.",
-					  device, words[1], strerror(errno));
+			syslog(LOG_ERR, "Unmounting invalid snapshot %s from %s.\n", device, words[1]);
+                        if (!_run(UMOUNT_COMMAND, "-fl", words[1], NULL))
+                                syslog(LOG_ERR, "Failed to umount snapshot %s from %s: %s.\n",
+                                       device, words[1], strerror(errno));
 		}
 	}
 
 	if (fclose(mounts))
-		log_sys_error("close", procmounts);
+		syslog(LOG_ERR, "Failed to close /proc/mounts.\n");
 }
 
 void process_event(struct dm_task *dmt,
 		   enum dm_event_mask event __attribute__((unused)),
-		   void **user)
+		   void **private)
 {
-	struct dso_state *state = *user;
 	void *next = NULL;
 	uint64_t start, length;
 	char *target_type = NULL;
@@ -173,47 +134,28 @@ void process_event(struct dm_task *dmt,
 	struct dm_status_snapshot *status = NULL;
 	const char *device = dm_task_get_name(dmt);
 	int percent;
-	struct dm_info info;
+	struct dso_state *state = *private;
 
 	/* No longer monitoring, waiting for remove */
 	if (!state->percent_check)
 		return;
 
+	dmeventd_lvm2_lock();
+
 	dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
-	if (!target_type || strcmp(target_type, "snapshot")) {
-		log_error("Target %s is not snapshot.", target_type);
-		return;
-	}
+	if (!target_type)
+		goto out;
 
-	if (!dm_get_status_snapshot(state->mem, params, &status)) {
-		log_error("Cannot parse snapshot %s state: %s.", device, params);
-		return;
-	}
+	if (!dm_get_status_snapshot(state->mem, params, &status))
+		goto out;
 
-	/*
-	 * If the snapshot has been invalidated or we failed to parse
-	 * the status string. Report the full status string to syslog.
-	 */
-	if (status->invalid || status->overflow || !status->total_sectors) {
-		log_warn("WARNING: Snapshot %s changed state to: %s and should be removed.",
-			 device, params);
-		state->percent_check = 0;
-		if (dm_task_get_info(dmt, &info))
+	if (status->invalid) {
+		struct dm_info info;
+		if (dm_task_get_info(dmt, &info)) {
+			dmeventd_lvm2_unlock();
 			_umount(device, info.major, info.minor);
-#ifdef SNAPSHOT_REMOVE
-		/* Maybe configurable ? */
-		_remove(dm_task_get_uuid(dmt));
-#endif
-		pthread_kill(pthread_self(), SIGALRM);
-		goto out;
-	}
-
-	if (length <= (status->used_sectors - status->metadata_sectors)) {
-		/* TODO eventually recognize earlier when room is enough */
-		log_info("Dropping monitoring of fully provisioned snapshot %s.",
-			 device);
-		pthread_kill(pthread_self(), SIGALRM);
-		goto out;
+			return;
+		} /* else; too bad, but this is best-effort thing... */
 	}
 
 	/* Snapshot size had changed. Clear the threshold. */
@@ -222,50 +164,69 @@ void process_event(struct dm_task *dmt,
 		state->known_size = status->total_sectors;
 	}
 
-	percent = dm_make_percent(status->used_sectors, status->total_sectors);
+	/*
+	 * If the snapshot has been invalidated or we failed to parse
+	 * the status string. Report the full status string to syslog.
+	 */
+	if (status->invalid || !status->total_sectors) {
+		syslog(LOG_ERR, "Snapshot %s changed state to: %s\n", device, params);
+		state->percent_check = 0;
+		goto out;
+	}
+
+	percent = (int) (100 * status->used_sectors / status->total_sectors);
 	if (percent >= state->percent_check) {
 		/* Usage has raised more than CHECK_STEP since the last
 		   time. Run actions. */
 		state->percent_check = (percent / CHECK_STEP) * CHECK_STEP + CHECK_STEP;
 
 		if (percent >= WARNING_THRESH) /* Print a warning to syslog. */
-			log_warn("WARNING: Snapshot %s is now %.2f%% full.",
-				 device, dm_percent_to_float(percent));
-
+			syslog(LOG_WARNING, "Snapshot %s is now %i%% full.\n", device, percent);
 		/* Try to extend the snapshot, in accord with user-set policies */
-		if (!_extend(state->cmd_lvextend))
-			log_error("Failed to extend snapshot %s.", device);
+		if (!_extend(state->cmd_str))
+			syslog(LOG_ERR, "Failed to extend snapshot %s.\n", device);
 	}
+
 out:
-	dm_pool_free(state->mem, status);
+	if (status)
+		dm_pool_free(state->mem, status);
+	dmeventd_lvm2_unlock();
 }
 
 int register_device(const char *device,
 		    const char *uuid __attribute__((unused)),
 		    int major __attribute__((unused)),
 		    int minor __attribute__((unused)),
-		    void **user)
+		    void **private)
 {
+	struct dm_pool *statemem = NULL;
 	struct dso_state *state;
 
-	if (!dmeventd_lvm2_init_with_pool("snapshot_state", state))
-		goto_bad;
+	if (!dmeventd_lvm2_init())
+		goto out;
 
-	if (!dmeventd_lvm2_command(state->mem, state->cmd_lvextend,
-				   sizeof(state->cmd_lvextend),
-				   "lvextend --use-policies", device)) {
-		dmeventd_lvm2_exit_with_pool(state);
-		goto_bad;
-	}
+	if (!(statemem = dm_pool_create("snapshot_state", 512)) ||
+	    !(state = dm_pool_zalloc(statemem, sizeof(*state))))
+		goto bad;
 
+	if (!dmeventd_lvm2_command(statemem, state->cmd_str,
+				   sizeof(state->cmd_str),
+				   "lvextend --use-policies", device))
+		goto bad;
+
+	state->mem = statemem;
 	state->percent_check = CHECK_MINIMUM;
-	*user = state;
+	*private = state;
 
-	log_info("Monitoring snapshot %s.", device);
+	syslog(LOG_INFO, "Monitoring snapshot %s\n", device);
 
 	return 1;
 bad:
-	log_error("Failed to monitor snapshot %s.", device);
+	if (statemem)
+		dm_pool_destroy(statemem);
+	dmeventd_lvm2_exit();
+out:
+	syslog(LOG_ERR, "Failed to monitor snapshot %s.\n", device);
 
 	return 0;
 }
@@ -274,12 +235,13 @@ int unregister_device(const char *device,
 		      const char *uuid __attribute__((unused)),
 		      int major __attribute__((unused)),
 		      int minor __attribute__((unused)),
-		      void **user)
+		      void **private)
 {
-	struct dso_state *state = *user;
+	struct dso_state *state = *private;
 
-	dmeventd_lvm2_exit_with_pool(state);
-	log_info("No longer monitoring snapshot %s.", device);
+	syslog(LOG_INFO, "No longer monitoring snapshot %s\n", device);
+	dm_pool_destroy(state->mem);
+	dmeventd_lvm2_exit();
 
 	return 1;
 }

daemons/dmeventd/plugins/thin/dmeventd_thin.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011-2015 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2011-2013 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -12,33 +12,25 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "lib.h"	/* using here lvm log */
-#include "dmeventd_lvm.h"
+#include "lib.h"
+
 #include "libdevmapper-event.h"
+#include "dmeventd_lvm.h"
 
 #include <sys/wait.h>
+#include <syslog.h> /* FIXME Replace syslog with multilog */
 #include <stdarg.h>
-#include <pthread.h>
+/* FIXME Missing openlog? */
 
-/* TODO - move this mountinfo code into library to be reusable */
-#ifdef __linux__
-#  include "kdev_t.h"
-#else
-#  define MAJOR(x) major((x))
-#  define MINOR(x) minor((x))
-#endif
-
-/* First warning when thin data or metadata is 80% full. */
-#define WARNING_THRESH	(DM_PERCENT_1 * 80)
+/* First warning when thin is 80% full. */
+#define WARNING_THRESH 80
 /* Run a check every 5%. */
-#define CHECK_STEP	(DM_PERCENT_1 *  5)
-/* Do not bother checking thin data or metadata is less than 50% full. */
-#define CHECK_MINIMUM	(DM_PERCENT_1 * 50)
+#define CHECK_STEP 5
+/* Do not bother checking thins less than 50% full. */
+#define CHECK_MINIMUM 50
 
 #define UMOUNT_COMMAND "/bin/umount"
 
-#define MAX_FAILS	(10)
-
 #define THIN_DEBUG 0
 
 struct dso_state {
@@ -47,11 +39,18 @@ struct dso_state {
 	int data_percent_check;
 	uint64_t known_metadata_size;
 	uint64_t known_data_size;
-	unsigned fails;
 	char cmd_str[1024];
 };
 
-DM_EVENT_LOG_FN("thin")
+
+/* TODO - move this mountinfo code into library to be reusable */
+#ifdef __linux__
+#  include "kdev_t.h"
+#else
+#  define MAJOR(x) major((x))
+#  define MINOR(x) minor((x))
+#  define MKDEV(x,y) makedev((x),(y))
+#endif
 
 /* Get dependencies for device, and try to find matching device */
 static int _has_deps(const char *name, int tp_major, int tp_minor, int *dev_minor)
@@ -94,8 +93,8 @@ static int _has_deps(const char *name, int tp_major, int tp_minor, int *dev_mino
 	{
 		char dev_name[PATH_MAX];
 		if (dm_device_get_name(major, minor, 0, dev_name, sizeof(dev_name)))
-			log_debug("Found %s (%u:%u) depends on %s.",
-				  name, major, *dev_minor, dev_name);
+			syslog(LOG_DEBUG, "Found %s (%u:%u) depends on %s",
+			       name, major, *dev_minor, dev_name);
 	}
 #endif
 	r = 1;
@@ -142,6 +141,14 @@ out:
 	return r;
 }
 
+static int _extend(struct dso_state *state)
+{
+#if THIN_DEBUG
+	syslog(LOG_INFO, "dmeventd executes: %s.\n", state->cmd_str);
+#endif
+	return dmeventd_lvm2_run(state->cmd_str);
+}
+
 static int _run(const char *cmd, ...)
 {
 	va_list ap;
@@ -161,12 +168,12 @@ static int _run(const char *cmd, ...)
 		argv = alloca(sizeof(const char *) * (argc + 1));
 
 		argv[0] = cmd;
-		va_start(ap, cmd);
+                va_start(ap, cmd);
 		while ((argv[++i] = va_arg(ap, const char *)));
 		va_end(ap);
 
 		execvp(cmd, (char **)argv);
-		log_sys_error("exec", cmd);
+		syslog(LOG_ERR, "Failed to execute %s: %s.\n", cmd, strerror(errno));
 		exit(127);
 	}
 
@@ -184,9 +191,9 @@ static int _run(const char *cmd, ...)
 }
 
 struct mountinfo_s {
-	const char *device;
 	struct dm_info info;
 	dm_bitset_t minors; /* Bitset for active thin pool minors */
+	const char *device;
 };
 
 static int _umount_device(char *buffer, unsigned major, unsigned minor,
@@ -195,11 +202,11 @@ static int _umount_device(char *buffer, unsigned major, unsigned minor,
 	struct mountinfo_s *data = cb_data;
 
 	if ((major == data->info.major) && dm_bit(data->minors, minor)) {
-		log_info("Unmounting thin volume %s from %s.",
-			 data->device, target);
+		syslog(LOG_INFO, "Unmounting thin volume %s from %s.\n",
+		       data->device, target);
 		if (!_run(UMOUNT_COMMAND, "-fl", target, NULL))
-			log_error("Failed to umount thin %s from %s: %s.",
-				  data->device, target, strerror(errno));
+			syslog(LOG_ERR, "Failed to umount thin %s from %s: %s.\n",
+			       data->device, target, strerror(errno));
 	}
 
 	return 1;
@@ -209,94 +216,78 @@ static int _umount_device(char *buffer, unsigned major, unsigned minor,
  * Find all thin pool users and try to umount them.
  * TODO: work with read-only thin pool support
  */
-static void _umount(struct dm_task *dmt)
+static void _umount(struct dm_task *dmt, const char *device)
 {
 	/* TODO: Convert to use hash to reduce memory usage */
 	static const size_t MINORS = (1U << 20); /* 20 bit */
-	struct mountinfo_s data = { NULL };
+	struct mountinfo_s data = {
+		.device = device,
+	};
 
 	if (!dm_task_get_info(dmt, &data.info))
 		return;
 
-	data.device = dm_task_get_name(dmt);
+	dmeventd_lvm2_unlock();
 
 	if (!(data.minors = dm_bitset_create(NULL, MINORS))) {
-		log_error("Failed to allocate bitset. Not unmounting %s.", data.device);
+		syslog(LOG_ERR, "Failed to allocate bitset. Not unmounting %s.\n", device);
 		goto out;
 	}
 
 	if (!_find_all_devs(data.minors, data.info.major, data.info.minor)) {
-		log_error("Failed to detect mounted volumes for %s.", data.device);
+		syslog(LOG_ERR, "Failed to detect mounted volumes for %s.\n", device);
 		goto out;
 	}
 
 	if (!dm_mountinfo_read(_umount_device, &data)) {
-		log_error("Could not parse mountinfo file.");
+		syslog(LOG_ERR, "Could not parse mountinfo file.\n");
 		goto out;
 	}
 
 out:
 	if (data.minors)
 		dm_bitset_destroy(data.minors);
-}
-
-static void _use_policy(struct dm_task *dmt, struct dso_state *state)
-{
-#if THIN_DEBUG
-	log_info("dmeventd executes: %s.", state->cmd_str);
-#endif
-	if (!dmeventd_lvm2_run_with_lock(state->cmd_str)) {
-		log_error("Failed to extend thin pool %s.",
-			  dm_task_get_name(dmt));
-		_umount(dmt);
-		state->fails++;
-	} else
-		state->fails = 0;
+	dmeventd_lvm2_lock();
 }
 
 void process_event(struct dm_task *dmt,
 		   enum dm_event_mask event __attribute__((unused)),
-		   void **user)
+		   void **private)
 {
 	const char *device = dm_task_get_name(dmt);
 	int percent;
-	struct dso_state *state = *user;
+	struct dso_state *state = *private;
 	struct dm_status_thin_pool *tps = NULL;
 	void *next = NULL;
 	uint64_t start, length;
 	char *target_type = NULL;
 	char *params;
-	int needs_policy = 0;
 
 #if 0
 	/* No longer monitoring, waiting for remove */
 	if (!state->meta_percent_check && !state->data_percent_check)
 		return;
 #endif
-	if (event & DM_EVENT_DEVICE_ERROR) {
-		/* Error -> no need to check and do instant resize */
-		_use_policy(dmt, state);
-		goto out;
-	}
+	dmeventd_lvm2_lock();
 
 	dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
 
 	if (!target_type || (strcmp(target_type, "thin-pool") != 0)) {
-		log_error("Invalid target type.");
+		syslog(LOG_ERR, "Invalid target type.\n");
 		goto out;
 	}
 
 	if (!dm_get_status_thin_pool(state->mem, params, &tps)) {
-		log_error("Failed to parse status.");
-		_umount(dmt);
+		syslog(LOG_ERR, "Failed to parse status.\n");
+		_umount(dmt, device);
 		goto out;
 	}
 
 #if THIN_DEBUG
-	log_debug("Thin pool status " FMTu64 "/" FMTu64 "  "
-		  FMTu64 "/" FMTu64 ".",
-		  tps->used_metadata_blocks, tps->total_metadata_blocks,
-		  tps->used_data_blocks, tps->total_data_blocks);
+	syslog(LOG_INFO, "%p: Got status %" PRIu64 " / %" PRIu64
+	       " %" PRIu64  " / %" PRIu64 ".\n", state,
+	       tps->used_metadata_blocks, tps->total_metadata_blocks,
+	       tps->used_data_blocks, tps->total_data_blocks);
 #endif
 
 	/* Thin pool size had changed. Clear the threshold. */
@@ -310,7 +301,7 @@ void process_event(struct dm_task *dmt,
 		state->known_data_size = tps->total_data_blocks;
 	}
 
-	percent = dm_make_percent(tps->used_metadata_blocks, tps->total_metadata_blocks);
+	percent = 100 * tps->used_metadata_blocks / tps->total_metadata_blocks;
 	if (percent >= state->metadata_percent_check) {
 		/*
 		 * Usage has raised more than CHECK_STEP since the last
@@ -320,12 +311,18 @@ void process_event(struct dm_task *dmt,
 
 		/* FIXME: extension of metadata needs to be written! */
 		if (percent >= WARNING_THRESH) /* Print a warning to syslog. */
-			log_warn("WARNING: Thin pool %s metadata is now %.2f%% full.",
-				 device, dm_percent_to_float(percent));
-		needs_policy = 1;
+			syslog(LOG_WARNING, "Thin metadata %s is now %i%% full.\n",
+			       device, percent);
+		 /* Try to extend the metadata, in accord with user-set policies */
+		if (!_extend(state)) {
+			syslog(LOG_ERR, "Failed to extend thin metadata %s.\n",
+			       device);
+			_umount(dmt, device);
+		}
+		/* FIXME: hmm READ-ONLY switch should happen in error path */
 	}
 
-	percent = dm_make_percent(tps->used_data_blocks, tps->total_data_blocks);
+	percent = 100 * tps->used_data_blocks / tps->total_data_blocks;
 	if (percent >= state->data_percent_check) {
 		/*
 		 * Usage has raised more than CHECK_STEP since
@@ -334,53 +331,56 @@ void process_event(struct dm_task *dmt,
 		state->data_percent_check = (percent / CHECK_STEP) * CHECK_STEP + CHECK_STEP;
 
 		if (percent >= WARNING_THRESH) /* Print a warning to syslog. */
-			log_warn("WARNING: Thin pool %s data is now %.2f%% full.",
-				 device, dm_percent_to_float(percent));
-		needs_policy = 1;
+			syslog(LOG_WARNING, "Thin %s is now %i%% full.\n", device, percent);
+		/* Try to extend the thin data, in accord with user-set policies */
+		if (!_extend(state)) {
+			syslog(LOG_ERR, "Failed to extend thin %s.\n", device);
+			state->data_percent_check = 0;
+			_umount(dmt, device);
+		}
+		/* FIXME: hmm READ-ONLY switch should happen in error path */
 	}
-
-	if (needs_policy)
-		_use_policy(dmt, state);
 out:
 	if (tps)
 		dm_pool_free(state->mem, tps);
 
-	if (state->fails >= MAX_FAILS) {
-		log_warn("WARNING: Dropping monitoring of %s. "
-			 "lvm2 command fails too often (%u times in raw).",
-			 device, state->fails);
-		pthread_kill(pthread_self(), SIGALRM);
-	}
+	dmeventd_lvm2_unlock();
 }
 
 int register_device(const char *device,
 		    const char *uuid __attribute__((unused)),
 		    int major __attribute__((unused)),
 		    int minor __attribute__((unused)),
-		    void **user)
+		    void **private)
 {
+	struct dm_pool *statemem = NULL;
 	struct dso_state *state;
 
-	if (!dmeventd_lvm2_init_with_pool("thin_pool_state", state))
-		goto_bad;
+	if (!dmeventd_lvm2_init())
+		goto bad;
 
-	if (!dmeventd_lvm2_command(state->mem, state->cmd_str,
+	if (!(statemem = dm_pool_create("thin_pool_state", 2048)) ||
+	    !(state = dm_pool_zalloc(statemem, sizeof(*state))) ||
+	    !dmeventd_lvm2_command(statemem, state->cmd_str,
 				   sizeof(state->cmd_str),
 				   "lvextend --use-policies",
 				   device)) {
-		dmeventd_lvm2_exit_with_pool(state);
-		goto_bad;
+		if (statemem)
+			dm_pool_destroy(statemem);
+		dmeventd_lvm2_exit();
+		goto bad;
 	}
 
+	state->mem = statemem;
 	state->metadata_percent_check = CHECK_MINIMUM;
 	state->data_percent_check = CHECK_MINIMUM;
-	*user = state;
+	*private = state;
 
-	log_info("Monitoring thin %s.", device);
+	syslog(LOG_INFO, "Monitoring thin %s.\n", device);
 
 	return 1;
 bad:
-	log_error("Failed to monitor thin %s.", device);
+	syslog(LOG_ERR, "Failed to monitor thin %s.\n", device);
 
 	return 0;
 }
@@ -389,12 +389,13 @@ int unregister_device(const char *device,
 		      const char *uuid __attribute__((unused)),
 		      int major __attribute__((unused)),
 		      int minor __attribute__((unused)),
-		      void **user)
+		      void **private)
 {
-	struct dso_state *state = *user;
+	struct dso_state *state = *private;
 
-	dmeventd_lvm2_exit_with_pool(state);
-	log_info("No longer monitoring thin %s.", device);
+	syslog(LOG_INFO, "No longer monitoring thin %s.\n", device);
+	dm_pool_destroy(state->mem);
+	dmeventd_lvm2_exit();
 
 	return 1;
 }

daemons/lvmetad/.gitignore

@@ -1,2 +0,0 @@
-lvmetad
-lvmetactl

daemons/lvmetad/Makefile.in

@@ -18,7 +18,7 @@ top_builddir = @top_builddir@
 SOURCES = lvmetad-core.c
 SOURCES2 = testclient.c
 
-TARGETS = lvmetad lvmetactl
+TARGETS = lvmetad
 
 .PHONY: install_lvmetad
 
@@ -41,12 +41,6 @@ lvmetad: $(OBJECTS) $(top_builddir)/libdaemon/client/libdaemonclient.a \
 		    $(top_builddir)/libdaemon/server/libdaemonserver.a
 	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJECTS) $(LVMLIBS) $(LIBS)
 
-lvmetactl: lvmetactl.o $(top_builddir)/libdaemon/client/libdaemonclient.a \
-	$(top_builddir)/libdaemon/server/libdaemonserver.a
-	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ lvmetactl.o $(LVMLIBS)
-
-CLEAN_TARGETS += lvmetactl.o
-
 # TODO: No idea. No idea how to test either.
 #ifneq ("$(CFLOW_CMD)", "")
 #CFLOW_SOURCES = $(addprefix $(srcdir)/, $(SOURCES))

daemons/lvmetad/lvmetactl.c

@@ -1,208 +0,0 @@
-/*
- * Copyright (C) 2014 Red Hat, Inc.
- *
- * This file is part of LVM2.
- *
- * This copyrighted material is made available to anyone wishing to use,
- * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU Lesser General Public License v.2.1.
- */
-
-#include "tool.h"
-
-#include "lvmetad-client.h"
-
-daemon_handle h;
-
-static void print_reply(daemon_reply reply)
-{
-	const char *a = daemon_reply_str(reply, "response", NULL);
-	const char *b = daemon_reply_str(reply, "status", NULL);
-	const char *c = daemon_reply_str(reply, "reason", NULL);
-
-	printf("response \"%s\" status \"%s\" reason \"%s\"\n",
-	       a ? a : "", b ? b : "", c ? c : "");
-}
-
-int main(int argc, char **argv)
-{
-	daemon_reply reply;
-	char *cmd;
-	char *uuid;
-	char *name;
-	int val;
-	int ver;
-
-	if (argc < 2) {
-		printf("lvmetactl dump\n");
-		printf("lvmetactl pv_list\n");
-		printf("lvmetactl vg_list\n");
-		printf("lvmetactl vg_lookup_name <name>\n");
-		printf("lvmetactl vg_lookup_uuid <uuid>\n");
-		printf("lvmetactl pv_lookup_uuid <uuid>\n");
-		printf("lvmetactl set_global_invalid 0|1\n");
-		printf("lvmetactl get_global_invalid\n");
-		printf("lvmetactl set_vg_version <uuid> <name> <version>\n");
-		printf("lvmetactl vg_lock_type <uuid>\n");
-		return -1;
-	}
-
-	cmd = argv[1];
-
-	h = lvmetad_open(NULL);
-
-	if (!strcmp(cmd, "dump")) {
-		reply = daemon_send_simple(h, "dump",
-					   "token = %s", "skip",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else if (!strcmp(cmd, "pv_list")) {
-		reply = daemon_send_simple(h, "pv_list",
-					   "token = %s", "skip",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else if (!strcmp(cmd, "vg_list")) {
-		reply = daemon_send_simple(h, "vg_list",
-					   "token = %s", "skip",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else if (!strcmp(cmd, "set_global_invalid")) {
-		if (argc < 3) {
-			printf("set_global_invalid 0|1\n");
-			return -1;
-		}
-		val = atoi(argv[2]);
-
-		reply = daemon_send_simple(h, "set_global_info",
-					   "global_invalid = %d", val,
-					   "token = %s", "skip",
-					   NULL);
-		print_reply(reply);
-
-	} else if (!strcmp(cmd, "get_global_invalid")) {
-		reply = daemon_send_simple(h, "get_global_info",
-					   "token = %s", "skip",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else if (!strcmp(cmd, "set_vg_version")) {
-		if (argc < 5) {
-			printf("set_vg_version <uuid> <name> <ver>\n");
-			return -1;
-		}
-		uuid = argv[2];
-		name = argv[3];
-		ver = atoi(argv[4]);
-
-		if ((strlen(uuid) == 1) && (uuid[0] == '-'))
-			uuid = NULL;
-		if ((strlen(name) == 1) && (name[0] == '-'))
-			name = NULL;
-
-		if (uuid && name) {
-			reply = daemon_send_simple(h, "set_vg_info",
-						   "uuid = %s", uuid,
-						   "name = %s", name,
-						   "version = %d", 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);
-		} else if (name) {
-			reply = daemon_send_simple(h, "set_vg_info",
-						   "name = %s", name,
-						   "version = %d", ver,
-						    "token = %s", "skip",
-						    NULL);
-		} else {
-			printf("name or uuid required\n");
-			return -1;
-		}
-
-		print_reply(reply);
-
-	} else if (!strcmp(cmd, "vg_lookup_name")) {
-		if (argc < 3) {
-			printf("vg_lookup_name <name>\n");
-			return -1;
-		}
-		name = argv[2];
-
-		reply = daemon_send_simple(h, "vg_lookup",
-					   "name = %s", name,
-					   "token = %s", "skip",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else if (!strcmp(cmd, "vg_lookup_uuid")) {
-		if (argc < 3) {
-			printf("vg_lookup_uuid <uuid>\n");
-			return -1;
-		}
-		uuid = argv[2];
-
-		reply = daemon_send_simple(h, "vg_lookup",
-					   "uuid = %s", uuid,
-					   "token = %s", "skip",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else if (!strcmp(cmd, "vg_lock_type")) {
-		struct dm_config_node *metadata;
-		const char *lock_type;
-
-		if (argc < 3) {
-			printf("vg_lock_type <uuid>\n");
-			return -1;
-		}
-		uuid = argv[2];
-
-		reply = daemon_send_simple(h, "vg_lookup",
-					   "uuid = %s", uuid,
-					   "token = %s", "skip",
-					   NULL);
-		/* printf("%s\n", reply.buffer.mem); */
-
-		metadata = dm_config_find_node(reply.cft->root, "metadata");
-		if (!metadata) {
-			printf("no metadata\n");
-			goto out;
-		}
-
-		lock_type = dm_config_find_str(metadata, "metadata/lock_type", NULL);
-		if (!lock_type) {
-			printf("no lock_type\n");
-			goto out;
-		}
-		printf("lock_type %s\n", lock_type);
-
-	} else if (!strcmp(cmd, "pv_lookup_uuid")) {
-		if (argc < 3) {
-			printf("pv_lookup_uuid <uuid>\n");
-			return -1;
-		}
-		uuid = argv[2];
-
-		reply = daemon_send_simple(h, "pv_lookup",
-					   "uuid = %s", uuid,
-					   "token = %s", "skip",
-					   NULL);
-		printf("%s\n", reply.buffer.mem);
-
-	} else {
-		printf("unknown command\n");
-		goto out_close;
-	}
-out:
-	daemon_reply_destroy(reply);
-out_close:
-	daemon_close(h);
-	return 0;
-}

daemons/lvmetad/lvmetad-core.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2015 Red Hat, Inc.
+ * Copyright (C) 2012 Red Hat, Inc.
  *
  * This file is part of LVM2.
  *
@@ -14,18 +14,17 @@
 
 #define _XOPEN_SOURCE 500  /* pthread */
 
-#define _REENTRANT
-
-#include "tool.h"
-
+#include "configure.h"
 #include "daemon-io.h"
+#include "config-util.h"
 #include "daemon-server.h"
 #include "daemon-log.h"
 #include "lvm-version.h"
 
 #include <assert.h>
-#include <errno.h>
 #include <pthread.h>
+#include <stdint.h>
+#include <unistd.h>
 
 #define LVMETAD_SOCKET DEFAULT_RUN_DIR "/lvmetad.socket"
 
@@ -124,7 +123,6 @@ struct vg_info {
 #define VGFL_INVALID 0x00000001
 
 typedef struct {
-	daemon_idle *idle;
 	log_state *log; /* convenience */
 	const char *log_config;
 
@@ -580,7 +578,7 @@ static void mark_outdated_pv(lvmetad_state *s, const char *vgid, const char *pvi
 		    !(cft_vgid = make_text_node(outdated_pvs, "vgid", dm_pool_strdup(outdated_pvs->mem, vgid),
 						outdated_pvs->root, NULL)))
 			abort();
-		if (!dm_hash_insert(s->vgid_to_outdated_pvs, cft_vgid->v->v.str, outdated_pvs))
+		if(!dm_hash_insert(s->vgid_to_outdated_pvs, cft_vgid->v->v.str, outdated_pvs))
 			abort();
 		DEBUGLOG(s, "created outdated_pvs list for VG %s", vgid);
 	}
@@ -1001,8 +999,7 @@ static response pv_gone(lvmetad_state *s, request r)
 
 	DEBUGLOG(s, "pv_gone (updated): %s / %" PRIu64, pvid, device);
 
-	if (!(pvmeta = dm_hash_lookup(s->pvid_to_pvmeta, pvid)))
-		return reply_unknown("PVID does not exist");
+	pvmeta = dm_hash_lookup(s->pvid_to_pvmeta, pvid);
 	vgid = dm_hash_lookup(s->pvid_to_vgid, pvid);
 
 	dm_hash_remove_binary(s->device_to_pvid, &device, sizeof(device));
@@ -1024,6 +1021,9 @@ static response pv_gone(lvmetad_state *s, request r)
 		dm_free(vgid);
 	}
 
+	if (!pvmeta)
+		return reply_unknown("PVID does not exist");
+
 	if (!alt_device)
 		dm_config_destroy(pvmeta);
 
@@ -1312,29 +1312,20 @@ static response set_vg_info(lvmetad_state *s, request r)
 {
 	struct dm_config_tree *vg;
 	struct vg_info *info;
-	const char *name;
-	const char *uuid;
+	const char *uuid = daemon_request_str(r, "uuid", NULL);
 	const int64_t new_version = daemon_request_int(r, "version", -1);
 	int64_t cache_version;
 
+	if (!uuid)
+		goto out;
+
 	if (new_version == -1)
 		goto out;
 
-	if (!(uuid = daemon_request_str(r, "uuid", NULL)))
-		goto use_name;
-
-	if ((vg = dm_hash_lookup(s->vgid_to_metadata, uuid)))
-		goto vers;
-use_name:
-	if (!(name = daemon_request_str(r, "name", NULL)))
+	vg = dm_hash_lookup(s->vgid_to_metadata, uuid);
+	if (!vg)
 		goto out;
 
-	if (!(uuid = dm_hash_lookup(s->vgname_to_vgid, name)))
-		goto out;
-
-	if (!(vg = dm_hash_lookup(s->vgid_to_metadata, uuid)))
-		goto out;
-vers:
 	if (!new_version)
 		goto inval;
 
@@ -1349,8 +1340,7 @@ inval:
 		if (!info)
 			goto bad;
 		memset(info, 0, sizeof(struct vg_info));
-		if (!dm_hash_insert(s->vgid_to_info, uuid, (void*)info))
-			goto bad;
+		dm_hash_insert(s->vgid_to_info, uuid, (void*)info);
 	}
 
 	info->external_version = new_version;
@@ -1594,9 +1584,6 @@ static int init(daemon_state *s)
 	/* if (ls->initial_registrations)
 	   _process_initial_registrations(ds->initial_registrations); */
 
-	if (ls->idle)
-		ls->idle->is_idle = 1;
-
 	return 1;
 }
 
@@ -1619,39 +1606,21 @@ static int fini(daemon_state *s)
 	return 1;
 }
 
-static int process_timeout_arg(const char *str, unsigned *max_timeouts)
-{
-	char *endptr;
-	unsigned long l;
-
-	errno = 0;
-	l = strtoul(str, &endptr, 10);
-	if (errno || *endptr || l >= UINT_MAX)
-		return 0;
-
-	*max_timeouts = (unsigned) l;
-
-	return 1;
-}
-
 static void usage(const char *prog, FILE *file)
 {
 	fprintf(file, "Usage:\n"
-		"%s [-V] [-h] [-f] [-l level[,level ...]] [-s path] [-t secs]\n\n"
+		"%s [-V] [-h] [-f] [-l {all|wire|debug}] [-s path]\n\n"
 		"   -V       Show version of lvmetad\n"
 		"   -h       Show this help information\n"
 		"   -f       Don't fork, run in the foreground\n"
-		"   -l       Logging message levels (all,fatal,error,warn,info,wire,debug)\n"
+		"   -l       Logging message level (-l {all|wire|debug})\n"
 		"   -p       Set path to the pidfile\n"
-		"   -s       Set path to the socket to listen on\n"
-		"   -t       Time to wait in seconds before shutdown on idle (missing or 0 = inifinite)\n\n", prog);
+		"   -s       Set path to the socket to listen on\n\n", prog);
 }
 
 int main(int argc, char *argv[])
 {
 	signed char opt;
-	struct timeval timeout;
-	daemon_idle di = { .ptimeout = &timeout };
 	lvmetad_state ls = { .log_config = "" };
 	daemon_state s = {
 		.daemon_fini = fini,
@@ -1666,7 +1635,7 @@ int main(int argc, char *argv[])
 	};
 
 	// use getopt_long
-	while ((opt = getopt(argc, argv, "?fhVl:p:s:t:")) != EOF) {
+	while ((opt = getopt(argc, argv, "?fhVl:p:s:")) != EOF) {
 		switch (opt) {
 		case 'h':
 			usage(argv[0], stdout);
@@ -1686,15 +1655,6 @@ int main(int argc, char *argv[])
 		case 's': // --socket
 			s.socket_path = optarg;
 			break;
-		case 't':
-			if (!process_timeout_arg(optarg, &di.max_timeouts)) {
-				fprintf(stderr, "Invalid value of timeout parameter.\n");
-				exit(EXIT_FAILURE);
-			}
-			/* 0 equals to wait indefinitely */
-			if (di.max_timeouts)
-				s.idle = ls.idle = &di;
-			break;
 		case 'V':
 			printf("lvmetad version: " LVM_VERSION "\n");
 			exit(1);

daemons/lvmetad/testclient.c

@@ -1,18 +1,3 @@
-/*
- * Copyright (C) 2011-2014 Red Hat, Inc.
- *
- * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-#include "tool.h"
-
 #include "lvmetad-client.h"
 #include "label.h"
 #include "lvmcache.h"
@@ -124,7 +109,7 @@ int main(int argc, char **argv) {
 
 	if (argc > 1) {
 		int i;
-		struct cmd_context *cmd = create_toolcontext(0, NULL, 0, 0, 1, 1);
+		struct cmd_context *cmd = create_toolcontext(0, NULL, 0, 0);
 		for (i = 1; i < argc; ++i) {
 			const char *uuid = NULL;
 			scan(h, argv[i]);

daemons/lvmlockd/.gitignore

@@ -1,2 +0,0 @@
-lvmlockctl
-lvmlockd

daemons/lvmlockd/Makefile.in

@@ -15,15 +15,10 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 top_builddir = @top_builddir@
 
-SOURCES = lvmlockd-core.c
-
-ifeq ("@BUILD_LOCKDSANLOCK@", "yes")
-  SOURCES += lvmlockd-sanlock.c
-endif
-
-ifeq ("@BUILD_LOCKDDLM@", "yes")
-  SOURCES += lvmlockd-dlm.c
-endif
+SOURCES = \
+	lvmlockd-core.c \
+	lvmlockd-sanlock.c \
+	lvmlockd-dlm.c
 
 TARGETS = lvmlockd lvmlockctl
 
@@ -34,15 +29,7 @@ include $(top_builddir)/make.tmpl
 INCLUDES += -I$(top_srcdir)/libdaemon/server
 LVMLIBS = -ldaemonserver $(LVMINTERNAL_LIBS) -ldevmapper
 
-LIBS += $(PTHREAD_LIBS)
-
-ifeq ("@BUILD_LOCKDSANLOCK@", "yes")
-  LIBS += -lsanlock_client
-endif
-
-ifeq ("@BUILD_LOCKDDLM@", "yes")
-  LIBS += -ldlm_lt
-endif
+LIBS += $(PTHREAD_LIBS) -ldlm_lt -lsanlock_client -lrt
 
 LDFLAGS += -L$(top_builddir)/libdaemon/server
 CLDFLAGS += -L$(top_builddir)/libdaemon/server

daemons/lvmlockd/lvmlockctl.c

@@ -1,48 +1,46 @@
-/*
- * Copyright (C) 2014-2015 Red Hat, Inc.
- *
- * This file is part of LVM2.
- *
- * This copyrighted material is made available to anyone wishing to use,
- * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU Lesser General Public License v.2.1.
- */
-
-#include "tool.h"
-
+#define _GNU_SOURCE
+#include "configure.h"
 #include "lvmlockd-client.h"
 
+#include <stdio.h>
+#include <stdint.h>
 #include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include <getopt.h>
+#include <string.h>
 #include <signal.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <syslog.h>
+#include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
-static int quit = 0;
-static int info = 0;
-static int dump = 0;
-static int wait_opt = 0;
-static int force_opt = 0;
-static int kill_vg = 0;
-static int drop_vg = 0;
-static int gl_enable = 0;
-static int gl_disable = 0;
-static int stop_lockspaces = 0;
-static char *arg_vg_name = NULL;
+static int quit;
+static int info;
+static int dump;
+static int wait_opt;
+static int force_opt;
+static int gl_enable;
+static int gl_disable;
+static int stop_lockspaces;
+static char *able_vg_name;
 
 #define DUMP_SOCKET_NAME "lvmlockd-dump.sock"
 #define DUMP_BUF_SIZE (1024 * 1024)
-static char dump_buf[DUMP_BUF_SIZE+1];
+static char dump_buf[DUMP_BUF_SIZE];
 static int dump_len;
 static struct sockaddr_un dump_addr;
 static socklen_t dump_addrlen;
 
 daemon_handle _lvmlockd;
 
+#define log_debug(fmt, args...) \
+do { \
+	printf(fmt "\n", ##args); \
+} while (0)
+
 #define log_error(fmt, args...) \
 do { \
 	printf(fmt "\n", ##args); \
@@ -100,8 +98,6 @@ static void find_client_info(uint32_t client_id, uint32_t *pid, char *cl_name)
 	}
 }
 
-static int first_ls = 1;
-
 static void format_info_ls(char *line)
 {
 	char ls_name[MAX_NAME+1] = { 0 };
@@ -114,9 +110,7 @@ static void format_info_ls(char *line)
 	sscanf(line, "info=ls ls_name=%s vg_name=%s vg_uuid=%s vg_sysid=%s vg_args=%s lm_type=%s",
 	       ls_name, vg_name, vg_uuid, vg_sysid, lock_args, lock_type);
 
-	if (!first_ls)
-		printf("\n");
-	first_ls = 0;
+	printf("\n");
 
 	printf("VG %s lock_type=%s %s\n", vg_name, lock_type, vg_uuid);
 
@@ -137,7 +131,7 @@ static void format_info_ls_action(char *line)
 
 	find_client_info(client_id, &pid, cl_name);
 
-	printf("OP %s pid %u (%s)\n", op, pid, cl_name);
+	printf("OP %s pid %u (%s)", op, pid, cl_name);
 }
 
 static void format_info_r(char *line, char *r_name_out, char *r_type_out)
@@ -151,20 +145,21 @@ static void format_info_r(char *line, char *r_name_out, char *r_type_out)
 	sscanf(line, "info=r name=%s type=%s mode=%s %s version=%u",
 	       r_name, r_type, mode, sh_count, &ver);
 
-	strcpy(r_name_out, r_name);
-	strcpy(r_type_out, r_type);
-
 	/* when mode is not un, wait and print each lk line */
-	if (strcmp(mode, "un"))
+
+	if (strcmp(mode, "un")) {
+		strcpy(r_name_out, r_name);
+		strcpy(r_type_out, r_type);
 		return;
+	}
 
 	/* when mode is un, there will be no lk lines, so print now */
 
 	if (!strcmp(r_type, "gl")) {
-		printf("LK GL un ver %u\n", ver);
+		printf("LK GL un ver %4u\n", ver);
 
 	} else if (!strcmp(r_type, "vg")) {
-		printf("LK VG un ver %u\n", ver);
+		printf("LK VG un ver %4u\n", ver);
 
 	} else if (!strcmp(r_type, "lv")) {
 		printf("LK LV un %s\n", r_name);
@@ -192,10 +187,10 @@ static void format_info_lk(char *line, char *r_name, char *r_type)
 	find_client_info(client_id, &pid, cl_name);
 
 	if (!strcmp(r_type, "gl")) {
-		printf("LK GL %s ver %u pid %u (%s)\n", mode, ver, pid, cl_name);
+		printf("LK GL %s ver %4u pid %u (%s)\n", mode, ver, pid, cl_name);
 
 	} else if (!strcmp(r_type, "vg")) {
-		printf("LK VG %s ver %u pid %u (%s)\n", mode, ver, pid, cl_name);
+		printf("LK VG %s ver %4u pid %u (%s)\n", mode, ver, pid, cl_name);
 
 	} else if (!strcmp(r_type, "lv")) {
 		printf("LK LV %s %s\n", mode, r_name);
@@ -228,25 +223,28 @@ static void format_info_r_action(char *line, char *r_name, char *r_type)
 	find_client_info(client_id, &pid, cl_name);
 
 	if (strcmp(op, "lock")) {
-		printf("OP %s pid %u (%s)\n", op, pid, cl_name);
+		printf("OP %s pid %u (%s)", op, pid, cl_name);
 		return;
 	}
 
 	if (!strcmp(r_type, "gl")) {
-		printf("LW GL %s ver %u pid %u (%s)\n", mode, 0, pid, cl_name);
+		printf("LW GL %s ver %4u pid %u (%s)\n", mode, 0, pid, cl_name);
 
 	} else if (!strcmp(r_type, "vg")) {
-		printf("LW VG %s ver %u pid %u (%s)\n", mode, 0, pid, cl_name);
+		printf("LW VG %s ver %4u pid %u (%s)\n", mode, 0, pid, cl_name);
 
 	} else if (!strcmp(r_type, "lv")) {
 		printf("LW LV %s %s\n", mode, r_name);
 	}
 }
 
-static void format_info_line(char *line, char *r_name, char *r_type)
+static void format_info_line(char *line)
 {
+	char r_name[MAX_NAME+1];
+	char r_type[MAX_NAME+1];
+
 	if (!strncmp(line, "info=structs ", strlen("info=structs "))) {
-		/* only print this in the raw info dump */
+		printf("%s\n", line);
 
 	} else if (!strncmp(line, "info=client ", strlen("info=client "))) {
 		save_client_info(line);
@@ -258,13 +256,8 @@ static void format_info_line(char *line, char *r_name, char *r_type)
 		format_info_ls_action(line);
 
 	} else if (!strncmp(line, "info=r ", strlen("info=r "))) {
-		/*
-		 * r_name/r_type are reset when a new resource is found.
-		 * They are reused for the lock and action lines that
-		 * follow a resource line.
-		 */
-		memset(r_name, 0, MAX_NAME+1);
-		memset(r_type, 0, MAX_NAME+1);
+		memset(r_name, 0, sizeof(r_name));
+		memset(r_type, 0, sizeof(r_type));
 		format_info_r(line, r_name, r_type);
 
 	} else if (!strncmp(line, "info=lk ", strlen("info=lk "))) {
@@ -282,8 +275,6 @@ static void format_info_line(char *line, char *r_name, char *r_type)
 static void format_info(void)
 {
 	char line[MAX_LINE];
-	char r_name[MAX_NAME+1];
-	char r_type[MAX_NAME+1];
 	int i, j;
 
 	j = 0;
@@ -293,7 +284,7 @@ static void format_info(void)
 		line[j++] = dump_buf[i];
 
 		if ((line[j-1] == '\n') || (line[j-1] == '\0')) {
-			format_info_line(line, r_name, r_type);
+			format_info_line(line);
 			j = 0;
 			memset(line, 0, sizeof(line));
 		}
@@ -326,6 +317,8 @@ static daemon_reply _lvmlockd_send(const char *req_name, ...)
 static int _lvmlockd_result(daemon_reply reply, int *result)
 {
 	int reply_result;
+	const char *reply_flags;
+	const char *lock_type;
 
 	if (reply.error) {
 		log_error("lvmlockd_result reply error %d", reply.error);
@@ -343,8 +336,14 @@ static int _lvmlockd_result(daemon_reply reply, int *result)
 		return 0;
 	}
 
+	/* The lock_type that lvmlockd used for locking. */
+	lock_type = daemon_reply_str(reply, "lock_type", "none");
+
 	*result = reply_result;
 
+	reply_flags = daemon_reply_str(reply, "result_flags", NULL);
+
+	log_debug("lvmlockd_result %d %s lm %s", reply_result, reply_flags, lock_type);
 	return 1;
 }
 
@@ -378,12 +377,8 @@ static int setup_dump_socket(void)
 	dump_addrlen = sizeof(sa_family_t) + strlen(dump_addr.sun_path+1) + 1;
 
 	rv = bind(s, (struct sockaddr *) &dump_addr, dump_addrlen);
-	if (rv < 0) {
-		rv = -errno;
-		if (!close(s))
-			log_error("failed to close dump socket");
+	if (rv < 0)
 		return rv;
-	}
 
 	return s;
 }
@@ -393,7 +388,6 @@ static int do_dump(const char *req_name)
 	daemon_reply reply;
 	int result;
 	int fd, rv = 0;
-	int count = 0;
 
 	fd = setup_dump_socket();
 	if (fd < 0) {
@@ -424,18 +418,13 @@ static int do_dump(const char *req_name)
 
 	memset(dump_buf, 0, sizeof(dump_buf));
 
-retry:
-	rv = recvfrom(fd, dump_buf + count, dump_len - count, MSG_WAITALL,
+	rv = recvfrom(fd, dump_buf, dump_len, MSG_WAITALL,
 		      (struct sockaddr *)&dump_addr, &dump_addrlen);
 	if (rv < 0) {
 		log_error("recvfrom error %d %d", rv, errno);
 		rv = -errno;
 		goto out;
 	}
-	count += rv;
-
-	if (count < dump_len)
-		goto retry;
 
 	rv = 0;
 	if ((info && dump) || !strcmp(req_name, "dump"))
@@ -443,8 +432,7 @@ retry:
 	else
 		format_info();
 out:
-	if (close(fd))
-		log_error("failed to close dump socket %d", fd);
+	close(fd);
 	return rv;
 }
 
@@ -455,9 +443,9 @@ static int do_able(const char *req_name)
 	int rv;
 
 	reply = _lvmlockd_send(req_name,
-				"cmd = %s", "lvmlockctl",
+				"cmd = %s", "lvmlock",
 				"pid = %d", getpid(),
-				"vg_name = %s", arg_vg_name,
+				"vg_name = %s", able_vg_name,
 				NULL);
 
 	if (!_lvmlockd_result(reply, &result)) {
@@ -486,7 +474,7 @@ static int do_stop_lockspaces(void)
 		strcat(opts, "force ");
 
 	reply = _lvmlockd_send("stop_all",
-				"cmd = %s", "lvmlockctl",
+				"cmd = %s", "lvmlock",
 				"pid = %d", getpid(),
 				"opts = %s", opts[0] ? opts : "none",
 				NULL);
@@ -502,87 +490,6 @@ static int do_stop_lockspaces(void)
 	return rv;
 }
 
-static int do_kill(void)
-{
-	daemon_reply reply;
-	int result;
-	int rv;
-
-	syslog(LOG_EMERG, "Lost access to sanlock lease storage in VG %s.", arg_vg_name);
-	/* These two lines explain the manual alternative to the FIXME below. */
-	syslog(LOG_EMERG, "Immediately deactivate LVs in VG %s.", arg_vg_name);
-	syslog(LOG_EMERG, "Once VG is unused, run lvmlockctl --drop %s.", arg_vg_name);
-
-	/*
-	 * It may not be strictly necessary to notify lvmlockd of the kill, but
-	 * lvmlockd can use this information to avoid attempting any new lock
-	 * requests in the VG (which would fail anyway), and can return an
-	 * error indicating that the VG has been killed.
-	 */
-
-	reply = _lvmlockd_send("kill_vg",
-				"cmd = %s", "lvmlockctl",
-				"pid = %d", getpid(),
-				"vg_name = %s", arg_vg_name,
-				NULL);
-
-	if (!_lvmlockd_result(reply, &result)) {
-		log_error("lvmlockd result %d", result);
-		rv = result;
-	} else {
-		rv = 0;
-	}
-
-	daemon_reply_destroy(reply);
-
-	/*
-	 * FIXME: here is where we should implement a strong form of
-	 * blkdeactivate, and if it completes successfully, automatically call
-	 * do_drop() afterward.  (The drop step may not always be necessary
-	 * if the lvm commands run while shutting things down release all the
-	 * leases.)
-	 *
-	 * run_strong_blkdeactivate();
-	 * do_drop();
-	 */
-
-	return rv;
-}
-
-static int do_drop(void)
-{
-	daemon_reply reply;
-	int result;
-	int rv;
-
-	syslog(LOG_WARNING, "Dropping locks for VG %s.", arg_vg_name);
-
-	/*
-	 * Check for misuse by looking for any active LVs in the VG
-	 * and refusing this operation if found?  One possible way
-	 * to kill LVs (e.g. if fs cannot be unmounted) is to suspend
-	 * them, or replace them with the error target.  In that
-	 * case the LV will still appear to be active, but it is
-	 * safe to release the lock.
-	 */
-
-	reply = _lvmlockd_send("drop_vg",
-				"cmd = %s", "lvmlockctl",
-				"pid = %d", getpid(),
-				"vg_name = %s", arg_vg_name,
-				NULL);
-
-	if (!_lvmlockd_result(reply, &result)) {
-		log_error("lvmlockd result %d", result);
-		rv = result;
-	} else {
-		rv = 0;
-	}
-
-	daemon_reply_destroy(reply);
-	return rv;
-}
-
 static void print_usage(void)
 {
 	printf("lvmlockctl options\n");
@@ -599,16 +506,12 @@ static void print_usage(void)
 	printf("      Wait option for other commands.\n");
 	printf("--force | -f 0|1>\n");
 	printf("      Force option for other commands.\n");
-	printf("--kill | -k <vgname>\n");
-	printf("      Kill access to the VG when sanlock cannot renew lease.\n");
-	printf("--drop | -r <vgname>\n");
-	printf("      Clear locks for the VG when it is unused after kill (-k).\n");
-	printf("--gl-enable | -E <vgname>\n");
-	printf("      Tell lvmlockd to enable the global lock in a sanlock VG.\n");
-	printf("--gl-disable | -D <vgname>\n");
-	printf("      Tell lvmlockd to disable the global lock in a sanlock VG.\n");
 	printf("--stop-lockspaces | -S\n");
 	printf("      Stop all lockspaces.\n");
+	printf("--gl-enable <vg_name>\n");
+	printf("      Tell lvmlockd to enable the global lock in a sanlock vg.\n");
+	printf("--gl-disable <vg_name>\n");
+	printf("      Tell lvmlockd to disable the global lock in a sanlock vg.\n");
 }
 
 static int read_options(int argc, char *argv[])
@@ -623,8 +526,6 @@ static int read_options(int argc, char *argv[])
 		{"dump",            no_argument,       0,  'd' },
 		{"wait",            required_argument, 0,  'w' },
 		{"force",           required_argument, 0,  'f' },
-		{"kill",            required_argument, 0,  'k' },
-		{"drop",            required_argument, 0,  'r' },
 		{"gl-enable",       required_argument, 0,  'E' },
 		{"gl-disable",      required_argument, 0,  'D' },
 		{"stop-lockspaces", no_argument,       0,  'S' },
@@ -637,7 +538,7 @@ static int read_options(int argc, char *argv[])
 	}
 
 	while (1) {
-		c = getopt_long(argc, argv, "hqidE:D:w:k:r:S", long_options, &option_index);
+		c = getopt_long(argc, argv, "hqidE:D:w:S", long_options, &option_index);
 		if (c == -1)
 			break;
 
@@ -661,21 +562,13 @@ static int read_options(int argc, char *argv[])
 		case 'w':
 			wait_opt = atoi(optarg);
 			break;
-		case 'k':
-			kill_vg = 1;
-			arg_vg_name = strdup(optarg);
-			break;
-		case 'r':
-			drop_vg = 1;
-			arg_vg_name = strdup(optarg);
-			break;
 		case 'E':
 			gl_enable = 1;
-			arg_vg_name = strdup(optarg);
+			able_vg_name = strdup(optarg);
 			break;
 		case 'D':
 			gl_disable = 1;
-			arg_vg_name = strdup(optarg);
+			able_vg_name = strdup(optarg);
 			break;
 		case 'S':
 			stop_lockspaces = 1;
@@ -701,7 +594,7 @@ int main(int argc, char **argv)
 	_lvmlockd = lvmlockd_open(NULL);
 
 	if (_lvmlockd.socket_fd < 0 || _lvmlockd.error) {
-		log_error("Cannot connect to lvmlockd.");
+		log_error("lvmlockd open error %d", _lvmlockd.error);
 		return -1;
 	}
 
@@ -720,24 +613,12 @@ int main(int argc, char **argv)
 		goto out;
 	}
 
-	if (kill_vg) {
-		rv = do_kill();
-		goto out;
-	}
-
-	if (drop_vg) {
-		rv = do_drop();
-		goto out;
-	}
-
 	if (gl_enable) {
-		syslog(LOG_INFO, "Enabling global lock in VG %s.", arg_vg_name);
 		rv = do_able("enable_gl");
 		goto out;
 	}
 
 	if (gl_disable) {
-		syslog(LOG_INFO, "Disabling global lock in VG %s.", arg_vg_name);
 		rv = do_able("disable_gl");
 		goto out;
 	}
@@ -751,3 +632,4 @@ out:
 	lvmlockd_close(_lvmlockd);
 	return rv;
 }
+

daemons/lvmlockd/lvmlockd-client.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2015 Red Hat, Inc.
+ * Copyright (C) 2014 Red Hat, Inc.
  *
  * This file is part of LVM2.
  *
@@ -45,8 +45,5 @@ static inline void lvmlockd_close(daemon_handle h)
 #define EMANAGER  214
 #define EPREPARE  215
 #define ELOCKD    216
-#define EVGKILLED 217 /* sanlock lost access to leases and VG is killed. */
-#define ELOCKIO   218 /* sanlock io errors during lock op, may be transient. */
-#define EREMOVED  219
 
-#endif	/* _LVM_LVMLOCKD_CLIENT_H */
+#endif

daemons/lvmlockd/lvmlockd-dlm.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2015 Red Hat, Inc.
+ * Copyright (C) 2014 Red Hat, Inc.
  *
  * This file is part of LVM2.
  *
@@ -10,9 +10,28 @@
 
 #define _XOPEN_SOURCE 500  /* pthread */
 #define _ISOC99_SOURCE
+#define _GNU_SOURCE
 
-#include "tool.h"
+#include <assert.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <poll.h>
+#include <errno.h>
+#include <string.h>
+#include <endian.h>
+#include <fcntl.h>
+#include <byteswap.h>
+#include <syslog.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
 
+#include "configure.h"
 #include "daemon-server.h"
 #include "daemon-log.h"
 #include "xlate.h"
@@ -26,17 +45,6 @@
  */
 #include "libdlm.h"
 
-#include <pthread.h>
-#include <stddef.h>
-#include <poll.h>
-#include <errno.h>
-#include <endian.h>
-#include <fcntl.h>
-#include <byteswap.h>
-#include <syslog.h>
-#include <dirent.h>
-#include <sys/socket.h>
-
 struct lm_dlm {
 	dlm_lshandle_t *dh;
 };
@@ -67,8 +75,6 @@ int lm_data_size_dlm(void)
 #define VG_LOCK_ARGS_MINOR 0
 #define VG_LOCK_ARGS_PATCH 0
 
-static int dlm_has_lvb_bug;
-
 static int cluster_name_from_args(char *vg_args, char *clustername)
 {
 	return last_string_from_args(vg_args, clustername);
@@ -98,7 +104,6 @@ static int check_args_version(char *vg_args)
 
 static int read_cluster_name(char *clustername)
 {
-	static const char close_error_msg[] = "read_cluster_name: close_error %d";
 	char *n;
 	int fd;
 	int rv;
@@ -110,30 +115,28 @@ static int read_cluster_name(char *clustername)
 
 	fd = open(DLM_CLUSTER_NAME_PATH, O_RDONLY);
 	if (fd < 0) {
-		log_debug("read_cluster_name: open error %d, check dlm_controld", fd);
+		log_error("read_cluster_name: open error %d, check dlm_controld", fd);
 		return fd;
 	}
 
-	rv = read(fd, clustername, MAX_ARGS);
+	rv = read(fd, clustername, MAX_ARGS - 1);
 	if (rv < 0) {
 		log_error("read_cluster_name: cluster name read error %d, check dlm_controld", fd);
-		if (close(fd))
-			log_error(close_error_msg, fd);
+		close(fd);
 		return rv;
 	}
 
 	n = strstr(clustername, "\n");
 	if (n)
 		*n = '\0';
-	if (close(fd))
-		log_error(close_error_msg, fd);
+	close(fd);
 	return 0;
 }
 
 int lm_init_vg_dlm(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
 {
-	char clustername[MAX_ARGS+1];
-	char lock_args_version[MAX_ARGS+1];
+	char clustername[MAX_ARGS];
+	char lock_args_version[MAX_ARGS];
 	int rv;
 
 	memset(clustername, 0, sizeof(clustername));
@@ -160,9 +163,8 @@ int lm_init_vg_dlm(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
 
 int lm_prepare_lockspace_dlm(struct lockspace *ls)
 {
-	char sys_clustername[MAX_ARGS+1];
-	char arg_clustername[MAX_ARGS+1];
-	uint32_t major = 0, minor = 0, patch = 0;
+	char sys_clustername[MAX_ARGS];
+	char arg_clustername[MAX_ARGS];
 	struct lm_dlm *lmd;
 	int rv;
 
@@ -173,17 +175,6 @@ int lm_prepare_lockspace_dlm(struct lockspace *ls)
 	if (rv < 0)
 		return -EMANAGER;
 
-	rv = dlm_kernel_version(&major, &minor, &patch);
-	if (rv < 0) {
-		log_error("prepare_lockspace_dlm kernel_version not detected %d", rv);
-		dlm_has_lvb_bug = 1;
-	}
-
-	if ((major == 6) && (minor == 0) && (patch == 1)) {
-		log_debug("dlm kernel version %u.%u.%u has lvb bug", major, minor, patch);
-		dlm_has_lvb_bug = 1;
-	}
-
 	if (!ls->vg_args[0]) {
 		/* global lockspace has no vg args */
 		goto skip_args;
@@ -260,6 +251,12 @@ int lm_rem_lockspace_dlm(struct lockspace *ls, int free_vg)
  out:
 	free(lmd);
 	ls->lm_data = NULL;
+
+	if (!strcmp(ls->name, gl_lsname_dlm)) {
+		gl_running_dlm = 0;
+		gl_auto_dlm = 0;
+	}
+
 	return 0;
 }
 
@@ -343,7 +340,7 @@ static int to_dlm_mode(int ld_mode)
 }
 
 static int lm_adopt_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
-			struct val_blk *vb_out)
+			uint32_t *r_version)
 {
 	struct lm_dlm *lmd = (struct lm_dlm *)ls->lm_data;
 	struct rd_dlm *rdd = (struct rd_dlm *)r->lm_data;
@@ -352,7 +349,7 @@ static int lm_adopt_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
 	int mode;
 	int rv;
 
-	memset(vb_out, 0, sizeof(struct val_blk));
+	*r_version = 0;
 
 	if (!r->lm_init) {
 		rv = lm_add_resource_dlm(ls, r, 0);
@@ -394,7 +391,7 @@ static int lm_adopt_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
 			  (void *)1, (void *)1, (void *)1,
 			  NULL, NULL);
 
-	if (rv == -1 && errno == -EAGAIN) {
+	if (rv == -EAGAIN) {
 		log_debug("S %s R %s adopt_dlm adopt mode %d try other mode",
 			  ls->name, r->name, ld_mode);
 		rv = -EUCLEAN;
@@ -431,13 +428,14 @@ static int lm_adopt_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
  */
 
 int lm_lock_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
-		struct val_blk *vb_out, int adopt)
+		uint32_t *r_version, int adopt)
 {
 	struct lm_dlm *lmd = (struct lm_dlm *)ls->lm_data;
 	struct rd_dlm *rdd = (struct rd_dlm *)r->lm_data;
 	struct dlm_lksb *lksb;
 	struct val_blk vb;
 	uint32_t flags = 0;
+	uint16_t vb_version;
 	int mode;
 	int rv;
 
@@ -445,7 +443,7 @@ int lm_lock_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
 		/* When adopting, we don't follow the normal method
 		   of acquiring a NL lock then converting it to the
 		   desired mode. */
-		return lm_adopt_dlm(ls, r, ld_mode, vb_out);
+		return lm_adopt_dlm(ls, r, ld_mode, r_version);
 	}
 
 	if (!r->lm_init) {
@@ -473,37 +471,19 @@ 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));
+		*r_version = 0;
 		return 0;
 	}
 
-	/*
-	 * The dlm lvb bug means that converting NL->EX will not return 
-	 * the latest lvb, so we have to convert NL->PR->EX to reread it.
-	 */
-	if (dlm_has_lvb_bug && (ld_mode == LD_LK_EX)) {
-		rv = dlm_ls_lock_wait(lmd->dh, LKM_PRMODE, lksb, flags,
-				      r->name, strlen(r->name),
-				      0, NULL, NULL, NULL);
-		if (rv == -1) {
-			log_debug("S %s R %s lock_dlm acquire mode PR for %d rv %d",
-				  ls->name, r->name, mode, rv);
-			goto lockrv;
-		}
-
-		/* Fall through to request EX. */
-	}
-
 	rv = dlm_ls_lock_wait(lmd->dh, mode, lksb, flags,
 			      r->name, strlen(r->name),
 			      0, NULL, NULL, NULL);
-lockrv:
-	if (rv == -1 && errno == EAGAIN) {
-		log_debug("S %s R %s lock_dlm acquire mode %d rv EAGAIN", ls->name, r->name, mode);
+	if (rv == -EAGAIN) {
+		log_error("S %s R %s lock_dlm mode %d rv EAGAIN", ls->name, r->name, mode);
 		return -EAGAIN;
 	}
 	if (rv < 0) {
-		log_error("S %s R %s lock_dlm acquire error %d errno %d", ls->name, r->name, rv, errno);
+		log_error("S %s R %s lock_dlm error %d", ls->name, r->name, rv);
 		return rv;
 	}
 
@@ -511,22 +491,28 @@ lockrv:
 		if (lksb->sb_flags & DLM_SBF_VALNOTVALID) {
 			log_debug("S %s R %s lock_dlm VALNOTVALID", ls->name, r->name);
 			memset(rdd->vb, 0, sizeof(struct val_blk));
-			memset(vb_out, 0, sizeof(struct val_blk));
+			*r_version = 0;
 			goto out;
 		}
 
-		/*
-		 * 'vb' contains disk endian values, not host endian.
-		 * It is copied directly to rdd->vb which is also kept
-		 * in disk endian form.
-		 * vb_out is returned to the caller in host endian form.
-		 */
 		memcpy(&vb, lksb->sb_lvbptr, sizeof(struct val_blk));
-		memcpy(rdd->vb, &vb, sizeof(vb));
+		vb_version = le16_to_cpu(vb.version);
 
-		vb_out->version = le16_to_cpu(vb.version);
-		vb_out->flags = le16_to_cpu(vb.flags);
-		vb_out->r_version = le32_to_cpu(vb.r_version);
+		if (vb_version && ((vb_version & 0xFF00) > (VAL_BLK_VERSION & 0xFF00))) {
+			log_error("S %s R %s lock_dlm ignore vb_version %x",
+				  ls->name, r->name, vb_version);
+			*r_version = 0;
+			free(rdd->vb);
+			rdd->vb = NULL;
+			lksb->sb_lvbptr = NULL;
+			goto out;
+		}
+
+		*r_version = le32_to_cpu(vb.r_version);
+		memcpy(rdd->vb, &vb, sizeof(vb)); /* rdd->vb saved as le */
+
+		log_debug("S %s R %s lock_dlm get r_version %u",
+			  ls->name, r->name, *r_version);
 	}
 out:
 	return 0;
@@ -570,7 +556,7 @@ int lm_convert_dlm(struct lockspace *ls, struct resource *r,
 	rv = dlm_ls_lock_wait(lmd->dh, mode, lksb, flags,
 			      r->name, strlen(r->name),
 			      0, NULL, NULL, NULL);
-	if (rv == -1 && errno == EAGAIN) {
+	if (rv == -EAGAIN) {
 		/* FIXME: When does this happen?  Should something different be done? */
 		log_error("S %s R %s convert_dlm mode %d rv EAGAIN", ls->name, r->name, mode);
 		return -EAGAIN;
@@ -582,17 +568,17 @@ int lm_convert_dlm(struct lockspace *ls, struct resource *r,
 }
 
 int lm_unlock_dlm(struct lockspace *ls, struct resource *r,
-		  uint32_t r_version, uint32_t lmu_flags)
+		  uint32_t r_version, uint32_t lmuf_flags)
 {
 	struct lm_dlm *lmd = (struct lm_dlm *)ls->lm_data;
 	struct rd_dlm *rdd = (struct rd_dlm *)r->lm_data;
 	struct dlm_lksb *lksb = &rdd->lksb;
-	struct val_blk vb_prev;
-	struct val_blk vb_next;
 	uint32_t flags = 0;
-	int new_vb = 0;
 	int rv;
 
+	log_debug("S %s R %s unlock_dlm r_version %u flags %x",
+		  ls->name, r->name, r_version, lmuf_flags);
+
 	/*
 	 * Do not set PERSISTENT, because we don't need an orphan
 	 * NL lock to protect anything.
@@ -600,46 +586,19 @@ int lm_unlock_dlm(struct lockspace *ls, struct resource *r,
 
 	flags |= LKF_CONVERT;
 
-	if (rdd->vb && (r->mode == LD_LK_EX)) {
-
-		/* vb_prev and vb_next are in disk endian form */
-		memcpy(&vb_prev, rdd->vb, sizeof(struct val_blk));
-		memcpy(&vb_next, rdd->vb, sizeof(struct val_blk));
-
-		if (!vb_prev.version) {
-			vb_next.version = cpu_to_le16(VAL_BLK_VERSION);
-			new_vb = 1;
+	if (rdd->vb && r_version && (r->mode == LD_LK_EX)) {
+		if (!rdd->vb->version) {
+			/* first time vb has been written */
+			rdd->vb->version = cpu_to_le16(VAL_BLK_VERSION);
 		}
+		if (r_version)
+			rdd->vb->r_version = cpu_to_le32(r_version);
+		memcpy(lksb->sb_lvbptr, rdd->vb, sizeof(struct val_blk));
 
-		if ((lmu_flags & LMUF_FREE_VG) && (r->type == LD_RT_VG)) {
-			vb_next.flags = cpu_to_le16(VBF_REMOVED);
-			new_vb = 1;
-		}
-
-		if (r_version) {
-			vb_next.r_version = cpu_to_le32(r_version);
-			new_vb = 1;
-		}
-
-		if (new_vb) {
-			memcpy(rdd->vb, &vb_next, sizeof(struct val_blk));
-			memcpy(lksb->sb_lvbptr, &vb_next, sizeof(struct val_blk));
-
-			log_debug("S %s R %s unlock_dlm vb old %x %x %u new %x %x %u",
-				  ls->name, r->name,
-				  le16_to_cpu(vb_prev.version),
-				  le16_to_cpu(vb_prev.flags),
-				  le32_to_cpu(vb_prev.r_version),
-				  le16_to_cpu(vb_next.version),
-				  le16_to_cpu(vb_next.flags),
-				  le32_to_cpu(vb_next.r_version));
-		} else {
-			log_debug("S %s R %s unlock_dlm vb unchanged", ls->name, r->name);
-		}
+		log_debug("S %s R %s unlock_dlm set r_version %u",
+			  ls->name, r->name, r_version);
 
 		flags |= LKF_VALBLK;
-	} else {
-		log_debug("S %s R %s unlock_dlm", ls->name, r->name);
 	}
 
 	if (daemon_test)
@@ -662,65 +621,8 @@ int lm_unlock_dlm(struct lockspace *ls, struct resource *r,
 
 #define DLM_LOCKSPACES_PATH "/sys/kernel/config/dlm/cluster/spaces"
 
-/*
- * FIXME: this should be implemented differently.
- * It's not nice to use an aspect of the dlm clustering
- * implementation, which could change.  It would be
- * better to do something like use a special lock in the
- * lockspace that was held PR by all nodes, and then an
- * EX request on it could check if it's started (and
- * possibly also notify others to stop it automatically).
- * Or, possibly an enhancement to libdlm that would give
- * info about lockspace members.
- *
- * (We could let the VG be removed while others still
- * have the lockspace running, which largely works, but
- * introduces problems if another VG with the same name is
- * recreated while others still have the lockspace running
- * for the previous VG.  We'd also want a way to clean up
- * the stale lockspaces on the others eventually.)
- */
-
-int lm_hosts_dlm(struct lockspace *ls, int notify)
-{
-	static const char closedir_err_msg[] = "lm_hosts_dlm: closedir failed";
-	char ls_nodes_path[PATH_MAX];
-	struct dirent *de;
-	DIR *ls_dir;
-	int count = 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);
-
-	if (!(ls_dir = opendir(ls_nodes_path)))
-		return -ECONNREFUSED;
-
-	while ((de = readdir(ls_dir))) {
-		if (de->d_name[0] == '.')
-			continue;
-		count++;
-	}
-
-	if (closedir(ls_dir))
-		log_error(closedir_err_msg);
-
-	if (!count) {
-		log_error("lm_hosts_dlm found no nodes in %s", ls_nodes_path);
-		return 0;
-	}
-
-	/*
-	 * Assume that a count of one node represents ourself,
-	 * and any value over one represents other nodes.
-	 */
-
-	return count - 1;
-}
-
 int lm_get_lockspaces_dlm(struct list_head *ls_rejoin)
 {
-	static const char closedir_err_msg[] = "lm_get_lockspace_dlm: closedir failed";
 	struct lockspace *ls;
 	struct dirent *de;
 	DIR *ls_dir;
@@ -736,8 +638,7 @@ int lm_get_lockspaces_dlm(struct list_head *ls_rejoin)
 			continue;
 
 		if (!(ls = alloc_lockspace())) {
-			if (closedir(ls_dir))
-				log_error(closedir_err_msg);
+			closedir(ls_dir);
 			return -ENOMEM;
 		}
 
@@ -747,14 +648,13 @@ int lm_get_lockspaces_dlm(struct list_head *ls_rejoin)
 		list_add_tail(&ls->list, ls_rejoin);
 	}
 
-	if (closedir(ls_dir))
-		log_error(closedir_err_msg);
+	closedir(ls_dir);
 	return 0;
 }
 
 int lm_is_running_dlm(void)
 {
-	char sys_clustername[MAX_ARGS+1];
+	char sys_clustername[MAX_ARGS];
 	int rv;
 
 	memset(sys_clustername, 0, sizeof(sys_clustername));
@@ -764,4 +664,3 @@ int lm_is_running_dlm(void)
 		return 0;
 	return 1;
 }
-

daemons/lvmlockd/lvmlockd-internal.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2015 Red Hat, Inc.
+ * Copyright (C) 2014 Red Hat, Inc.
  *
  * This file is part of LVM2.
  *
@@ -50,9 +50,6 @@ enum {
 	LD_OP_RENAME_FINAL,
 	LD_OP_RUNNING_LM,
 	LD_OP_FIND_FREE_LOCK,
-	LD_OP_KILL_VG,
-	LD_OP_DROP_VG,
-	LD_OP_BUSY,
 };
 
 /* resource types */
@@ -85,12 +82,11 @@ struct client {
 	unsigned int recv : 1;
 	unsigned int dead : 1;
 	unsigned int poll_ignore : 1;
-	unsigned int lock_ops : 1;
 	char name[MAX_NAME+1];
 };
 
 #define LD_AF_PERSISTENT           0x00000001
-#define LD_AF_NO_CLIENT            0x00000002
+#define LD_AF_UNUSED               0x00000002 /* use me */
 #define LD_AF_UNLOCK_CANCEL        0x00000004
 #define LD_AF_NEXT_VERSION         0x00000008
 #define LD_AF_WAIT                 0x00000010
@@ -101,10 +97,9 @@ struct client {
 #define LD_AF_SEARCH_LS            0x00000200
 #define LD_AF_WAIT_STARTING        0x00001000
 #define LD_AF_DUP_GL_LS            0x00002000
+#define LD_AF_INACTIVE_LS          0x00004000
+#define LD_AF_ADD_LS_ERROR         0x00008000
 #define LD_AF_ADOPT                0x00010000
-#define LD_AF_WARN_GL_REMOVED	   0x00020000
-#define LD_AF_LV_LOCK              0x00040000
-#define LD_AF_LV_UNLOCK            0x00080000
 
 /*
  * Number of times to repeat a lock request after
@@ -131,8 +126,8 @@ struct action {
 	char vg_name[MAX_NAME+1];
 	char lv_name[MAX_NAME+1];
 	char lv_uuid[MAX_NAME+1];
-	char vg_args[MAX_ARGS+1];
-	char lv_args[MAX_ARGS+1];
+	char vg_args[MAX_ARGS];
+	char lv_args[MAX_ARGS];
 	char vg_sysid[MAX_NAME+1];
 };
 
@@ -143,14 +138,13 @@ struct resource {
 	int8_t mode;
 	unsigned int sh_count;		/* number of sh locks on locks list */
 	uint32_t version;
-	uint32_t last_client_id;	/* last client_id to lock or unlock resource */
 	unsigned int lm_init : 1;	/* lm_data is initialized */
 	unsigned int adopt : 1;		/* temp flag in remove_inactive_lvs */
 	unsigned int version_zero_valid : 1;
-	unsigned int use_vb : 1;
 	struct list_head locks;
 	struct list_head actions;
-	char lv_args[MAX_ARGS+1];
+	struct val_blk *vb;
+	char lv_args[MAX_ARGS];
 	char lm_data[0];		/* lock manager specific data */
 };
 
@@ -169,7 +163,7 @@ struct lockspace {
 	char name[MAX_NAME+1];
 	char vg_name[MAX_NAME+1];
 	char vg_uuid[64];
-	char vg_args[MAX_ARGS+1];	/* lock manager specific args */
+	char vg_args[MAX_ARGS];		/* lock manager specific args */
 	char vg_sysid[MAX_NAME+1];
 	int8_t lm_type;			/* lock manager: LM_DLM, LM_SANLOCK */
 	void *lm_data;
@@ -187,20 +181,13 @@ struct lockspace {
 	unsigned int thread_done : 1;
 	unsigned int sanlock_gl_enabled: 1;
 	unsigned int sanlock_gl_dup: 1;
-	unsigned int free_vg: 1;
-	unsigned int kill_vg: 1;
-	unsigned int drop_vg: 1;
 
 	struct list_head actions;	/* new client actions */
 	struct list_head resources;	/* resource/lock state for gl/vg/lv */
 };
 
-/* val_blk version */
 #define VAL_BLK_VERSION 0x0101
 
-/* val_blk flags */
-#define VBF_REMOVED 0x0001
-
 struct val_blk {
 	uint16_t version;
 	uint16_t flags;
@@ -210,6 +197,49 @@ struct val_blk {
 /* lm_unlock flags */
 #define LMUF_FREE_VG 0x00000001
 
+struct lockspace *alloc_lockspace(void);
+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);
+
+int lm_init_vg_dlm(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
+int lm_prepare_lockspace_dlm(struct lockspace *ls);
+int lm_add_lockspace_dlm(struct lockspace *ls, int adopt);
+int lm_rem_lockspace_dlm(struct lockspace *ls, int free_vg);
+int lm_lock_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
+		uint32_t *r_version, int adopt);
+int lm_convert_dlm(struct lockspace *ls, struct resource *r,
+		   int ld_mode, uint32_t r_version);
+int lm_unlock_dlm(struct lockspace *ls, struct resource *r,
+		  uint32_t r_version, uint32_t lmu_flags);
+int lm_rem_resource_dlm(struct lockspace *ls, struct resource *r);
+int lm_get_lockspaces_dlm(struct list_head *ls_rejoin);
+int lm_data_size_dlm(void);
+int lm_is_running_dlm(void);
+
+int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
+int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, uint64_t free_offset);
+int lm_free_lv_sanlock(struct lockspace *ls, struct resource *r);
+int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
+int lm_prepare_lockspace_sanlock(struct lockspace *ls);
+int lm_add_lockspace_sanlock(struct lockspace *ls, int adopt);
+int lm_rem_lockspace_sanlock(struct lockspace *ls, int free_vg);
+int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
+		    uint32_t *r_version, int *retry, int adopt);
+int lm_convert_sanlock(struct lockspace *ls, struct resource *r,
+		       int ld_mode, uint32_t r_version);
+int lm_unlock_sanlock(struct lockspace *ls, struct resource *r,
+		      uint32_t r_version, uint32_t lmu_flags);
+int lm_able_gl_sanlock(struct lockspace *ls, int enable);
+int lm_ex_disable_gl_sanlock(struct lockspace *ls);
+int lm_hosts_sanlock(struct lockspace *ls, int notify);
+int lm_rem_resource_sanlock(struct lockspace *ls, struct resource *r);
+int lm_gl_is_enabled(struct lockspace *ls);
+int lm_get_lockspaces_sanlock(struct list_head *ls_rejoin);
+int lm_data_size_sanlock(void);
+int lm_is_running_sanlock(void);
+int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset);
+
 #define container_of(ptr, type, member) ({                      \
 	const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
 	(type *)( (char *)__mptr - offsetof(type,member) );})
@@ -320,268 +350,22 @@ static inline int list_empty(const struct list_head *head)
 EXTERN int gl_type_static;
 EXTERN int gl_use_dlm;
 EXTERN int gl_use_sanlock;
+EXTERN pthread_mutex_t gl_type_mutex;
+
 EXTERN char gl_lsname_dlm[MAX_NAME+1];
 EXTERN char gl_lsname_sanlock[MAX_NAME+1];
-EXTERN int global_dlm_lockspace_exists;
+
+EXTERN int gl_running_dlm;
+EXTERN int gl_auto_dlm;
 
 EXTERN int daemon_test; /* run as much as possible without a live lock manager */
 EXTERN int daemon_debug;
 EXTERN int daemon_host_id;
 EXTERN const char *daemon_host_id_file;
-EXTERN int sanlock_io_timeout;
-
-/*
- * This flag is set to 1 if we see multiple vgs with the global
- * lock enabled.  While this is set, we return a special flag
- * with the vg lock result indicating to the lvm command that
- * there is a duplicate gl in the vg which should be resolved.
- * While this is set, find_lockspace_name has the side job of
- * counting the number of lockspaces with enabled gl's so that
- * this can be set back to zero when the duplicates are disabled.
- */
-EXTERN int sanlock_gl_dup;
 
 void log_level(int level, const char *fmt, ...)  __attribute__((format(printf, 2, 3)));
 #define log_debug(fmt, args...) log_level(LOG_DEBUG, fmt, ##args)
 #define log_error(fmt, args...) log_level(LOG_ERR, fmt, ##args)
 #define log_warn(fmt, args...) log_level(LOG_WARNING, fmt, ##args)
 
-struct lockspace *alloc_lockspace(void);
-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);
-
-
-#ifdef LOCKDDLM_SUPPORT
-
-int lm_init_vg_dlm(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
-int lm_prepare_lockspace_dlm(struct lockspace *ls);
-int lm_add_lockspace_dlm(struct lockspace *ls, int adopt);
-int lm_rem_lockspace_dlm(struct lockspace *ls, int free_vg);
-int lm_lock_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
-		struct val_blk *vb_out, int adopt);
-int lm_convert_dlm(struct lockspace *ls, struct resource *r,
-		   int ld_mode, uint32_t r_version);
-int lm_unlock_dlm(struct lockspace *ls, struct resource *r,
-		  uint32_t r_version, uint32_t lmu_flags);
-int lm_rem_resource_dlm(struct lockspace *ls, struct resource *r);
-int lm_get_lockspaces_dlm(struct list_head *ls_rejoin);
-int lm_data_size_dlm(void);
-int lm_is_running_dlm(void);
-int lm_hosts_dlm(struct lockspace *ls, int notify);
-
-static inline int lm_support_dlm(void)
-{
-	return 1;
-}
-
-#else
-
-static inline int lm_init_vg_dlm(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
-{
-	return -1;
-}
-
-static inline int lm_prepare_lockspace_dlm(struct lockspace *ls)
-{
-	return -1;
-}
-
-static inline int lm_add_lockspace_dlm(struct lockspace *ls, int adopt)
-{
-	return -1;
-}
-
-static inline int lm_rem_lockspace_dlm(struct lockspace *ls, int free_vg)
-{
-	return -1;
-}
-
-static inline int lm_lock_dlm(struct lockspace *ls, struct resource *r, int ld_mode,
-		struct val_blk *vb_out, int adopt)
-{
-	return -1;
-}
-
-static inline int lm_convert_dlm(struct lockspace *ls, struct resource *r,
-		   int ld_mode, uint32_t r_version)
-{
-	return -1;
-}
-
-static inline int lm_unlock_dlm(struct lockspace *ls, struct resource *r,
-		  uint32_t r_version, uint32_t lmu_flags)
-{
-	return -1;
-}
-
-static inline int lm_rem_resource_dlm(struct lockspace *ls, struct resource *r)
-{
-	return -1;
-}
-
-static inline int lm_get_lockspaces_dlm(struct list_head *ls_rejoin)
-{
-	return -1;
-}
-
-static inline int lm_data_size_dlm(void)
-{
-	return -1;
-}
-
-static inline int lm_is_running_dlm(void)
-{
-	return 0;
-}
-
-static inline int lm_support_dlm(void)
-{
-	return 0;
-}
-
-static inline int lm_hosts_dlm(struct lockspace *ls, int notify)
-{
-	return 0;
-}
-
-#endif /* dlm support */
-
-#ifdef LOCKDSANLOCK_SUPPORT
-
-int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
-int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, uint64_t free_offset);
-int lm_free_lv_sanlock(struct lockspace *ls, struct resource *r);
-int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args);
-int lm_prepare_lockspace_sanlock(struct lockspace *ls);
-int lm_add_lockspace_sanlock(struct lockspace *ls, int adopt);
-int lm_rem_lockspace_sanlock(struct lockspace *ls, int free_vg);
-int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
-		    struct val_blk *vb_out, int *retry, int adopt);
-int lm_convert_sanlock(struct lockspace *ls, struct resource *r,
-		       int ld_mode, uint32_t r_version);
-int lm_unlock_sanlock(struct lockspace *ls, struct resource *r,
-		      uint32_t r_version, uint32_t lmu_flags);
-int lm_able_gl_sanlock(struct lockspace *ls, int enable);
-int lm_ex_disable_gl_sanlock(struct lockspace *ls);
-int lm_hosts_sanlock(struct lockspace *ls, int notify);
-int lm_rem_resource_sanlock(struct lockspace *ls, struct resource *r);
-int lm_gl_is_enabled(struct lockspace *ls);
-int lm_get_lockspaces_sanlock(struct list_head *ls_rejoin);
-int lm_data_size_sanlock(void);
-int lm_is_running_sanlock(void);
-int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset);
-
-static inline int lm_support_sanlock(void)
-{
-	return 1;
-}
-
-#else
-
-static inline int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
-{
-	return -1;
-}
-
-static inline int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name, char *vg_args, char *lv_args, uint64_t free_offset)
-{
-	return -1;
-}
-
-static inline int lm_free_lv_sanlock(struct lockspace *ls, struct resource *r)
-{
-	return -1;
-}
-
-static inline int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_args)
-{
-	return -1;
-}
-
-static inline int lm_prepare_lockspace_sanlock(struct lockspace *ls)
-{
-	return -1;
-}
-
-static inline int lm_add_lockspace_sanlock(struct lockspace *ls, int adopt)
-{
-	return -1;
-}
-
-static inline int lm_rem_lockspace_sanlock(struct lockspace *ls, int free_vg)
-{
-	return -1;
-}
-
-static inline int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
-		    struct val_blk *vb_out, int *retry, int adopt)
-{
-	return -1;
-}
-
-static inline int lm_convert_sanlock(struct lockspace *ls, struct resource *r,
-		       int ld_mode, uint32_t r_version)
-{
-	return -1;
-}
-
-static inline int lm_unlock_sanlock(struct lockspace *ls, struct resource *r,
-		      uint32_t r_version, uint32_t lmu_flags)
-{
-	return -1;
-}
-
-static inline int lm_able_gl_sanlock(struct lockspace *ls, int enable)
-{
-	return -1;
-}
-
-static inline int lm_ex_disable_gl_sanlock(struct lockspace *ls)
-{
-	return -1;
-}
-
-static inline int lm_hosts_sanlock(struct lockspace *ls, int notify)
-{
-	return -1;
-}
-
-static inline int lm_rem_resource_sanlock(struct lockspace *ls, struct resource *r)
-{
-	return -1;
-}
-
-static inline int lm_gl_is_enabled(struct lockspace *ls)
-{
-	return -1;
-}
-
-static inline int lm_get_lockspaces_sanlock(struct list_head *ls_rejoin)
-{
-	return -1;
-}
-
-static inline int lm_data_size_sanlock(void)
-{
-	return -1;
-}
-
-static inline int lm_is_running_sanlock(void)
-{
-	return 0;
-}
-
-static inline int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
-{
-	return -1;
-}
-
-static inline int lm_support_sanlock(void)
-{
-	return 0;
-}
-
-#endif /* sanlock support */
-
-#endif	/* _LVM_LVMLOCKD_INTERNAL_H */
+#endif

daemons/lvmlockd/lvmlockd-sanlock.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2015 Red Hat, Inc.
+ * Copyright (C) 2014 Red Hat, Inc.
  *
  * This file is part of LVM2.
  *
@@ -10,9 +10,23 @@
 
 #define _XOPEN_SOURCE 500  /* pthread */
 #define _ISOC99_SOURCE
+#define _GNU_SOURCE
 
-#include "tool.h"
+#include <assert.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <poll.h>
+#include <errno.h>
+#include <string.h>
+#include <syslog.h>
+#include <sys/types.h>
+#include <sys/socket.h>
 
+#include "configure.h"
 #include "daemon-server.h"
 #include "daemon-log.h"
 #include "xlate.h"
@@ -25,109 +39,53 @@
 #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>
-
 /*
--------------------------------------------------------------------------------
-For each VG, lvmlockd creates a sanlock lockspace that holds the leases for
-that VG.  There's a lease for the VG lock, and there's a lease for each active
-LV.  sanlock maintains (reads/writes) these leases, which exist on storage.
-That storage is a hidden LV within the VG: /dev/vg/lvmlock.  lvmlockd gives the
-path of this internal LV to sanlock, which then reads/writes the leases on it.
-
-# lvs -a cc -o+uuid
-  LV        VG   Attr       LSize   LV UUID
-  lv1       cc   -wi-a-----   2.00g 7xoDtu-yvNM-iwQx-C94t-BbYs-UzBl-o8hAIa
-  lv2       cc   -wi-a----- 100.00g exxNPX-wZdO-uCNy-yiGa-aJGT-JKVl-arfcYT
-  [lvmlock] cc   -wi-ao---- 256.00m iLpDel-hR0T-hJ3u-rnVo-PcDh-mcjt-sF9egM
-
-# sanlock status
-s lvm_cc:1:/dev/mapper/cc-lvmlock:0
-r lvm_cc:exxNPX-wZdO-uCNy-yiGa-aJGT-JKVl-arfcYT:/dev/mapper/cc-lvmlock:71303168:13 p 26099
-r lvm_cc:7xoDtu-yvNM-iwQx-C94t-BbYs-UzBl-o8hAIa:/dev/mapper/cc-lvmlock:70254592:3 p 26099
-
-This shows that sanlock is maintaining leases on /dev/mapper/cc-lvmlock.
-
-sanlock acquires a lockspace lease when the lockspace is joined, i.e. when the
-VG is started by 'vgchange --lock-start cc'.  This lockspace lease exists at
-/dev/mapper/cc-lvmlock offset 0, and sanlock regularly writes to it to maintain
-ownership of it.  Joining the lockspace (by acquiring the lockspace lease in
-it) then allows standard resource leases to be acquired in the lockspace for
-whatever the application wants.  lvmlockd uses resource leases for the VG lock
-and LV locks.
-
-sanlock acquires a resource lease for each actual lock that lvm commands use.
-Above, there are two LV locks that are held because the two LVs are active.
-These are on /dev/mapper/cc-lvmlock at offsets 71303168 and 70254592.  sanlock
-does not write to these resource leases except when acquiring and releasing
-them (e.g. lvchange -ay/-an).  The renewal of the lockspace lease maintains
-ownership of all the resource leases in the lockspace.
-
-If the host loses access to the disk that the sanlock lv lives on, then sanlock
-can no longer renew its lockspace lease.  The lockspace lease will eventually
-expire, at which point the host will lose ownership of it, and of all resource
-leases it holds in the lockspace.  Eventually, other hosts will be able to
-acquire those leases.  sanlock ensures that another host will not be able to
-acquire one of the expired leases until the current host has quit using it.
-
-It is important that the host "quit using" the leases it is holding if the
-sanlock storage is lost and they begin expiring.  If the host cannot quit using
-the leases and release them within a limited time, then sanlock will use the
-local watchdog to forcibly reset the host before any other host can acquire
-them.  This is severe, but preferable to possibly corrupting the data protected
-by the lease.  It ensures that two nodes will not be using the same lease at
-once.  For LV leases, that means that another host will not be able to activate
-the LV while another host still has it active.
-
-sanlock notifies the application that it cannot renew the lockspace lease.  The
-application needs to quit using all leases in the lockspace and release them as
-quickly as possible.  In the initial version, lvmlockd ignored this
-notification, so sanlock would eventually reach the point where it would use
-the local watchdog to reset the host.  However, it's better to attempt a
-response.  If that response succeeds, the host can avoid being reset.  If the
-response fails, then sanlock will eventually reset the host as the last resort.
-sanlock gives the application about 40 seconds to complete its response and
-release its leases before resetting the host.
-
-An application can specify the path and args of a program that sanlock should
-run to notify it if the lockspace lease cannot be renewed.  This program should
-carry out the application's response to the expiring leases: attempt to quit
-using the leases and then release them.  lvmlockd gives this command to sanlock
-for each VG when that VG is started: 'lvmlockctl --kill vg_name'
-
-If sanlock loses access to lease storage in that VG, it runs lvmlockctl --kill,
-which:
-
-1. Uses syslog to explain what is happening.
-
-2. Notifies lvmlockd that the VG is being killed, so lvmlockd can
-   immediatley return an error for this condition if any new lock
-   requests are made.  (This step would not be strictly necessary.)
-
-3. Attempts to quit using the VG.  This is not yet implemented, but
-   will eventually use blkdeactivate on the VG (or a more forceful
-   equivalent.)
-
-4. If step 3 was successful at terminating all use of the VG, then
-   lvmlockd is told to release all the leases for the VG.  If this
-   is all done without about 40 seconds, the host can avoid being
-   reset.
-
-Until steps 3 and 4 are fully implemented, manual steps can be substituted.
-This is primarily for testing since the problem needs to be noticed and
-responded to in a very short time.  The manual alternative to step 3 is to kill
-any processes using file systems on LV's in the VG, unmount all file systems on
-the LVs, and deactivate all the LVs.  Once this is done, the manual alternative
-to step 4 is to run 'lvmlockctl --drop vg_name', which tells lvmlockd to
-release all the leases for the VG.
--------------------------------------------------------------------------------
-*/
-
+ * If access to the pv containing the vg's leases is lost, sanlock cannot renew
+ * the leases we have acquired for locked LVs.  This means that we could soon
+ * loose the lease to another host which could activate our LV exclusively.  We
+ * do not want to get to the point of two hosts having the same LV active
+ * exclusively (it obviously violates the purpose of LV locks.)
+ *
+ * The default method of preventing this problem is for lvmlockd to do nothing,
+ * which produces a safe but potentially inconvenient result.  Doing nothing
+ * leads to our LV leases not being released, which leads to sanlock using the
+ * local watchdog to reset us before another host can acquire our lock.  It
+ * would often be preferrable to avoid the abrupt hard reset from the watchdog.
+ *
+ * There are other options to avoid being reset by our watchdog.  If we can
+ * quickly stop using the LVs in question and release the locks for them, then
+ * we could avoid a reset (there's a certain grace period of about 40 seconds
+ * in which we can attempt this.)  To do this, we can tell sanlock to run a
+ * specific program when it has lost access to our leases.  We could use this
+ * program to:
+ *
+ * 1. Deactivate all lvs in the effected vg.  If all the leases are
+ * deactivated, then our LV locks would be released and sanlock would no longer
+ * use the watchdog to reset us.  If file systems are mounted on the active
+ * lvs, then deactivating them would fail, so this option would be of limited
+ * usefulness.
+ *
+ * 2. Option 1 could be extended to kill pids using the fs on the lv, unmount
+ * the fs, and deactivate the lv.  This is probably out of scope for lvm
+ * directly, and would likely need the help of another system service.
+ *
+ * 3. Use dmsetup suspend to block access to lvs in the effected vg.  If this
+ * was successful, the local host could no longer write to the lvs, we could
+ * safely release the LV locks, and sanlock would no longer reset us.  At this
+ * point, with suspended lvs, the host would be in a fairly hobbled state, and
+ * would almost certainly need a manual, forcible reset.
+ *
+ * 4. Option 3 could be extended to monitor the lost storage, and if it is
+ * reconnected, the leases could be reacquired, and the suspended lvs resumed
+ * (reacquiring leases will fail if another host has acquired them since they
+ * were released.)  This complexity of this option, combined with the fact that
+ * the error conditions are often not as simple as storage being lost and then
+ * later connecting, will result in this option being too unreliable.
+ *
+ * Add a config option that we could use to select a different behavior than
+ * the default.  Then implement one of the simpler options as a proof of
+ * concept, which could be extended if needed.
+ */
 
 /*
  * Each lockspace thread has its own sanlock daemon connection.
@@ -216,7 +174,7 @@ static int lock_lv_name_from_args(char *vg_args, char *lock_lv_name)
 
 static int lock_lv_offset_from_args(char *lv_args, uint64_t *lock_lv_offset)
 {
-	char offset_str[MAX_ARGS+1];
+	char offset_str[MAX_ARGS];
 	int rv;
 
 	memset(offset_str, 0, sizeof(offset_str));
@@ -285,8 +243,7 @@ static int read_host_id_file(void)
 			break;
 		}
 	}
-	if (fclose(file))
-		log_error("failed to close host id file %s", daemon_host_id_file);
+	fclose(file);
 out:
 	log_debug("host_id %d from %s", host_id, daemon_host_id_file);
 	return host_id;
@@ -305,8 +262,8 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	struct sanlk_lockspace ss;
 	struct sanlk_resourced rd;
 	struct sanlk_disk disk;
-	char lock_lv_name[MAX_ARGS+1];
-	char lock_args_version[MAX_ARGS+1];
+	char lock_lv_name[MAX_ARGS];
+	char lock_args_version[MAX_ARGS];
 	const char *gl_name = NULL;
 	uint32_t daemon_version;
 	uint32_t daemon_proto;
@@ -334,7 +291,7 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	if (strlen(lock_lv_name) + strlen(lock_args_version) + 2 > MAX_ARGS)
 		return -EARGS;
 
-	snprintf(disk.path, SANLK_PATH_LEN-1, "/dev/mapper/%s-%s", vg_name, lock_lv_name);
+	snprintf(disk.path, SANLK_PATH_LEN, "/dev/mapper/%s-%s", vg_name, lock_lv_name);
 
 	log_debug("S %s init_vg_san path %s", ls_name, disk.path);
 
@@ -364,7 +321,7 @@ int lm_init_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_ar
 	memcpy(ss.host_id_disk.path, disk.path, SANLK_PATH_LEN);
 	ss.host_id_disk.offset = LS_BEGIN * align_size;
 
-	rv = sanlock_write_lockspace(&ss, 0, 0, sanlock_io_timeout);
+	rv = sanlock_write_lockspace(&ss, 0, 0, 0);
 	if (rv < 0) {
 		log_error("S %s init_vg_san write_lockspace error %d %s",
 			  ls_name, rv, ss.host_id_disk.path);
@@ -472,8 +429,8 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 		       char *vg_args, char *lv_args, uint64_t free_offset)
 {
 	struct sanlk_resourced rd;
-	char lock_lv_name[MAX_ARGS+1];
-	char lock_args_version[MAX_ARGS+1];
+	char lock_lv_name[MAX_ARGS];
+	char lock_args_version[MAX_ARGS];
 	uint64_t offset;
 	int align_size;
 	int rv;
@@ -494,7 +451,7 @@ int lm_init_lv_sanlock(char *ls_name, char *vg_name, char *lv_name,
 
 	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);
+	snprintf(rd.rs.disks[0].path, SANLK_PATH_LEN, "/dev/mapper/%s-%s", vg_name, lock_lv_name);
 
 	align_size = sanlock_align(&rd.rs.disks[0]);
 	if (align_size <= 0) {
@@ -578,7 +535,7 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 	struct sanlk_lockspace ss;
 	struct sanlk_resourced rd;
 	struct sanlk_disk disk;
-	char lock_lv_name[MAX_ARGS+1];
+	char lock_lv_name[MAX_ARGS];
 	uint64_t offset;
 	uint32_t io_timeout;
 	int align_size;
@@ -599,7 +556,7 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 		return rv;
 	}
 
-	snprintf(disk.path, SANLK_PATH_LEN-1, "/dev/mapper/%s-%s", vg_name, lock_lv_name);
+	snprintf(disk.path, SANLK_PATH_LEN, "/dev/mapper/%s-%s", vg_name, lock_lv_name);
 
 	log_debug("S %s rename_vg_san path %s", ls_name, disk.path);
 
@@ -633,7 +590,7 @@ int lm_rename_vg_sanlock(char *ls_name, char *vg_name, uint32_t flags, char *vg_
 
 	strncpy(ss.name, ls_name, SANLK_NAME_LEN);
 
-	rv = sanlock_write_lockspace(&ss, 0, 0, sanlock_io_timeout);
+	rv = sanlock_write_lockspace(&ss, 0, 0, 0);
 	if (rv < 0) {
 		log_error("S %s rename_vg_san write_lockspace error %d %s",
 			  ls_name, rv, ss.host_id_disk.path);
@@ -779,7 +736,7 @@ int lm_ex_disable_gl_sanlock(struct lockspace *ls)
 	strncpy(rd2.rs.name, R_NAME_GL_DISABLED, SANLK_NAME_LEN);
 
 	rd1.rs.num_disks = 1;
-	strncpy(rd1.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
+	strncpy(rd1.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN);
 	rd1.rs.disks[0].offset = lms->align_size * GL_LOCK_BEGIN;
 
 	rv = sanlock_acquire(lms->sock, -1, 0, 1, &rs1, NULL);
@@ -837,7 +794,7 @@ int lm_able_gl_sanlock(struct lockspace *ls, int enable)
 	strncpy(rd.rs.name, gl_name, SANLK_NAME_LEN);
 
 	rd.rs.num_disks = 1;
-	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
+	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN);
 	rd.rs.disks[0].offset = lms->align_size * GL_LOCK_BEGIN;
 
 	rv = sanlock_write_resource(&rd.rs, 0, 0, 0);
@@ -850,6 +807,8 @@ int lm_able_gl_sanlock(struct lockspace *ls, int enable)
 	log_debug("S %s able_gl %s", ls->name, gl_name);
 
 	ls->sanlock_gl_enabled = enable;
+	if (ls->sanlock_gl_dup && !enable)
+		ls->sanlock_gl_dup = 0;
 
 	if (enable)
 		strncpy(gl_lsname_sanlock, ls->name, MAX_NAME);
@@ -874,7 +833,7 @@ static int gl_is_enabled(struct lockspace *ls, struct lm_sanlock *lms)
 	/* leave rs.name empty, it is what we're checking */
 
 	rd.rs.num_disks = 1;
-	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
+	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN);
 
 	offset = lms->align_size * GL_LOCK_BEGIN;
 	rd.rs.disks[0].offset = offset;
@@ -932,7 +891,7 @@ int lm_find_free_lock_sanlock(struct lockspace *ls, uint64_t *free_offset)
 
 	strncpy(rd.rs.lockspace_name, ls->name, SANLK_NAME_LEN);
 	rd.rs.num_disks = 1;
-	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN-1);
+	strncpy(rd.rs.disks[0].path, lms->ss.host_id_disk.path, SANLK_PATH_LEN);
 
 	offset = lms->align_size * LV_LOCK_BEGIN;
 
@@ -1007,27 +966,15 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 {
 	struct stat st;
 	struct lm_sanlock *lms = NULL;
-	char lock_lv_name[MAX_ARGS+1];
+	char lock_lv_name[MAX_ARGS];
 	char lsname[SANLK_NAME_LEN + 1];
 	char disk_path[SANLK_PATH_LEN];
-	char killpath[SANLK_PATH_LEN];
-	char killargs[SANLK_PATH_LEN];
 	int gl_found;
 	int ret, rv;
 
 	memset(disk_path, 0, sizeof(disk_path));
 	memset(lock_lv_name, 0, sizeof(lock_lv_name));
 
-	/*
-	 * Construct the path to lvmlockctl by using the path to the lvm binary
-	 * and appending "lockctl" to get /path/to/lvmlockctl.
-	 */
-	memset(killpath, 0, sizeof(killpath));
-	snprintf(killpath, SANLK_PATH_LEN - 1, "%slockctl", LVM_PATH);
-
-	memset(killargs, 0, sizeof(killargs));
-	snprintf(killargs, SANLK_PATH_LEN - 1, "--kill %s", ls->vg_name);
-
 	rv = check_args_version(ls->vg_args, VG_LOCK_ARGS_MAJOR);
 	if (rv < 0) {
 		ret = -EARGS;
@@ -1042,7 +989,7 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 		goto fail;
 	}
 
-	snprintf(disk_path, SANLK_PATH_LEN-1, "/dev/mapper/%s-%s",
+	snprintf(disk_path, SANLK_PATH_LEN, "/dev/mapper/%s-%s",
 		 ls->vg_name, lock_lv_name);
 
 	/*
@@ -1094,7 +1041,7 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 	memcpy(lms->ss.name, lsname, SANLK_NAME_LEN);
 	lms->ss.host_id_disk.offset = 0;
 	lms->ss.host_id = ls->host_id;
-	strncpy(lms->ss.host_id_disk.path, disk_path, SANLK_PATH_LEN-1);
+	strncpy(lms->ss.host_id_disk.path, disk_path, SANLK_PATH_LEN);
 
 	if (daemon_test) {
 		if (!gl_lsname_sanlock[0]) {
@@ -1112,15 +1059,6 @@ int lm_prepare_lockspace_sanlock(struct lockspace *ls)
 		goto fail;
 	}
 
-	log_debug("set killpath to %s %s", killpath, killargs);
-
-	rv = sanlock_killpath(lms->sock, 0, killpath, killargs);
-	if (rv < 0) {
-		log_error("S %s killpath error %d", lsname, rv);
-		ret = -EMANAGER;
-		goto fail;
-	}
-
 	rv = sanlock_restrict(lms->sock, SANLK_RESTRICT_SIGKILL);
 	if (rv < 0) {
 		log_error("S %s restrict error %d", lsname, rv);
@@ -1175,7 +1113,7 @@ int lm_add_lockspace_sanlock(struct lockspace *ls, int adopt)
 	struct lm_sanlock *lms = (struct lm_sanlock *)ls->lm_data;
 	int rv;
 
-	rv = sanlock_add_lockspace_timeout(&lms->ss, 0, sanlock_io_timeout);
+	rv = sanlock_add_lockspace(&lms->ss, 0);
 	if (rv == -EEXIST && adopt) {
 		/* We could alternatively just skip the sanlock call for adopt. */
 		log_debug("S %s add_lockspace_san adopt found ls", ls->name);
@@ -1207,8 +1145,7 @@ out:
 	return 0;
 
 fail:
-	if (close(lms->sock))
-		log_error("failed to close sanlock daemon socket connection");
+	close(lms->sock);
 	free(lms);
 	ls->lm_data = NULL;
 	return rv;
@@ -1237,15 +1174,14 @@ int lm_rem_lockspace_sanlock(struct lockspace *ls, int free_vg)
 		 */
 		strncpy(lms->ss.name, "#unused", SANLK_NAME_LEN);
 
-		rv = sanlock_write_lockspace(&lms->ss, 0, 0, sanlock_io_timeout);
+		rv = sanlock_write_lockspace(&lms->ss, 0, 0, 0);
 		if (rv < 0) {
 			log_error("S %s rem_lockspace free_vg write_lockspace error %d %s",
 				  ls->name, rv, lms->ss.host_id_disk.path);
 		}
 	}
 out:
-	if (close(lms->sock))
-		log_error("failed to close sanlock daemon socket connection");
+	close(lms->sock);
 
 	free(lms);
 	ls->lm_data = NULL;
@@ -1300,7 +1236,7 @@ int lm_rem_resource_sanlock(struct lockspace *ls, struct resource *r)
 }
 
 int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
-		    struct val_blk *vb_out, int *retry, int adopt)
+		    uint32_t *r_version, int *retry, int adopt)
 {
 	struct lm_sanlock *lms = (struct lm_sanlock *)ls->lm_data;
 	struct rd_sanlock *rds = (struct rd_sanlock *)r->lm_data;
@@ -1308,6 +1244,7 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 	uint64_t lock_lv_offset;
 	uint32_t flags = 0;
 	struct val_blk vb;
+	uint16_t vb_version;
 	int added = 0;
 	int rv;
 
@@ -1321,14 +1258,6 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 
 	rs = &rds->rs;
 
-	/*
-	 * While there are duplicate global locks, keep checking
-	 * to see if any have been disabled.
-	 */
-	if (sanlock_gl_dup && ls->sanlock_gl_enabled &&
-	    (r->type == LD_RT_GL || r->type == LD_RT_VG))
-		ls->sanlock_gl_enabled = gl_is_enabled(ls, ls->lm_data);
-
 	if (r->type == LD_RT_LV) {
 		/*
 		 * The lv may have been removed and recreated with a new lease
@@ -1383,7 +1312,7 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 		  (unsigned long long)rs->disks[0].offset);
 
 	if (daemon_test) {
-		memset(vb_out, 0, sizeof(struct val_blk));
+		*r_version = 0;
 		return 0;
 	}
 
@@ -1392,15 +1321,6 @@ 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);
 
 	if (rv == -EAGAIN) {
@@ -1471,30 +1391,15 @@ 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
-		 * expire.  If we retry we'll eventually acquire the lock
-		 * (or find someone else has acquired it).  The EAGAIN retry
-		 * attempts for SH locks above would not be sufficient for
-		 * the length of expiration time.  We could add a longer
-		 * retry time here to cover the full expiration time and block
-		 * the activation command for that long.  For now just return
-		 * the standard error indicating that another host still owns
-		 * the lease.  FIXME: return a different error number so the
-		 * command can print an different error indicating that the
-		 * owner of the lease is in the process of expiring?
-		 */
-		log_debug("S %s R %s lock_san acquire mode %d rv %d", ls->name, r->name, ld_mode, rv);
-		*retry = 0;
-		return -EAGAIN;
-	}
-#endif
 	if (rv < 0) {
 		log_error("S %s R %s lock_san acquire error %d",
 			  ls->name, r->name, rv);
 
+		if (added) {
+			lm_rem_resource_sanlock(ls, r);
+			return rv;
+		}
+
 		/* if the gl has been disabled, remove and free the gl resource */
 		if ((rv == SANLK_LEADER_RESOURCE) && (r->type == LD_RT_GL)) {
 			if (!lm_gl_is_enabled(ls)) {
@@ -1506,22 +1411,6 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 			}
 		}
 
-		if (added)
-			lm_rem_resource_sanlock(ls, r);
-
-		/* sanlock gets i/o errors trying to read/write the leases. */
-		if (rv == -EIO)
-			rv = -ELOCKIO;
-
-		/*
-		 * The sanlock lockspace can disappear if the lease storage fails,
-		 * the delta lease renewals fail, the lockspace enters recovery,
-		 * lvmlockd holds no leases in the lockspace, so sanlock can
-		 * stop and free the lockspace.
-		 */
-		if (rv == -ENOSPC)
-			rv = -ELOCKIO;
-
 		return rv;
 	}
 
@@ -1529,23 +1418,26 @@ int lm_lock_sanlock(struct lockspace *ls, struct resource *r, int ld_mode,
 		rv = sanlock_get_lvb(0, rs, (char *)&vb, sizeof(vb));
 		if (rv < 0) {
 			log_error("S %s R %s lock_san get_lvb error %d", ls->name, r->name, rv);
-			memset(rds->vb, 0, sizeof(struct val_blk));
-			memset(vb_out, 0, sizeof(struct val_blk));
+			*r_version = 0;
 			goto out;
 		}
 
-		/*
-		 * 'vb' contains disk endian values, not host endian.
-		 * It is copied directly to rrs->vb which is also kept
-		 * in disk endian form.
-		 * vb_out is returned to the caller in host endian form.
-		 */
+		vb_version = le16_to_cpu(vb.version);
 
-		memcpy(rds->vb, &vb, sizeof(vb));
+		if (vb_version && ((vb_version & 0xFF00) > (VAL_BLK_VERSION & 0xFF00))) {
+			log_error("S %s R %s lock_san ignore vb_version %x",
+				  ls->name, r->name, vb_version);
+			*r_version = 0;
+			free(rds->vb);
+			rds->vb = NULL;
+			goto out;
+		}
 
-		vb_out->version = le16_to_cpu(vb.version);
-		vb_out->flags = le16_to_cpu(vb.flags);
-		vb_out->r_version = le32_to_cpu(vb.r_version);
+		*r_version = le32_to_cpu(vb.r_version);
+		memcpy(rds->vb, &vb, sizeof(vb)); /* rds->vb saved as le */
+
+		log_debug("S %s R %s lock_san get r_version %u",
+			  ls->name, r->name, *r_version);
 	}
 out:
 	return rv;
@@ -1700,11 +1592,9 @@ int lm_unlock_sanlock(struct lockspace *ls, struct resource *r,
 	}
 
 	rv = sanlock_release(lms->sock, -1, 0, 1, &rs);
-	if (rv < 0)
+	if (rv < 0) {
 		log_error("S %s R %s unlock_san release error %d", ls->name, r->name, rv);
-
-	if (rv == -EIO)
-		rv = -ELOCKIO;
+	}
 
 	return rv;
 }
@@ -1823,3 +1713,4 @@ int lm_is_running_sanlock(void)
 		return 0;
 	return 1;
 }
+

daemons/lvmpolld/.gitignore

@@ -1 +0,0 @@
-lvmpolld

daemons/lvmpolld/lvmpolld-common.h

@@ -18,14 +18,19 @@
 #ifndef _LVM_LVMPOLLD_COMMON_H
 #define _LVM_LVMPOLLD_COMMON_H
 
-#define _REENTRANT
+#include "configure.h"
 
-#include "tool.h"
+#define _REENTRANT
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include "libdevmapper.h"
 
 #include "lvmpolld-cmd-utils.h"
 #include "lvmpolld-protocol.h"
 
 #include <assert.h>
 #include <errno.h>
+#include <unistd.h>
 
 #endif	/* _LVM_LVMPOLLD_COMMON_H */

daemons/lvmpolld/lvmpolld-core.c

@@ -83,12 +83,6 @@ static int _init(struct daemon_state *s)
 	struct lvmpolld_state *ls = s->private;
 	ls->log = s->log;
 
-	/*
-	 * log warnings to stderr by default. Otherwise we would miss any lvpoll
-	 * error messages in default configuration
-	 */
-	daemon_log_enable(ls->log, DAEMON_LOG_OUTLET_STDERR, DAEMON_LOG_WARN,  1);
-
 	if (!daemon_log_parse(ls->log, DAEMON_LOG_OUTLET_STDERR, ls->log_config, 1))
 		return 0;
 
@@ -290,7 +284,7 @@ static int poll_for_output(struct lvmpolld_lv *pdlv, struct lvmpolld_thread_data
 				 "caught input data in STDERR");
 
 			assert(read_single_line(data, 1)); /* may block indef. anyway */
-			WARN(pdlv->ls, "%s: PID %d: %s: '%s'", LVM2_LOG_PREFIX,
+			INFO(pdlv->ls, "%s: PID %d: %s: '%s'", LVM2_LOG_PREFIX,
 			     pdlv->cmd_pid, "STDERR", data->line);
 		} else if (fds[1].revents) {
 			if (fds[1].revents & POLLHUP)
@@ -333,19 +327,15 @@ static int poll_for_output(struct lvmpolld_lv *pdlv, struct lvmpolld_thread_data
 	if (fds[1].fd >= 0)
 		while (read_single_line(data, 1)) {
 			assert(r > 0);
-			WARN(pdlv->ls, "%s: PID %d: %s: %s", LVM2_LOG_PREFIX, pdlv->cmd_pid, "STDERR", data->line);
+			INFO(pdlv->ls, "%s: PID %d: %s: %s", LVM2_LOG_PREFIX, pdlv->cmd_pid, "STDERR", data->line);
 		}
 
 	if (WIFEXITED(ch_stat)) {
+		INFO(pdlv->ls, "%s: %s (PID %d) %s (%d)", PD_LOG_PREFIX,
+		     "lvm2 cmd", pdlv->cmd_pid, "exited with", WEXITSTATUS(ch_stat));
 		cmd_state.retcode = WEXITSTATUS(ch_stat);
-		if (cmd_state.retcode)
-			ERROR(pdlv->ls, "%s: %s (PID %d) %s (retcode: %d)", PD_LOG_PREFIX,
-			     "lvm2 cmd", pdlv->cmd_pid, "failed", cmd_state.retcode);
-		else
-			INFO(pdlv->ls, "%s: %s (PID %d) %s", PD_LOG_PREFIX,
-			     "lvm2 cmd", pdlv->cmd_pid, "finished successfully");
 	} else if (WIFSIGNALED(ch_stat)) {
-		ERROR(pdlv->ls, "%s: %s (PID %d) %s (%d)", PD_LOG_PREFIX,
+		WARN(pdlv->ls, "%s: %s (PID %d) %s (%d)", PD_LOG_PREFIX,
 		     "lvm2 cmd", pdlv->cmd_pid, "got terminated by signal",
 		     WTERMSIG(ch_stat));
 		cmd_state.signal = WTERMSIG(ch_stat);
@@ -539,7 +529,7 @@ static response progress_info(client_handle h, struct lvmpolld_state *ls, reques
 		if (st.polling_finished)
 			r = daemon_reply_simple(LVMPD_RESP_FINISHED,
 						"reason = %s", st.cmd_state.signal ? LVMPD_REAS_SIGNAL : LVMPD_REAS_RETCODE,
-						LVMPD_PARM_VALUE " = %d", (int64_t)(st.cmd_state.signal ?: st.cmd_state.retcode),
+						LVMPD_PARM_VALUE " = %d", st.cmd_state.signal ?: st.cmd_state.retcode,
 						NULL);
 		else
 			r = daemon_reply_simple(LVMPD_RESP_IN_PROGRESS, NULL);
@@ -576,8 +566,6 @@ static struct lvmpolld_lv *construct_pdlv(request req, struct lvmpolld_state *ls
 		return NULL;
 	}
 
-	pdlv->cmdargv = cmdargv;
-
 	cmdenvp = cmdenvp_ctr(pdlv);
 	if (!cmdenvp) {
 		pdlv_destroy(pdlv);
@@ -585,6 +573,7 @@ static struct lvmpolld_lv *construct_pdlv(request req, struct lvmpolld_state *ls
 		return NULL;
 	}
 
+	pdlv->cmdargv = cmdargv;
 	pdlv->cmdenvp = cmdenvp;
 
 	return pdlv;
@@ -595,16 +584,12 @@ static int spawn_detached_thread(struct lvmpolld_lv *pdlv)
 	int r;
 	pthread_attr_t attr;
 
-	if (pthread_attr_init(&attr) != 0)
-		return 0;
-
-	if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
-		return 0;
+	pthread_attr_init(&attr);
+	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
 	r = pthread_create(&pdlv->tid, &attr, fork_and_poll, (void *)pdlv);
 
-	if (pthread_attr_destroy(&attr) != 0)
-		return 0;
+	pthread_attr_destroy(&attr);
 
 	return !r;
 }

daemons/lvmpolld/lvmpolld-data-utils.c

@@ -325,7 +325,6 @@ struct lvmpolld_thread_data *lvmpolld_thread_data_constructor(struct lvmpolld_lv
 
 	data->pdlv = NULL;
 	data->line = NULL;
-	data->line_size = 0;
 	data->fout = data->ferr = NULL;
 	data->outpipe[0] = data->outpipe[1] = data->errpipe[0] = data->errpipe[1] = -1;
 
@@ -366,8 +365,7 @@ void lvmpolld_thread_data_destroy(void *thread_private)
 		pdst_unlock(data->pdlv->pdst);
 	}
 
-	/* may get reallocated in getline(). dm_free must not be used */
-	free(data->line);
+	dm_free(data->line);
 
 	if (data->fout && !fclose(data->fout))
 		data->outpipe[0] = -1;
@@ -376,16 +374,16 @@ void lvmpolld_thread_data_destroy(void *thread_private)
 		data->errpipe[0] = -1;
 
 	if (data->outpipe[0] >= 0)
-		(void) close(data->outpipe[0]);
+		close(data->outpipe[0]);
 
 	if (data->outpipe[1] >= 0)
-		(void) close(data->outpipe[1]);
+		close(data->outpipe[1]);
 
 	if (data->errpipe[0] >= 0)
-		(void) close(data->errpipe[0]);
+		close(data->errpipe[0]);
 
 	if (data->errpipe[1] >= 0)
-		(void) close(data->errpipe[1]);
+		close(data->errpipe[1]);
 
 	dm_free(data);
 }

include/.symlinks.in

@@ -45,6 +45,7 @@
 @top_srcdir@/lib/metadata/vg.h
 @top_srcdir@/lib/mm/memlock.h
 @top_srcdir@/lib/mm/xlate.h
+@top_builddir@/lib/misc/configure.h
 @top_srcdir@/lib/misc/crc.h
 @top_srcdir@/lib/misc/intl.h
 @top_srcdir@/lib/misc/last-path-component.h
@@ -55,6 +56,7 @@
 @top_srcdir@/lib/misc/lvm-globals.h
 @top_srcdir@/lib/misc/lvm-signal.h
 @top_srcdir@/lib/misc/lvm-string.h
+@top_builddir@/lib/misc/lvm-version.h
 @top_srcdir@/lib/misc/lvm-percent.h
 @top_srcdir@/lib/misc/lvm-wrappers.h
 @top_srcdir@/lib/misc/sharedlib.h
@@ -74,4 +76,3 @@
 @top_srcdir@/libdm/misc/kdev_t.h
 @top_srcdir@/po/pogen.h
 @top_srcdir@/tools/lvm2cmd.h
-@top_srcdir@/tools/tool.h

include/Makefile.in

@@ -1,6 +1,6 @@
 #
 # Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
-# Copyright (C) 2004-2015 Red Hat, Inc. All rights reserved.
+# Copyright (C) 2004-2010 Red Hat, Inc. All rights reserved.
 #
 # This file is part of LVM2.
 #
@@ -35,5 +35,5 @@ device-mapper: all
 
 cflow: all
 
-DISTCLEAN_TARGETS += .symlinks configure.h lvm-version.h
+DISTCLEAN_TARGETS += .symlinks
 CLEAN_TARGETS += $(LINKS) .include_symlinks .symlinks_created

lib/Makefile.in

@@ -62,7 +62,6 @@ SOURCES =\
 	device/dev-swap.c \
 	device/dev-type.c \
 	device/dev-luks.c \
-	device/dev-dasd.c \
 	display/display.c \
 	error/errseg.c \
 	unknown/unknown.c \
@@ -83,6 +82,7 @@ SOURCES =\
 	format_text/format-text.c \
 	format_text/import.c \
 	format_text/import_vsn1.c \
+	format_text/tags.c \
 	format_text/text_label.c \
 	freeseg/freeseg.c \
 	label/label.c \
@@ -123,6 +123,11 @@ SOURCES =\
 	uuid/uuid.c \
 	zero/zero.c
 
+ifeq ("@HAVE_REALTIME@", "yes")
+  SOURCES +=\
+	misc/timestamp.c
+endif
+
 ifeq ("@LVM1@", "internal")
   SOURCES +=\
 	format1/disk-rep.c \
@@ -231,4 +236,4 @@ CFLAGS += $(BLKID_CFLAGS) $(UDEV_CFLAGS) $(VALGRIND_CFLAGS)
 
 $(SUBDIRS): $(LIB_STATIC)
 
-CLEAN_TARGETS += misc/configure.h misc/lvm-version.h
+DISTCLEAN_TARGETS += misc/configure.h misc/lvm-version.h

lib/activate/activate.c

@@ -180,7 +180,7 @@ int lv_passes_auto_activation_filter(struct cmd_context *cmd, struct logical_vol
 {
 	const struct dm_config_node *cn;
 
-	if (!(cn = find_config_tree_array(cmd, activation_auto_activation_volume_list_CFG, NULL))) {
+	if (!(cn = find_config_tree_node(cmd, activation_auto_activation_volume_list_CFG, NULL))) {
 		log_verbose("activation/auto_activation_volume_list configuration setting "
 			    "not defined: All logical volumes will be auto-activated.");
 		return 1;
@@ -467,7 +467,7 @@ static int _passes_activation_filter(struct cmd_context *cmd,
 {
 	const struct dm_config_node *cn;
 
-	if (!(cn = find_config_tree_array(cmd, activation_volume_list_CFG, NULL))) {
+	if (!(cn = find_config_tree_node(cmd, activation_volume_list_CFG, NULL))) {
 		log_verbose("activation/volume_list configuration setting "
 			    "not defined: Checking only host tags for %s/%s",
 			    lv->vg->name, lv->name);
@@ -496,7 +496,7 @@ static int _passes_readonly_filter(struct cmd_context *cmd,
 {
 	const struct dm_config_node *cn;
 
-	if (!(cn = find_config_tree_array(cmd, activation_read_only_volume_list_CFG, NULL)))
+	if (!(cn = find_config_tree_node(cmd, activation_read_only_volume_list_CFG, NULL)))
 		return 0;
 
 	return _lv_passes_volumes_filter(cmd, lv, cn, activation_read_only_volume_list_CFG);
@@ -648,8 +648,8 @@ static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv,
 	 * in progress - as only those could lead to opened files
 	 */
 	if (with_open_count) {
-		if (locking_is_clustered() && !sync_local_dev_names(cmd)) /* Wait to have udev in sync */
-			return_0;
+		if (locking_is_clustered())
+			sync_local_dev_names(cmd); /* Wait to have udev in sync */
 		else if (fs_has_non_delete_ops())
 			fs_unlock(); /* For non clustered - wait if there are non-delete ops */
 	}
@@ -1813,9 +1813,7 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 		goto_out;
 
 	/* Ignore origin_only unless LV is origin in both old and new metadata */
-	/* or LV is thin or thin pool volume */
-	if (!lv_is_thin_volume(ondisk_lv) && !lv_is_thin_pool(ondisk_lv) &&
-	    !(lv_is_origin(ondisk_lv) && lv_is_origin(incore_lv)))
+	if (!lv_is_thin_volume(ondisk_lv) && !(lv_is_origin(ondisk_lv) && lv_is_origin(incore_lv)))
 		laopts->origin_only = 0;
 
 	if (test_mode()) {
@@ -1989,6 +1987,7 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 	const struct logical_volume *lv_to_free = NULL;
 	struct lvinfo info;
 	int r = 0;
+	int messages_only = 0;
 
 	if (!activation())
 		return 1;
@@ -1996,7 +1995,10 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 	if (!lv && !(lv_to_free = lv = lv_from_lvid(cmd, lvid_s, 0)))
 		goto_out;
 
-	if (!lv_is_origin(lv) && !lv_is_thin_volume(lv) && !lv_is_thin_pool(lv))
+	if (lv_is_thin_pool(lv) && laopts->origin_only)
+		messages_only = 1;
+
+	if (!lv_is_origin(lv) && !lv_is_thin_volume(lv))
 		laopts->origin_only = 0;
 
 	if (test_mode()) {
@@ -2016,7 +2018,7 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 	if (!lv_info(cmd, lv, laopts->origin_only, &info, 0, 0))
 		goto_out;
 
-	if (!info.exists || !info.suspended) {
+	if (!info.exists || !(info.suspended || messages_only)) {
 		if (error_if_not_active)
 			goto_out;
 		r = 1;

lib/activate/dev_manager.c

@@ -60,7 +60,6 @@ struct dev_manager {
 	uint32_t pvmove_mirror_count;
 	int flush_required;
 	int activation;                 /* building activation tree */
-	int suspend;			/* building suspend tree */
 	int skip_external_lv;
 	struct dm_list pending_delete;	/* str_list of dlid(s) with pending delete */
 	unsigned track_pending_delete;
@@ -143,23 +142,23 @@ static int _get_segment_status_from_target_params(const char *target_name,
 		return 0;
 	}
 
-	if (segtype_is_cache(segtype)) {
+	if (!strcmp(segtype->name, "cache")) {
 		if (!dm_get_status_cache(seg_status->mem, params, &(seg_status->cache)))
 			return_0;
 		seg_status->type = SEG_STATUS_CACHE;
-	} else if (segtype_is_raid(segtype)) {
+	} else if (!strcmp(segtype->name, "raid")) {
 		if (!dm_get_status_raid(seg_status->mem, params, &seg_status->raid))
 			return_0;
 		seg_status->type = SEG_STATUS_RAID;
-	} else if (segtype_is_thin_volume(segtype)) {
+	} else if (!strcmp(segtype->name, "thin")) {
 		if (!dm_get_status_thin(seg_status->mem, params, &seg_status->thin))
 			return_0;
 		seg_status->type = SEG_STATUS_THIN;
-	} else if (segtype_is_thin_pool(segtype)) {
+	} else if (!strcmp(segtype->name, "thin-pool")) {
 		if (!dm_get_status_thin_pool(seg_status->mem, params, &seg_status->thin_pool))
 			return_0;
 		seg_status->type = SEG_STATUS_THIN_POOL;
-	} else if (segtype_is_snapshot(segtype)) {
+	} else if (!strcmp(segtype->name, "snapshot")) {
 		if (!dm_get_status_snapshot(seg_status->mem, params, &seg_status->snapshot))
 			return_0;
 		seg_status->type = SEG_STATUS_SNAPSHOT;
@@ -518,73 +517,6 @@ out:
 	return r;
 }
 
-static int _ignore_unusable_thins(struct device *dev)
-{
-	/* TODO make function for thin testing */
-	struct dm_pool *mem;
-	struct dm_status_thin_pool *status;
-	struct dm_task *dmt = NULL;
-	void *next = NULL;
-	uint64_t start, length;
-	char *target_type = NULL;
-	char *params;
-	int minor, major;
-	int r = 0;
-
-	if (!(mem = dm_pool_create("unusable_thins", 128)))
-		return_0;
-
-	if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
-		goto_out;
-	if (!dm_task_no_open_count(dmt))
-		goto_out;
-	if (!dm_task_set_major_minor(dmt, MAJOR(dev->dev), MINOR(dev->dev), 1))
-		goto_out;
-	if (!dm_task_run(dmt)) {
-		log_error("Failed to get state of mapped device.");
-		goto out;
-	}
-	dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
-	if (sscanf(params, "%d:%d", &minor, &major) != 2) {
-		log_error("Failed to get thin-pool major:minor for thin device %d:%d.",
-			  (int)MAJOR(dev->dev), (int)MINOR(dev->dev));
-		goto out;
-	}
-	dm_task_destroy(dmt);
-
-	if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
-		goto_out;
-	if (!dm_task_no_flush(dmt))
-		log_warn("Can't set no_flush.");
-	if (!dm_task_no_open_count(dmt))
-		goto_out;
-	if (!dm_task_set_major_minor(dmt, minor, major, 1))
-		goto_out;
-	if (!dm_task_run(dmt)) {
-		log_error("Failed to get state of mapped device.");
-		goto out;
-	}
-
-	dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
-	if (!dm_get_status_thin_pool(mem, params, &status))
-		return_0;
-
-	if (status->read_only || status->out_of_data_space) {
-		log_warn("WARNING: %s: Thin's thin-pool needs inspection.",
-			 dev_name(dev));
-		goto out;
-	}
-
-	r = 1;
-out:
-	if (dmt)
-		dm_task_destroy(dmt);
-
-	dm_pool_destroy(mem);
-
-        return r;
-}
-
 /*
  * device_is_usable
  * @dev
@@ -713,13 +645,6 @@ int device_is_usable(struct device *dev, struct dev_usable_check_params check)
 			goto out;
 		}
 
-		/* TODO: extend check struct ? */
-		if (target_type && !strcmp(target_type, "thin") &&
-		    !_ignore_unusable_thins(dev)) {
-			log_debug_activation("%s: %s device %s not usable.", dev_name(dev), target_type, name);
-			goto out;
-		}
-
 		if (target_type && strcmp(target_type, "error"))
 			only_error_target = 0;
 	} while (next);
@@ -1045,11 +970,6 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 				wait ? DM_DEVICE_WAITEVENT : DM_DEVICE_STATUS, 0, 0, 0)))
 		return_0;
 
-	/* No freeze on overfilled thin-pool, read existing slightly outdated data */
-	if (lv && lv_is_thin_pool(lv) &&
-	    !dm_task_no_flush(dmt))
-		log_warn("Can't set no_flush flag."); /* Non fatal */
-
 	if (!dm_task_run(dmt))
 		goto_out;
 
@@ -1117,7 +1037,7 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 			goto_out;
 	}
 
-	log_debug_activation("LV percent: %.2f", dm_percent_to_float(*overall_percent));
+	log_debug_activation("LV percent: %f", dm_percent_to_float(*overall_percent));
 	r = 1;
 
       out:
@@ -1997,6 +1917,7 @@ struct pool_cb_data {
 	int skip_zero;  /* to skip zeroed device header (check first 64B) */
 	int exec;       /* which binary to call */
 	int opts;
+	const char *defaults;
 	const char *global;
 };
 
@@ -2004,6 +1925,7 @@ static int _pool_callback(struct dm_tree_node *node,
 			  dm_node_callback_t type, void *cb_data)
 {
 	int ret, status, fd;
+	char *split;
 	const struct dm_config_node *cn;
 	const struct dm_config_value *cv;
 	const struct pool_cb_data *data = cb_data;
@@ -2018,19 +1940,23 @@ static int _pool_callback(struct dm_tree_node *node,
 	if (!*argv[0])
 		return 1; /* Checking disabled */
 
-	if (!(cn = find_config_tree_array(mlv->vg->cmd, data->opts, NULL))) {
-		log_error(INTERNAL_ERROR "Unable to find configuration for pool check options.");
-		return 0;
-	}
-
-	for (cv = cn->v; cv && args < 16; cv = cv->next) {
-		if (cv->type != DM_CFG_STRING) {
-			log_error("Invalid string in config file: "
-				  "global/%s_check_options",
-				  data->global);
+	if ((cn = find_config_tree_node(mlv->vg->cmd, data->opts, NULL))) {
+		for (cv = cn->v; cv && args < 16; cv = cv->next) {
+			if (cv->type != DM_CFG_STRING) {
+				log_error("Invalid string in config file: "
+					  "global/%s_check_options",
+					  data->global);
+				return 0;
+			}
+			argv[++args] = cv->v.str;
+		}
+	} else {
+		/* Use default options (no support for options with spaces) */
+		if (!(split = dm_pool_strdup(data->dm->mem, data->defaults))) {
+			log_error("Failed to duplicate defaults.");
 			return 0;
 		}
-		argv[++args] = cv->v.str;
+		args = dm_split_words(split, 16, 0, (char**) argv + 1);
 	}
 
 	if (args == 16) {
@@ -2121,12 +2047,14 @@ static int _pool_register_callback(struct dev_manager *dm,
 		data->skip_zero = 1;
 		data->exec = global_thin_check_executable_CFG;
 		data->opts = global_thin_check_options_CFG;
+		data->defaults = DEFAULT_THIN_CHECK_OPTION1 " " DEFAULT_THIN_CHECK_OPTION2;
 		data->global = "thin";
 	} else if (lv_is_cache(lv)) { /* cache pool */
 		data->pool_lv = first_seg(lv)->pool_lv;
 		data->skip_zero = dm->activation;
 		data->exec = global_cache_check_executable_CFG;
 		data->opts = global_cache_check_options_CFG;
+		data->defaults = DEFAULT_CACHE_CHECK_OPTION1;
 		data->global = "cache";
 	} else {
 		log_error(INTERNAL_ERROR "Registering unsupported pool callback.");
@@ -2138,11 +2066,6 @@ static int _pool_register_callback(struct dev_manager *dm,
 	return 1;
 }
 
-/* Declaration to resolve suspend tree and message passing for thin-pool */
-static int _add_target_to_dtree(struct dev_manager *dm,
-				struct dm_tree_node *dnode,
-				struct lv_segment *seg,
-				struct lv_activate_opts *laopts);
 /*
  * Add LV and any known dependencies
  */
@@ -2211,43 +2134,15 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		 */
 		if (!_add_dev_to_dtree(dm, dtree, lv, lv_layer(lv)))
 			return_0;
-
-		/*
-		 * TODO: change API and move this code
-		 * Could be easier to handle this in _add_dev_to_dtree()
-		 * and base this according to info.exists ?
-		 */
 		if (!dm->activation) {
+			/* Setup callback for non-activation partial tree */
+			/* Activation gets own callback when needed */
+			/* TODO: extend _cached_dm_info() to return dnode */
 			if (!(uuid = build_dm_uuid(dm->mem, lv, lv_layer(lv))))
 				return_0;
-			if ((node = dm_tree_find_node_by_uuid(dtree, uuid))) {
-				if (origin_only) {
-					struct lv_activate_opts laopts = {
-						.origin_only = 1,
-						.send_messages = 1 /* Node with messages */
-					};
-					/*
-					 * Add some messsages if right node exist in the table only
-					 * when building SUSPEND tree for origin-only thin-pool.
-					 *
-					 * TODO: Fix call of '_add_target_to_dtree()' to add message
-					 * to thin-pool node as we already know the pool node exists
-					 * in the table. Any better/cleaner API way ?
-					 *
-					 * Probably some 'new' target method to add messages for any node?
-					 */
-					if (dm->suspend &&
-					    !dm_list_empty(&(first_seg(lv)->thin_messages)) &&
-					    !_add_target_to_dtree(dm, node, first_seg(lv), &laopts))
-						return_0;
-				} else {
-					/* Setup callback for non-activation partial tree */
-					/* Activation gets own callback when needed */
-					/* TODO: extend _cached_dm_info() to return dnode */
-					if (!_pool_register_callback(dm, node, lv))
-						return_0;
-				}
-			}
+			if ((node = dm_tree_find_node_by_uuid(dtree, uuid)) &&
+			    !_pool_register_callback(dm, node, lv))
+				return_0;
 		}
 	}
 
@@ -2345,7 +2240,7 @@ static struct dm_tree *_create_partial_dtree(struct dev_manager *dm, const struc
 
 	dm_tree_set_optional_uuid_suffixes(dtree, &uuid_suffix_list[0]);
 
-	if (!_add_lv_to_dtree(dm, dtree, lv, (lv_is_origin(lv) || lv_is_thin_volume(lv) || lv_is_thin_pool(lv)) ? origin_only : 0))
+	if (!_add_lv_to_dtree(dm, dtree, lv, (lv_is_origin(lv) || lv_is_thin_volume(lv)) ? origin_only : 0))
 		goto_bad;
 
 	return dtree;
@@ -2800,7 +2695,7 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 		return_0;
 
 	/* Add pool layer */
-	if (seg->pool_lv && !laopts->origin_only &&
+	if (seg->pool_lv &&
 	    !_add_new_lv_to_dtree(dm, dtree, seg->pool_lv, laopts,
 				  lv_layer(seg->pool_lv)))
 		return_0;
@@ -3242,7 +3137,6 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv,
 	}
 	/* Some targets may build bigger tree for activation */
 	dm->activation = ((action == PRELOAD) || (action == ACTIVATE));
-	dm->suspend = (action == SUSPEND_WITH_LOCKFS) || (action == SUSPEND);
 	if (!(dtree = _create_partial_dtree(dm, lv, laopts->origin_only)))
 		return_0;
 
@@ -3277,7 +3171,7 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv,
 		break;
 	case SUSPEND:
 		dm_tree_skip_lockfs(root);
-		if (!dm->flush_required && !lv_is_pvmove(lv))
+		if (!dm->flush_required && lv_is_mirror(lv) && !lv_is_pvmove(lv))
 			dm_tree_use_no_flush_suspend(root);
 		/* Fall through */
 	case SUSPEND_WITH_LOCKFS:
@@ -3287,23 +3181,14 @@ static int _tree_action(struct dev_manager *dm, const struct logical_volume *lv,
 	case PRELOAD:
 	case ACTIVATE:
 		/* Add all required new devices to tree */
-		if (!_add_new_lv_to_dtree(dm, dtree, lv, laopts,
-					  (lv_is_origin(lv) && laopts->origin_only) ? "real" :
-					  (lv_is_thin_pool(lv) && laopts->origin_only) ? "tpool" : NULL))
+		if (!_add_new_lv_to_dtree(dm, dtree, lv, laopts, (lv_is_origin(lv) && laopts->origin_only) ? "real" : NULL))
 			goto_out;
 
 		/* Preload any devices required before any suspensions */
 		if (!dm_tree_preload_children(root, dlid, DLID_SIZE))
 			goto_out;
 
-		if ((dm_tree_node_size_changed(root) < 0))
-			dm->flush_required = 1;
-
-		/* Currently keep the code require flush for any
-		 * non 'thin pool/volume, mirror' or with any size change */
-		if (!lv_is_thin_volume(lv) &&
-		    !lv_is_thin_pool(lv) &&
-		    (!lv_is_mirror(lv) || dm_tree_node_size_changed(root)))
+		if (dm_tree_node_size_changed(root))
 			dm->flush_required = 1;
 
 		if (action == ACTIVATE) {
@@ -3334,6 +3219,7 @@ out_no_root:
 int dev_manager_activate(struct dev_manager *dm, const struct logical_volume *lv,
 			 struct lv_activate_opts *laopts)
 {
+	laopts->send_messages = 1;
 	if (!_tree_action(dm, lv, laopts, ACTIVATE))
 		return_0;
 

lib/cache/lvmcache.c

@@ -56,7 +56,6 @@ struct lvmcache_vginfo {
 	char _padding[7];
 	struct lvmcache_vginfo *next; /* Another VG with same name? */
 	char *creation_host;
-	char *lock_type;
 	uint32_t mda_checksum;
 	size_t mda_size;
 	size_t vgmetadata_size;
@@ -1448,7 +1447,7 @@ static int _lvmcache_update_vgname(struct lvmcache_info *info,
 }
 
 static int _lvmcache_update_vgstatus(struct lvmcache_info *info, uint32_t vgstatus,
-				     const char *creation_host, const char *lock_type)
+				     const char *creation_host)
 {
 	if (!info || !info->vginfo)
 		return 1;
@@ -1461,11 +1460,11 @@ static int _lvmcache_update_vgstatus(struct lvmcache_info *info, uint32_t vgstat
 	info->vginfo->status = vgstatus;
 
 	if (!creation_host)
-		goto set_lock_type;
+		return 1;
 
 	if (info->vginfo->creation_host && !strcmp(creation_host,
 						   info->vginfo->creation_host))
-		goto set_lock_type;
+		return 1;
 
 	if (info->vginfo->creation_host)
 		dm_free(info->vginfo->creation_host);
@@ -1479,24 +1478,6 @@ static int _lvmcache_update_vgstatus(struct lvmcache_info *info, uint32_t vgstat
 	log_debug_cache("lvmcache: %s: VG %s: Set creation host to %s.",
 			dev_name(info->dev), info->vginfo->vgname, creation_host);
 
-set_lock_type:
-
-	if (!lock_type)
-		goto out;
-
-	if (info->vginfo->lock_type && !strcmp(lock_type, info->vginfo->lock_type))
-		goto out;
-
-	if (info->vginfo->lock_type)
-		dm_free(info->vginfo->lock_type);
-
-	if (!(info->vginfo->lock_type = dm_strdup(lock_type))) {
-		log_error("cache creation host alloc failed for %s",
-			  lock_type);
-		return 0;
-	}
-
-out:
 	return 1;
 }
 
@@ -1542,6 +1523,10 @@ int lvmcache_update_vgname_and_id(struct lvmcache_info *info, struct lvmcache_vg
 		vgid = vgname;
 	}
 
+	/* When using lvmetad, the PV could not have become orphaned. */
+	if (lvmetad_active() && is_orphan_vg(vgname) && info->vginfo)
+		return 1;
+
 	/* If PV without mdas is already in a real VG, don't make it orphan */
 	if (is_orphan_vg(vgname) && info->vginfo &&
 	    mdas_empty_or_ignored(&info->mdas) &&
@@ -1561,7 +1546,7 @@ int lvmcache_update_vgname_and_id(struct lvmcache_info *info, struct lvmcache_vg
 	if (!_lvmcache_update_vgname(info, vgname, vgid, vgsummary->vgstatus,
 				     vgsummary->creation_host, info->fmt) ||
 	    !_lvmcache_update_vgid(info, info->vginfo, vgid) ||
-	    !_lvmcache_update_vgstatus(info, vgsummary->vgstatus, vgsummary->creation_host, vgsummary->lock_type) ||
+	    !_lvmcache_update_vgstatus(info, vgsummary->vgstatus, vgsummary->creation_host) ||
 	    !_lvmcache_update_vg_mda_info(info, vgsummary->mda_checksum, vgsummary->mda_size))
 		return_0;
 
@@ -1576,8 +1561,7 @@ int lvmcache_update_vg(struct volume_group *vg, unsigned precommitted)
 	struct lvmcache_vgsummary vgsummary = {
 		.vgname = vg->name,
 		.vgstatus = vg->status,
-		.vgid = vg->id,
-		.lock_type = vg->lock_type
+		.vgid = vg->id
 	};
 
 	pvid_s[sizeof(pvid_s) - 1] = '\0';
@@ -1867,17 +1851,19 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 			 * device already exists?  Things don't seem to work
 			 * if we do that for some reason.
 			 */
-			log_debug_cache("Found same device %s with same pvid %s",
-					dev_name(existing->dev), pvid_s);
+			log_verbose("Found same device %s with same pvid %s",
+				    dev_name(existing->dev), pvid_s);
 		}
 
 		/*
-		 * This happens when running pvcreate on an existing PV.
+		 * FIXME: when could this ever happen?
+		 * If this does happen, identify when/why here, and
+		 * if not, remove this code.
 		 */
 		if (strcmp(pvid_s, existing->dev->pvid))  {
-			log_verbose("Replacing dev %s pvid %s with dev %s pvid %s",
-				    dev_name(existing->dev), existing->dev->pvid,
-				    dev_name(dev), pvid_s);
+			log_warn("Replacing dev %s pvid %s with dev %s pvid %s",
+				 dev_name(existing->dev), existing->dev->pvid,
+				 dev_name(dev), pvid_s);
 		}
 
 		/*
@@ -2341,40 +2327,3 @@ int lvmcache_lookup_mda(struct lvmcache_vgsummary *vgsummary)
 
 	return 0;
 }
-
-int lvmcache_contains_lock_type_sanlock(struct cmd_context *cmd)
-{
-	struct lvmcache_vginfo *vginfo;
-
-	dm_list_iterate_items(vginfo, &_vginfos) {
-		if (vginfo->lock_type && !strcmp(vginfo->lock_type, "sanlock"))
-			return 1;
-	}
-
-	return 0;
-}
-
-void lvmcache_get_max_name_lengths(struct cmd_context *cmd,
-				   unsigned *pv_max_name_len,
-				   unsigned *vg_max_name_len)
-{
-	struct lvmcache_vginfo *vginfo;
-	struct lvmcache_info *info;
-	unsigned len;
-
-	*vg_max_name_len = 0;
-	*pv_max_name_len = 0;
-
-	dm_list_iterate_items(vginfo, &_vginfos) {
-		len = strlen(vginfo->vgname);
-		if (*vg_max_name_len < len)
-			*vg_max_name_len = len;
-
-		dm_list_iterate_items(info, &vginfo->infos) {
-			len = strlen(dev_name(info->dev));
-			if (*pv_max_name_len < len)
-				*pv_max_name_len = len;
-		}
-	}
-}
-

lib/cache/lvmcache.h

@@ -39,23 +39,11 @@ struct disk_locn;
 
 struct lvmcache_vginfo;
 
-/*
- * vgsummary represents a summary of the VG that is read
- * without a lock.  The info does not come through vg_read(),
- * but through reading mdas.  It provides information about
- * the VG that is needed to lock the VG and then read it fully
- * with vg_read(), after which the VG summary should be checked
- * against the full VG metadata to verify it was correct (since
- * it was read without a lock.)
- *
- * Once read, vgsummary information is saved in lvmcache_vginfo.
- */
 struct lvmcache_vgsummary {
 	const char *vgname;
 	struct id vgid;
 	uint64_t vgstatus;
 	char *creation_host;
-	const char *lock_type;
 	uint32_t mda_checksum;
 	size_t mda_size;
 };
@@ -188,10 +176,4 @@ int lvmcache_found_duplicate_pvs(void);
 
 void lvmcache_set_preferred_duplicates(const char *vgid);
 
-int lvmcache_contains_lock_type_sanlock(struct cmd_context *cmd);
-
-void lvmcache_get_max_name_lengths(struct cmd_context *cmd,
-			unsigned *pv_max_name_len, unsigned *vg_max_name_len);
-
-
 #endif

lib/cache/lvmetad.c

@@ -22,7 +22,6 @@
 #include "format-text.h" // TODO for disk_locn, used as a DA representation
 #include "crc.h"
 #include "lvm-signal.h"
-#include "lvmlockd.h"
 
 #define SCAN_TIMEOUT_SECONDS	80
 #define MAX_RESCANS		10	/* Maximum number of times to scan all PVs and retry if the daemon returns a token mismatch error */
@@ -37,70 +36,6 @@ static struct cmd_context *_lvmetad_cmd = NULL;
 
 static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct volume_group *vg);
 
-static int _log_debug_inequality(const char *name, struct dm_config_node *a, struct dm_config_node *b)
-{
-	int result = 0;
-	int final_result = 0;
-
-	if (a->v && b->v) {
-		result = compare_value(a->v, b->v);
-		if (result) {
-			struct dm_config_value *av = a->v;
-			struct dm_config_value *bv = b->v;
-
-			if (!strcmp(a->key, b->key)) {
-				if (a->v->type == DM_CFG_STRING && b->v->type == DM_CFG_STRING)
-					log_debug_lvmetad("VG %s metadata inequality at %s / %s: %s / %s",
-							  name, a->key, b->key, av->v.str, bv->v.str);
-				else if (a->v->type == DM_CFG_INT && b->v->type == DM_CFG_INT)
-					log_debug_lvmetad("VG %s metadata inequality at %s / %s: " FMTi64 " / " FMTi64,
-							  name, a->key, b->key, av->v.i, bv->v.i);
-				else
-					log_debug_lvmetad("VG %s metadata inequality at %s / %s: type %d / type %d",
-							  name, a->key, b->key, av->type, bv->type);
-			} else {
-				log_debug_lvmetad("VG %s metadata inequality at %s / %s", name, a->key, b->key);
-			}
-			final_result = result;
-		}
-	}
-
-	if (a->v && !b->v) {
-		log_debug_lvmetad("VG %s metadata inequality at %s / %s", name, a->key, b->key);
-		final_result = 1;
-	}
-
-	if (!a->v && b->v) {
-		log_debug_lvmetad("VG %s metadata inequality at %s / %s", name, a->key, b->key);
-		final_result = -1;
-	}
-
-	if (a->child && b->child) {
-		result = _log_debug_inequality(name, a->child, b->child);
-		if (result)
-			final_result = result;
-	}
-
-	if (a->sib && b->sib) {
-		result = _log_debug_inequality(name, a->sib, b->sib);
-		if (result)
-			final_result = result;
-	}
-	
-
-	if (a->sib && !b->sib) {
-		log_debug_lvmetad("VG %s metadata inequality at %s / %s", name, a->key, b->key);
-		final_result = 1;
-	}
-
-	if (!a->sib && b->sib) {
-		log_debug_lvmetad("VG %s metadata inequality at %s / %s", name, a->key, b->key);
-		final_result = -1;
-	}
-
-	return final_result;
-}
-
 void lvmetad_disconnect(void)
 {
 	if (_lvmetad_connected)
@@ -212,7 +147,7 @@ static int _lvmetad_pvscan_all_devs(struct cmd_context *cmd, activation_handler
 static daemon_reply _lvmetad_send(const char *id, ...)
 {
 	va_list ap;
-	daemon_reply repl = { 0 };
+	daemon_reply repl;
 	daemon_request req;
 	unsigned num_rescans = 0;
 	unsigned total_usecs_waited = 0;
@@ -222,10 +157,8 @@ static daemon_reply _lvmetad_send(const char *id, ...)
 retry:
 	req = daemon_request_make(id);
 
-	if (_lvmetad_token && !daemon_request_extend(req, "token = %s", _lvmetad_token, NULL)) {
-		repl.error = ENOMEM;
-		return repl;
-	}
+	if (_lvmetad_token)
+		daemon_request_extend(req, "token = %s", _lvmetad_token, NULL);
 
 	va_start(ap, id);
 	daemon_request_extend_v(req, ap);
@@ -498,7 +431,6 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, const char *vgna
 	struct format_type *fmt;
 	struct dm_config_node *pvcn;
 	struct pv_list *pvl;
-	int rescan = 0;
 
 	if (!lvmetad_active())
 		return NULL;
@@ -557,56 +489,16 @@ struct volume_group *lvmetad_vg_lookup(struct cmd_context *cmd, const char *vgna
 		if (!(vg = import_vg_from_lvmetad_config_tree(reply.cft, fid)))
 			goto_out;
 
-		/*
-		 * Read the VG from disk, ignoring the lvmetad copy in these
-		 * cases:
-		 *
-		 * 1. The host is not using lvmlockd, but is reading lockd VGs
-		 * using the --shared option.  The shared option is meant to
-		 * let hosts not running lvmlockd look at lockd VGs, like the
-		 * foreign option allows hosts to look at foreign VGs.  When
-		 * --foreign is used, the code forces a rescan since the local
-		 * lvmetad cache of foreign VGs is likely stale.  Similarly,
-		 * for --shared, have the code reading the shared VGs below
-		 * not use the cached copy from lvmetad but to rescan the VG.
-		 *
-		 * 2. The host failed to acquire the VG lock from lvmlockd for
-		 * the lockd VG.  In this case, the usual mechanisms for
-		 * updating the lvmetad copy of the VG have been missed.  Since
-		 * we don't know if the cached copy is valid, assume it's not.
-		 *
-		 * 3. lvmetad has returned the "vg_invalid" flag, which is the
-		 * usual mechanism used by lvmlockd/lvmetad to cause a host to
-		 * reread a VG from disk that has been modified from another
-		 * host.
-		 */
-
-		if (is_lockd_type(vg->lock_type) && cmd->include_shared_vgs) {
-			log_debug_lvmetad("Rescan VG %s because including shared", vgname);
-			rescan = 1;
-		} else if (is_lockd_type(vg->lock_type) && cmd->lockd_vg_rescan) {
-			log_debug_lvmetad("Rescan VG %s because no lvmlockd lock is held", vgname);
-			rescan = 1;
-		} else if (dm_config_find_node(reply.cft->root, "vg_invalid")) {
-			log_debug_lvmetad("Rescan VG %s because lvmetad returned invalid", vgname);
-			rescan = 1;
-		}
-
 		/*
 		 * locking may have detected a newer vg version and
 		 * invalidated the cached vg.
 		 */
-		if (rescan) {
+		if (dm_config_find_node(reply.cft->root, "vg_invalid")) {
 			log_debug_lvmetad("Update invalid lvmetad cache for VG %s", vgname);
 			vg2 = lvmetad_pvscan_vg(cmd, vg);
 			release_vg(vg);
 			vg = vg2;
-			if (!vg) {
-				log_debug_lvmetad("VG %s from lvmetad not found during rescan.", vgname);
-				fid = NULL;
-				goto out;
-			} else
-				fid = vg->fid;
+			fid = vg->fid;
 		}
 
 		dm_list_iterate_items(pvl, &vg->pvs) {
@@ -1057,51 +949,6 @@ int lvmetad_pv_found(const struct id *pvid, struct device *dev, const struct for
 	     daemon_reply_int(reply, "seqno_after", -1) != daemon_reply_int(reply, "seqno_before", -1)))
 		log_warn("WARNING: Inconsistent metadata found for VG %s", vg->name);
 
-	/*
-	 * pvscan --cache does not perform any lvmlockd locking, and
-	 * pvscan --cache -aay skips autoactivation in lockd VGs.
-	 *
-	 * pvscan --cache populates lvmetad with VG metadata from disk.
-	 * No lvmlockd locking is needed.  It is expected that lockd VG
-	 * metadata that is read by pvscan and populated in lvmetad may
-	 * be immediately stale due to changes to the VG from other hosts
-	 * during or after this pvscan.  This is normal and not a problem.
-	 * When a subsequent lvm command uses the VG, it will lock the VG
-	 * with lvmlockd, read the VG from lvmetad, and update the cached
-	 * copy from disk if necessary.
-	 *
-	 * pvscan --cache -aay does not activate LVs in lockd VGs because
-	 * activation requires locking, and a lock-start operation is needed
-	 * on a lockd VG before any locking can be performed in it.
-	 *
-	 * An equivalent of pvscan --cache -aay for lockd VGs is:
-	 * 1. pvscan --cache
-	 * 2. vgchange --lock-start
-	 * 3. vgchange -aay -S 'locktype=sanlock || locktype=dlm'
-	 *
-	 * [We could eventually add support for autoactivating lockd VGs
-	 * using pvscan by incorporating the lock start step (which can
-	 * take a long time), but there may be a better option than
-	 * continuing to overload pvscan.]
-	 * 
-	 * Stages of starting a lockd VG:
-	 *
-	 * . pvscan --cache populates lockd VGs in lvmetad without locks,
-	 *   and this initial cached copy may quickly become stale.
-	 *
-	 * . vgchange --lock-start VG reads the VG without the VG lock
-	 *   because no locks are available until the locking is started.
-	 *   It only uses the VG name and lock_type from the VG metadata,
-	 *   and then only uses it to start the VG lockspace in lvmlockd.
-	 *
-	 * . Further lvm commands, e.g. activation, can then lock the VG
-	 *   with lvmlockd and use current VG metdata.
-	 */
-	if (handler && vg && is_lockd_type(vg->lock_type)) {
-		log_debug_lvmetad("Skip pvscan activation for lockd type VG %s", vg->name);
-		handler = NULL;
-	}
-
 	if (result && handler) {
 		status = daemon_reply_str(reply, "status", "<missing>");
 		vgname = daemon_reply_str(reply, "vgname", "<missing>");
@@ -1169,8 +1016,7 @@ static int _lvmetad_pvscan_single(struct metadata_area *mda, void *baton)
 	struct _lvmetad_pvscan_baton *b = baton;
 	struct volume_group *this;
 
-	if (!(this = mda_is_ignored(mda) ? NULL : mda->ops->vg_read(b->fid, "", mda, NULL, NULL, 1)))
-		return 1;
+	this = mda_is_ignored(mda) ? NULL : mda->ops->vg_read(b->fid, "", mda, NULL, NULL, 1);
 
 	/* FIXME Also ensure contents match etc. */
 	if (!b->vg || this->seqno > b->vg->seqno)
@@ -1186,8 +1032,6 @@ static int _lvmetad_pvscan_single(struct metadata_area *mda, void *baton)
  * due to something like an lvcreate from another host.
  * This is limited to changes that only affect the vg (not global state like
  * orphan PVs), so we only need to reread mdas on the vg's existing pvs.
- * But, a previous PV in the VG may have been removed since we last read
- * the VG, and that PV may have been reused for another VG.
  */
 
 static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct volume_group *vg)
@@ -1200,17 +1044,13 @@ static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct vo
 	struct format_instance *fid;
 	struct format_instance_ctx fic = { .type = 0 };
 	struct _lvmetad_pvscan_baton baton;
-	struct device *save_dev = NULL;
 
 	dm_list_iterate_items(pvl, &vg->pvs) {
 		/* missing pv */
 		if (!pvl->pv->dev)
 			continue;
 
-		if (!(info = lvmcache_info_from_pvid((const char *)&pvl->pv->id, 0))) {
-			log_error("Failed to find cached info for PV %s.", pv_dev_name(pvl->pv));
-			return NULL;
-		}
+		info = lvmcache_info_from_pvid((const char *)&pvl->pv->id, 0);
 
 		baton.vg = NULL;
 		baton.fid = lvmcache_fmt(info)->ops->create_instance(lvmcache_fmt(info), &fic);
@@ -1227,25 +1067,9 @@ static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct vo
 
 		lvmcache_foreach_mda(info, _lvmetad_pvscan_single, &baton);
 
-		/*
-		 * The PV may have been removed from the VG by another host
-		 * since we last read the VG.
-		 */
 		if (!baton.vg) {
-			log_debug_lvmetad("Did not find VG %s in scan of PV %s", vg->name, dev_name(pvl->pv->dev));
 			lvmcache_fmt(info)->ops->destroy_instance(baton.fid);
-			continue;
-		}
-
-		/*
-		 * The PV may have been removed from the VG and used for a
-		 * different VG since we last read the VG.
-		 */
-		if (strcmp(baton.vg->name, vg->name)) {
-			log_debug_lvmetad("Did not find VG %s in scan of PV %s which is now VG %s",
-					  vg->name, dev_name(pvl->pv->dev), baton.vg->name);
-			release_vg(baton.vg);
-			continue;
+			return NULL;
 		}
 
 		if (!(vgmeta = export_vg_to_config_tree(baton.vg))) {
@@ -1256,12 +1080,9 @@ static struct volume_group *lvmetad_pvscan_vg(struct cmd_context *cmd, struct vo
 
 		if (!vgmeta_ret) {
 			vgmeta_ret = vgmeta;
-			save_dev = pvl->pv->dev;
 		} else {
-			if (compare_config(vgmeta_ret->root, vgmeta->root)) {
-				log_error("VG %s metadata comparison failed for device %s vs %s",
-					  vg->name, dev_name(pvl->pv->dev), save_dev ? dev_name(save_dev) : "none");
-				_log_debug_inequality(vg->name, vgmeta_ret->root, vgmeta->root);
+			if (!compare_config(vgmeta_ret->root, vgmeta->root)) {
+				log_error("VG metadata comparison failed");
 				dm_config_destroy(vgmeta);
 				dm_config_destroy(vgmeta_ret);
 				release_vg(baton.vg);
@@ -1331,7 +1152,7 @@ int lvmetad_pvscan_single(struct cmd_context *cmd, struct device *dev,
 			log_warn("WARNING: Ignoring obsolete format of metadata (%s) on device %s when using lvmetad",
 				  baton.fid->fmt->name, dev_name(dev));
 		else
-			log_error("Ignoring obsolete format of metadata (%s) on device %s when using lvmetad.",
+			log_error("WARNING: Ignoring obsolete format of metadata (%s) on device %s when using lvmetad",
 				  baton.fid->fmt->name, dev_name(dev));
 		lvmcache_fmt(info)->ops->destroy_instance(baton.fid);
 
@@ -1528,8 +1349,7 @@ static int _lvmetad_get_pv_cache_list(struct cmd_context *cmd, struct dm_list *p
 /*
  * Opening the device RDWR should trigger a udev db update.
  * FIXME: is there a better way to update the udev db than
- * doing an open/close of the device? - For example writing
- * "change" to /sys/block/<device>/uevent?
+ * doing an open/close of the device?
  */
 static void _update_pv_in_udev(struct cmd_context *cmd, dev_t devt)
 {
@@ -1543,13 +1363,9 @@ static void _update_pv_in_udev(struct cmd_context *cmd, dev_t devt)
 		return;
 	}
 
-	if (!dev_open(dev)) {
-		stack;
+	if (!dev_open(dev))
 		return;
-	}
-
-	if (!dev_close(dev))
-		stack;
+	dev_close(dev);
 }
 
 /*
@@ -1678,15 +1494,8 @@ void lvmetad_validate_global_cache(struct cmd_context *cmd, int force)
 	dm_list_init(&pvc_before);
 	dm_list_init(&pvc_after);
 
-	if (!lvmlockd_use()) {
-		log_error(INTERNAL_ERROR "validate global cache without lvmlockd");
+	if (!lvmetad_used())
 		return;
-	}
-
-	if (!lvmetad_active())
-		return;
-
-	log_debug_lvmetad("Validating global lvmetad cache");
 
 	if (force)
 		goto do_scan;

lib/cache_segtype/cache.c

@@ -25,11 +25,6 @@
 #include "lv_alloc.h"
 #include "defaults.h"
 
-static const char _cache_module[] = "cache";
-
-/* TODO: using static field here, maybe should be a part of segment_type */
-static unsigned _feature_mask;
-
 #define SEG_LOG_ERROR(t, p...) \
         log_error(t " segment %s of logical volume %s.", ## p,	\
                   dm_config_parent_name(sn), seg->lv->name), 0;
@@ -71,16 +66,20 @@ static int _cache_pool_text_import(struct lv_segment *seg,
 	if (dm_config_has_node(sn, "cache_mode")) {
 		if (!(str = dm_config_find_str(sn, "cache_mode", NULL)))
 			return SEG_LOG_ERROR("cache_mode must be a string in");
-		if (!cache_set_mode(seg, str))
+		if (!set_cache_pool_feature(&seg->feature_flags, str))
 			return SEG_LOG_ERROR("Unknown cache_mode in");
-	}
+	} else
+		/* When missed in metadata, it's an old stuff - use writethrough */
+		seg->feature_flags |= DM_CACHE_FEATURE_WRITETHROUGH;
 
 	if (dm_config_has_node(sn, "policy")) {
 		if (!(str = dm_config_find_str(sn, "policy", NULL)))
 			return SEG_LOG_ERROR("policy must be a string in");
 		if (!(seg->policy_name = dm_pool_strdup(mem, str)))
 			return SEG_LOG_ERROR("Failed to duplicate policy in");
-	}
+	} else
+		/* Cannot use 'just' default, so pick one */
+		seg->policy_name = DEFAULT_CACHE_POOL_POLICY; /* FIXME make configurable */
 
 	/*
 	 * Read in policy args:
@@ -100,9 +99,6 @@ static int _cache_pool_text_import(struct lv_segment *seg,
 	 *   If the policy is not present, default policy is used.
 	 */
 	if ((sn = dm_config_find_node(sn, "policy_settings"))) {
-		if (!seg->policy_name)
-			return SEG_LOG_ERROR("policy_settings must have a policy_name in");
-
 		if (sn->v)
 			return SEG_LOG_ERROR("policy_settings must be a section in");
 
@@ -131,33 +127,24 @@ static int _cache_pool_text_export(const struct lv_segment *seg,
 {
 	const char *cache_mode;
 
+	if (!(cache_mode = get_cache_pool_cachemode_name(seg)))
+		return_0;
+
 	outf(f, "data = \"%s\"", seg_lv(seg, 0)->name);
 	outf(f, "metadata = \"%s\"", seg->metadata_lv->name);
 	outf(f, "chunk_size = %" PRIu32, seg->chunk_size);
+	outf(f, "cache_mode = \"%s\"", cache_mode);
 
-	/*
-	 * Cache pool used by a cache LV holds data. Not ideal,
-	 * but not worth to break backward compatibility, by shifting
-	 * content to cache segment
-	 */
-	if (cache_mode_is_set(seg)) {
-		if (!(cache_mode = get_cache_mode_name(seg)))
-			return_0;
-		outf(f, "cache_mode = \"%s\"", cache_mode);
-	}
-
-	if (seg->policy_name) {
+	if (seg->policy_name)
 		outf(f, "policy = \"%s\"", seg->policy_name);
 
-		if (seg->policy_settings) {
-			if (strcmp(seg->policy_settings->key, "policy_settings")) {
-				log_error(INTERNAL_ERROR "Incorrect policy_settings tree, %s.",
-					  seg->policy_settings->key);
-				return 0;
-			}
-			if (seg->policy_settings->child)
-				out_config_node(f, seg->policy_settings);
+	if (seg->policy_settings) {
+		if (strcmp(seg->policy_settings->key, "policy_settings")) {
+			log_error(INTERNAL_ERROR "Incorrect policy_settings tree, %s.",
+				  seg->policy_settings->key);
+			return 0;
 		}
+		out_config_node(f, seg->policy_settings);
 	}
 
 	return 1;
@@ -170,29 +157,12 @@ static void _destroy(struct segment_type *segtype)
 
 #ifdef DEVMAPPER_SUPPORT
 static int _target_present(struct cmd_context *cmd,
-			   const struct lv_segment *seg __attribute__((unused)),
-			   unsigned *attributes __attribute__((unused)))
+				const struct lv_segment *seg __attribute__((unused)),
+				unsigned *attributes __attribute__((unused)))
 {
-	/* List of features with their kernel target version */
-	static const struct feature {
-		uint32_t maj;
-		uint32_t min;
-		unsigned cache_feature;
-		const char feature[12];
-		const char module[12]; /* check dm-%s */
-	} _features[] = {
-		{ 1, 3, CACHE_FEATURE_POLICY_MQ, "policy_mq", "cache-mq" },
-		{ 1, 8, CACHE_FEATURE_POLICY_SMQ, "policy_smq", "cache-smq" },
-	};
-	static const char _lvmconf[] = "global/cache_disabled_features";
-	static unsigned _attrs = 0;
+	uint32_t maj, min, patchlevel;
 	static int _cache_checked = 0;
 	static int _cache_present = 0;
-	uint32_t maj, min, patchlevel;
-	unsigned i;
-	const struct dm_config_node *cn;
-	const struct dm_config_value *cv;
-	const char *str;
 
 	if (!_cache_checked) {
 		_cache_present = target_present(cmd, "cache", 1);
@@ -206,53 +176,11 @@ static int _target_present(struct cmd_context *cmd,
 
 		if ((maj < 1) ||
 		    ((maj == 1) && (min < 3))) {
-			_cache_present = 0;
-			log_error("The cache kernel module is version %u.%u.%u. "
-				  "Version 1.3.0+ is required.",
+			log_error("The cache kernel module is version %u.%u.%u."
+				  "  Version 1.3.0+ is required.",
 				  maj, min, patchlevel);
 			return 0;
 		}
-
-
-		for (i = 0; i < DM_ARRAY_SIZE(_features); ++i) {
-			if (((maj > _features[i].maj) ||
-			     (maj == _features[i].maj && min >= _features[i].min)) &&
-			    (!_features[i].module[0] || module_present(cmd, _features[i].module)))
-				_attrs |= _features[i].cache_feature;
-			else
-				log_very_verbose("Target %s does not support %s.",
-						 _cache_module, _features[i].feature);
-		}
-	}
-
-	if (attributes) {
-		if (!_feature_mask) {
-			/* Support runtime lvm.conf changes, N.B. avoid 32 feature */
-			if ((cn = find_config_tree_array(cmd, global_cache_disabled_features_CFG, NULL))) {
-				for (cv = cn->v; cv; cv = cv->next) {
-					if (cv->type != DM_CFG_STRING) {
-						log_error("Ignoring invalid string in config file %s.",
-							  _lvmconf);
-						continue;
-					}
-					str = cv->v.str;
-					if (!*str)
-						continue;
-					for (i = 0; i < DM_ARRAY_SIZE(_features); ++i)
-						if (strcasecmp(str, _features[i].feature) == 0)
-							_feature_mask |= _features[i].cache_feature;
-				}
-			}
-
-			_feature_mask = ~_feature_mask;
-
-			for (i = 0; i < DM_ARRAY_SIZE(_features); ++i)
-				if ((_attrs & _features[i].cache_feature) &&
-				    !(_feature_mask & _features[i].cache_feature))
-					log_very_verbose("Target %s %s support disabled by %s",
-							 _cache_module, _features[i].feature, _lvmconf);
-		}
-		*attributes = _attrs & _feature_mask;
 	}
 
 	return _cache_present;
@@ -378,9 +306,7 @@ static int _cache_add_target_line(struct dev_manager *dm,
 					   metadata_uuid,
 					   data_uuid,
 					   origin_uuid,
-					   seg->cleaner_policy ? "cleaner" :
-						   /* undefined policy name -> likely an old "mq" */
-						   cache_pool_seg->policy_name ? : "mq",
+					   seg->cleaner_policy ? "cleaner" : cache_pool_seg->policy_name,
 					   seg->cleaner_policy ? NULL : cache_pool_seg->policy_settings,
 					   cache_pool_seg->chunk_size))
 		return_0;
@@ -420,7 +346,7 @@ int init_cache_segtypes(struct cmd_context *cmd,
 		return 0;
 	}
 
-	segtype->name = SEG_TYPE_NAME_CACHE_POOL;
+	segtype->name = "cache-pool";
 	segtype->flags = SEG_CACHE_POOL | SEG_CANNOT_BE_ZEROED | SEG_ONLY_EXCLUSIVE;
 	segtype->ops = &_cache_pool_ops;
 
@@ -434,7 +360,7 @@ int init_cache_segtypes(struct cmd_context *cmd,
 		return 0;
 	}
 
-	segtype->name = SEG_TYPE_NAME_CACHE;
+	segtype->name = "cache";
 	segtype->flags = SEG_CACHE | SEG_ONLY_EXCLUSIVE;
 	segtype->ops = &_cache_ops;
 
@@ -442,8 +368,5 @@ int init_cache_segtypes(struct cmd_context *cmd,
 		return_0;
 	log_very_verbose("Initialised segtype: %s", segtype->name);
 
-	/* Reset mask for recalc */
-	_feature_mask = 0;
-
 	return 1;
 }

lib/commands/toolcontext.c

@@ -29,6 +29,7 @@
 #include "segtype.h"
 #include "lvmcache.h"
 #include "lvmetad.h"
+#include "lvmlockd.h"
 #include "archiver.h"
 #include "lvmpolld-client.h"
 
@@ -245,10 +246,8 @@ static int _parse_debug_classes(struct cmd_context *cmd)
 	const struct dm_config_value *cv;
 	int debug_classes = 0;
 
-	if (!(cn = find_config_tree_array(cmd, log_debug_classes_CFG, NULL))) {
-		log_error(INTERNAL_ERROR "Unable to find configuration for log/debug_classes.");
-		return -1;
-	}
+	if (!(cn = find_config_tree_node(cmd, log_debug_classes_CFG, NULL)))
+		return DEFAULT_LOGGED_DEBUG_CLASSES;
 
 	for (cv = cn->v; cv; cv = cv->next) {
 		if (cv->type != DM_CFG_STRING) {
@@ -362,8 +361,7 @@ static void _init_logging(struct cmd_context *cmd)
 
 	/* Tell device-mapper about our logging */
 #ifdef DEVMAPPER_SUPPORT
-	if (!dm_log_is_non_default())
-		dm_log_with_errno_init(print_log);
+	dm_log_with_errno_init(print_log);
 #endif
 	reset_log_duplicated();
 	reset_lvm_errno(1);
@@ -416,57 +414,6 @@ static int _check_config(struct cmd_context *cmd)
 	return 1;
 }
 
-static const char *_set_time_format(struct cmd_context *cmd)
-{
-	/* Compared to strftime, we do not allow "newline" character - the %n in format. */
-	static const char *allowed_format_chars = "aAbBcCdDeFGghHIjklmMpPrRsStTuUVwWxXyYzZ%";
-	static const char *allowed_alternative_format_chars_e = "cCxXyY";
-	static const char *allowed_alternative_format_chars_o = "deHImMSuUVwWy";
-	static const char *chars_to_check;
-	const char *tf = find_config_tree_str(cmd, report_time_format_CFG, NULL);
-	const char *p_fmt;
-	size_t i;
-	char c;
-
-	if (!*tf) {
-		log_error("Configured time format is empty string.");
-		goto bad;
-	} else {
-		p_fmt = tf;
-		while ((c = *p_fmt)) {
-			if (c == '%') {
-				c = *++p_fmt;
-				if (c == 'E') {
-					c = *++p_fmt;
-					chars_to_check = allowed_alternative_format_chars_e;
-				} else if (c == 'O') {
-					c = *++p_fmt;
-					chars_to_check = allowed_alternative_format_chars_o;
-				} else
-					chars_to_check = allowed_format_chars;
-
-				for (i = 0; chars_to_check[i]; i++) {
-					if (c == chars_to_check[i])
-						break;
-				}
-				if (!chars_to_check[i])
-					goto_bad;
-			}
-			else if (isprint(c))
-				p_fmt++;
-			else {
-				log_error("Configured time format contains non-printable characters.");
-				goto bad;
-			}
-		}
-	}
-
-	return tf;
-bad:
-	log_error("Invalid time format \"%s\" supplied.", tf);
-	return NULL;
-}
-
 int process_profilable_config(struct cmd_context *cmd)
 {
 	if (!(cmd->default_settings.unit_factor =
@@ -480,8 +427,6 @@ int process_profilable_config(struct cmd_context *cmd)
 	cmd->report_binary_values_as_numeric = find_config_tree_bool(cmd, report_binary_values_as_numeric_CFG, NULL);
 	cmd->default_settings.suffix = find_config_tree_bool(cmd, global_suffix_CFG, NULL);
 	cmd->report_list_item_separator = find_config_tree_str(cmd, report_list_item_separator_CFG, NULL);
-	if (!(cmd->time_format = _set_time_format(cmd)))
-		return 0;
 
 	return 1;
 }
@@ -533,7 +478,12 @@ static int _process_config(struct cmd_context *cmd)
 	const struct dm_config_node *cn;
 	const struct dm_config_value *cv;
 	int64_t pv_min_kb;
+	const char *lvmetad_socket;
+	const char *lvmpolld_socket;
+	const char *lvmlockd_socket;
 	int udev_disabled = 0;
+	int locking_type;
+	int use_lvmlockd;
 	char sysfs_dir[PATH_MAX];
 
 	if (!_check_config(cmd))
@@ -653,7 +603,7 @@ static int _process_config(struct cmd_context *cmd)
 		}
 	}
 
-	if ((cn = find_config_tree_array(cmd, activation_mlock_filter_CFG, NULL)))
+	if ((cn = find_config_tree_node(cmd, activation_mlock_filter_CFG, NULL)))
 		for (cv = cn->v; cv; cv = cv->next) 
 			if ((cv->type != DM_CFG_STRING) || !cv->v.str[0]) 
 				log_error("Ignoring invalid activation/mlock_filter entry in config file");
@@ -675,9 +625,68 @@ static int _process_config(struct cmd_context *cmd)
 	init_detect_internal_vg_cache_corruption
 		(find_config_tree_bool(cmd, global_detect_internal_vg_cache_corruption_CFG, NULL));
 
+	lvmetad_disconnect();
+	lvmpolld_disconnect();
+
+	lvmetad_socket = getenv("LVM_LVMETAD_SOCKET");
+	if (!lvmetad_socket)
+		lvmetad_socket = DEFAULT_RUN_DIR "/lvmetad.socket";
+
+	/* TODO?
+		lvmetad_socket = find_config_tree_str(cmd, "lvmetad/socket_path",
+						      DEFAULT_RUN_DIR "/lvmetad.socket");
+	*/
+	lvmetad_set_socket(lvmetad_socket);
+	cn = find_config_tree_node(cmd, devices_global_filter_CFG, NULL);
+	lvmetad_set_token(cn ? cn->v : NULL);
+
+	if (find_config_tree_int(cmd, global_locking_type_CFG, NULL) == 3 &&
+	    find_config_tree_bool(cmd, global_use_lvmetad_CFG, NULL)) {
+		log_warn("WARNING: configuration setting use_lvmetad overridden to 0 due to locking_type 3. "
+			 "Clustered environment not supported by lvmetad yet.");
+		lvmetad_set_active(NULL, 0);
+	} else
+		lvmetad_set_active(NULL, find_config_tree_bool(cmd, global_use_lvmetad_CFG, NULL));
+
+	lvmetad_init(cmd);
+
 	if (!_init_system_id(cmd))
 		return_0;
 
+	lvmpolld_socket = getenv("LVM_LVMPOLLD_SOCKET");
+	if (!lvmpolld_socket)
+		lvmpolld_socket = DEFAULT_RUN_DIR "/lvmpolld.socket";
+	lvmpolld_set_socket(lvmpolld_socket);
+
+	lvmpolld_set_active(find_config_tree_bool(cmd, global_use_lvmpolld_CFG, NULL));
+
+	/*
+	 * clvmd and lvmlockd cannot be used concurrently, it is
+	 * one or the other.
+	 * global/locking_type=3 is the clvmd configuration.
+	 * global/use_lvmlockd=1 is the lvmlockd configuration.
+	 *
+	 * use_lvmlockd should be combined with locking_type 1 (local).
+	 */
+
+	locking_type = find_config_tree_int(cmd, global_locking_type_CFG, NULL);
+	use_lvmlockd = find_config_tree_bool(cmd, global_use_lvmlockd_CFG, NULL);
+
+	if (locking_type == 3 && use_lvmlockd) {
+		log_error("ERROR: configuration setting use_lvmlockd cannot be used with locking_type 3.");
+		return 0;
+	}
+
+	lvmlockd_disconnect(); /* start over when tool context is refreshed */
+	lvmlockd_socket = getenv("LVM_LVMLOCKD_SOCKET");
+	if (!lvmlockd_socket)
+		lvmlockd_socket = DEFAULT_RUN_DIR "/lvmlockd.socket";
+
+	lvmlockd_set_socket(lvmlockd_socket);
+	lvmlockd_set_use(use_lvmlockd);
+	if (use_lvmlockd)
+		lvmlockd_init(cmd);
+
 	return 1;
 }
 
@@ -984,9 +993,15 @@ static int _init_dev_cache(struct cmd_context *cmd)
 
 	init_obtain_device_list_from_udev(device_list_from_udev);
 
-	if (!(cn = find_config_tree_array(cmd, devices_scan_CFG, NULL))) {
-		log_error(INTERNAL_ERROR "Unable to find configuration for devices/scan.");
-		return_0;
+	if (!(cn = find_config_tree_node(cmd, devices_scan_CFG, NULL))) {
+		if (!dev_cache_add_dir("/dev")) {
+			log_error("Failed to add /dev to internal "
+				  "device cache");
+			return 0;
+		}
+		log_verbose("device/scan not in config file: "
+			    "Defaulting to /dev");
+		return 1;
 	}
 
 	for (cv = cn->v; cv; cv = cv->next) {
@@ -1024,7 +1039,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
 		}
 	}
 
-	if (!(cn = find_config_tree_array(cmd, devices_loopfiles_CFG, NULL)))
+	if (!(cn = find_config_tree_node(cmd, devices_loopfiles_CFG, NULL)))
 		return 1;
 
 	for (cv = cn->v; cv; cv = cv->next) {
@@ -1070,7 +1085,7 @@ static struct dev_filter *_init_lvmetad_filter_chain(struct cmd_context *cmd)
 			nr_filt++;
 	}
 
-	/* global regex filter. Optional. */
+	/* regex filter. Optional. */
 	if ((cn = find_config_tree_node(cmd, devices_global_filter_CFG, NULL))) {
 		if (!(filters[nr_filt] = regex_filter_create(cn->v))) {
 			log_error("Failed to create global regex device filter");
@@ -1079,17 +1094,6 @@ static struct dev_filter *_init_lvmetad_filter_chain(struct cmd_context *cmd)
 		nr_filt++;
 	}
 
-	/* regex filter. Optional. */
-	if (!lvmetad_used()) {
-		if ((cn = find_config_tree_node(cmd, devices_filter_CFG, NULL))) {
-			if (!(filters[nr_filt] = regex_filter_create(cn->v))) {
-				log_error("Failed to create regex device filter");
-				goto bad;
-			}
-			nr_filt++;
-		}
-	}
-
 	/* device type filter. Required. */
 	if (!(filters[nr_filt] = lvm_type_filter_create(cmd->dev_types))) {
 		log_error("Failed to create lvm type filter");
@@ -1157,33 +1161,30 @@ bad:
  *     md component filter -> fw raid filter
  *
  *   - cmd->filter - the filter chain used for lvmetad responses:
- *     persistent filter -> regex_filter -> usable device filter(FILTER_MODE_POST_LVMETAD)
+ *     persistent filter -> usable device filter(FILTER_MODE_POST_LVMETAD) ->
+ *     regex filter
  *
  *   - cmd->full_filter - the filter chain used for all the remaining situations:
- *     cmd->lvmetad_filter -> cmd->filter
+ *     lvmetad_filter -> filter
  *
- * If lvmetad is not used, there's just one filter chain:
+ * If lvmetad isnot used, there's just one filter chain:
  *
  *   - cmd->filter == cmd->full_filter:
- *     persistent filter -> sysfs filter -> global regex filter ->
- *     regex_filter -> type filter -> usable device filter(FILTER_MODE_NO_LVMETAD) ->
- *     mpath component filter -> partitioned filter -> md component filter -> fw raid filter
+ *     persistent filter -> regex filter -> sysfs filter ->
+ *     global regex filter -> type filter ->
+ *     usable device filter(FILTER_MODE_NO_LVMETAD) ->
+ *     mpath component filter -> partitioned filter ->
+ *     md component filter -> fw raid filter
  *
  */
-int init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
+static int _init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
 {
 	const char *dev_cache;
 	struct dev_filter *filter = NULL, *filter_components[2] = {0};
-	int nr_filt;
 	struct stat st;
 	const struct dm_config_node *cn;
 	struct timespec ts, cts;
 
-	if (!cmd->initialized.connections) {
-		log_error(INTERNAL_ERROR "connections must be initialized before filters");
-		return 0;
-	}
-
 	cmd->dump_filter = 0;
 
 	cmd->lvmetad_filter = _init_lvmetad_filter_chain(cmd);
@@ -1203,26 +1204,26 @@ int init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
 	 */
 	/* filter component 0 */
 	if (lvmetad_used()) {
-		nr_filt = 0;
-		if ((cn = find_config_tree_array(cmd, devices_filter_CFG, NULL))) {
-			if (!(filter_components[nr_filt] = regex_filter_create(cn->v))) {
-				log_verbose("Failed to create regex device filter.");
-				goto bad;
-			}
-			nr_filt++;
-		}
-		if (!(filter_components[nr_filt] = usable_filter_create(cmd->dev_types, FILTER_MODE_POST_LVMETAD))) {
+		if (!(filter_components[0] = usable_filter_create(cmd->dev_types, FILTER_MODE_POST_LVMETAD))) {
 			log_verbose("Failed to create usable device filter.");
 			goto bad;
 		}
-		nr_filt++;
-		if (!(filter = composite_filter_create(nr_filt, 0, filter_components)))
-			goto_bad;
 	} else {
-		filter = cmd->lvmetad_filter;
+		filter_components[0] = cmd->lvmetad_filter;
 		cmd->lvmetad_filter = NULL;
 	}
 
+	/* filter component 1 */
+	if ((cn = find_config_tree_node(cmd, devices_filter_CFG, NULL))) {
+		if (!(filter_components[1] = regex_filter_create(cn->v)))
+			goto_bad;
+		/* we have two filter components - create composite filter */
+		if (!(filter = composite_filter_create(2, 0, filter_components)))
+			goto_bad;
+	} else
+		/* we have only one filter component - no need to create composite filter */
+		filter = filter_components[0];
+
 	if (!(dev_cache = find_config_tree_str(cmd, devices_cache_CFG, NULL)))
 		goto_bad;
 
@@ -1234,12 +1235,9 @@ int init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
 	cmd->filter = filter;
 
 	if (lvmetad_used()) {
-		nr_filt = 0;
-		filter_components[nr_filt] = cmd->lvmetad_filter;
-		nr_filt++;
-		filter_components[nr_filt] = cmd->filter;
-		nr_filt++;
-		if (!(cmd->full_filter = composite_filter_create(nr_filt, 0, filter_components)))
+		filter_components[0] = cmd->lvmetad_filter;
+		filter_components[1] = cmd->filter;
+		if (!(cmd->full_filter = composite_filter_create(2, 0, filter_components)))
 			goto_bad;
 	} else
 		cmd->full_filter = filter;
@@ -1267,7 +1265,6 @@ int init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
 				    dev_cache);
 	}
 
-	cmd->initialized.filters = 1;
 	return 1;
 bad:
 	if (!filter) {
@@ -1291,7 +1288,6 @@ bad:
 	if (cmd->lvmetad_filter)
 		cmd->lvmetad_filter->destroy(cmd->lvmetad_filter);
 
-	cmd->initialized.filters = 0;
 	return 0;
 }
 
@@ -1335,7 +1331,7 @@ static int _init_formats(struct cmd_context *cmd)
 #ifdef HAVE_LIBDL
 	/* Load any formats in shared libs if not static */
 	if (!is_static() &&
-	    (cn = find_config_tree_array(cmd, global_format_libraries_CFG, NULL))) {
+	    (cn = find_config_tree_node(cmd, global_format_libraries_CFG, NULL))) {
 
 		const struct dm_config_value *cv;
 		struct format_type *(*init_format_fn) (struct cmd_context *);
@@ -1501,7 +1497,7 @@ static int _init_segtypes(struct cmd_context *cmd)
 #ifdef HAVE_LIBDL
 	/* Load any formats in shared libs unless static */
 	if (!is_static() &&
-	    (cn = find_config_tree_array(cmd, global_segment_libraries_CFG, NULL))) {
+	    (cn = find_config_tree_node(cmd, global_segment_libraries_CFG, NULL))) {
 
 		const struct dm_config_value *cv;
 		int (*init_multiple_segtypes_fn) (struct cmd_context *,
@@ -1665,80 +1661,11 @@ static int _reopen_stream(FILE *stream, int fd, const char *mode, const char *na
 	return 1;
 }
 
-static int _init_lvmetad(struct cmd_context *cmd)
-{
-	const struct dm_config_node *cn;
-	const char *lvmetad_socket;
-
-	lvmetad_disconnect();
-
-	lvmetad_socket = getenv("LVM_LVMETAD_SOCKET");
-	if (!lvmetad_socket)
-		lvmetad_socket = DEFAULT_RUN_DIR "/lvmetad.socket";
-
-	/* TODO?
-		lvmetad_socket = find_config_tree_str(cmd, "lvmetad/socket_path",
-						      DEFAULT_RUN_DIR "/lvmetad.socket");
-	*/
-
-	lvmetad_set_socket(lvmetad_socket);
-	cn = find_config_tree_array(cmd, devices_global_filter_CFG, NULL);
-	lvmetad_set_token(cn ? cn->v : NULL);
-
-	if (find_config_tree_int(cmd, global_locking_type_CFG, NULL) == 3 &&
-	    find_config_tree_bool(cmd, global_use_lvmetad_CFG, NULL)) {
-		log_warn("WARNING: configuration setting use_lvmetad overridden to 0 due to locking_type 3. "
-			 "Clustered environment not supported by lvmetad yet.");
-		lvmetad_set_active(NULL, 0);
-	} else
-		lvmetad_set_active(NULL, find_config_tree_bool(cmd, global_use_lvmetad_CFG, NULL));
-
-	lvmetad_init(cmd);
-	return 1;
-}
-
-static int _init_lvmpolld(struct cmd_context *cmd)
-{
-	const char *lvmpolld_socket;
-
-	lvmpolld_disconnect();
-
-	lvmpolld_socket = getenv("LVM_LVMPOLLD_SOCKET");
-	if (!lvmpolld_socket)
-		lvmpolld_socket = DEFAULT_RUN_DIR "/lvmpolld.socket";
-	lvmpolld_set_socket(lvmpolld_socket);
-
-	lvmpolld_set_active(find_config_tree_bool(cmd, global_use_lvmpolld_CFG, NULL));
-	return 1;
-}
-
-int init_connections(struct cmd_context *cmd)
-{
-
-	if (!_init_lvmetad(cmd)) {
-		log_error("Failed to initialize lvmetad connection.");
-		goto bad;
-	}
-
-	if (!_init_lvmpolld(cmd)) {
-		log_error("Failed to initialize lvmpolld connection.");
-		goto bad;
-	}
-
-	cmd->initialized.connections = 1;
-	return 1;
-bad:
-	cmd->initialized.connections = 0;
-	return 0;
-}
-
 /* Entry point */
 struct cmd_context *create_toolcontext(unsigned is_long_lived,
 				       const char *system_dir,
 				       unsigned set_buffering,
-				       unsigned threaded,
-				       unsigned set_connections,
-				       unsigned set_filters)
+				       unsigned threaded)
 {
 	struct cmd_context *cmd;
 	FILE *new_stream;
@@ -1876,12 +1803,15 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 		goto_out;
 
 	if (!(cmd->dev_types = create_dev_types(cmd->proc_dir,
-						find_config_tree_array(cmd, devices_types_CFG, NULL))))
+						find_config_tree_node(cmd, devices_types_CFG, NULL))))
 		goto_out;
 
 	if (!_init_dev_cache(cmd))
 		goto_out;
 
+	if (!_init_filters(cmd, 1))
+		goto_out;
+
 	memlock_init(cmd);
 
 	if (!_init_formats(cmd))
@@ -1900,18 +1830,12 @@ struct cmd_context *create_toolcontext(unsigned is_long_lived,
 
 	_init_globals(cmd);
 
-	if (set_connections && !init_connections(cmd))
-		return_0;
-
-	if (set_filters && !init_filters(cmd, 1))
-		goto_out;
-
 	cmd->default_settings.cache_vgmetadata = 1;
 	cmd->current_settings = cmd->default_settings;
 
-	cmd->initialized.config = 1;
+	cmd->config_initialized = 1;
 out:
-	if (!cmd->initialized.config) {
+	if (!cmd->config_initialized) {
 		destroy_toolcontext(cmd);
 		cmd = NULL;
 	}
@@ -1983,19 +1907,14 @@ static void _destroy_filters(struct cmd_context *cmd)
 		cmd->full_filter->destroy(cmd->full_filter);
 		cmd->lvmetad_filter = cmd->filter = cmd->full_filter = NULL;
 	}
-	cmd->initialized.filters = 0;
 }
 
 int refresh_filters(struct cmd_context *cmd)
 {
 	int r, saved_ignore_suspended_devices = ignore_suspended_devices();
 
-	if (!cmd->initialized.filters)
-		/* if filters not initialized, there's nothing to refresh */
-		return 1;
-
 	_destroy_filters(cmd);
-	if (!(r = init_filters(cmd, 0)))
+	if (!(r = _init_filters(cmd, 0)))
                 stack;
 
 	/*
@@ -2024,6 +1943,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
 	label_exit();
 	_destroy_segtypes(&cmd->segtypes);
 	_destroy_formats(cmd, &cmd->formats);
+	_destroy_filters(cmd);
 
 	if (!dev_cache_exit())
 		stack;
@@ -2041,7 +1961,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
 
 	_destroy_config(cmd);
 
-	cmd->initialized.config = 0;
+	cmd->config_initialized = 0;
 
 	cmd->hosttags = 0;
 
@@ -2098,12 +2018,15 @@ int refresh_toolcontext(struct cmd_context *cmd)
 		return_0;
 
 	if (!(cmd->dev_types = create_dev_types(cmd->proc_dir,
-						find_config_tree_array(cmd, devices_types_CFG, NULL))))
+						find_config_tree_node(cmd, devices_types_CFG, NULL))))
 		return_0;
 
 	if (!_init_dev_cache(cmd))
 		return_0;
 
+	if (!_init_filters(cmd, 0))
+		return_0;
+
 	if (!_init_formats(cmd))
 		return_0;
 
@@ -2116,13 +2039,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
 	if (!_init_backup(cmd))
 		return_0;
 
-	cmd->initialized.config = 1;
-
-	if (cmd->initialized.connections && !init_connections(cmd))
-		return_0;
-
-	if (!refresh_filters(cmd))
-		return_0;
+	cmd->config_initialized = 1;
 
 	reset_lvm_errno(1);
 	return 1;
@@ -2189,6 +2106,7 @@ void destroy_toolcontext(struct cmd_context *cmd)
 #endif
 	dm_free(cmd);
 
+	lvmlockd_disconnect();
 	lvmetad_release_token();
 	lvmetad_disconnect();
 	lvmpolld_disconnect();

lib/commands/toolcontext.h

@@ -60,59 +60,29 @@ struct config_tree_list {
 	struct dm_config_tree *cft;
 };
 
-struct cmd_context_initialized_parts {
-	unsigned config:1; /* used to reinitialize config if previous init was not successful */
-	unsigned filters:1;
-	unsigned connections:1;
-};
-
 /* FIXME Split into tool & library contexts */
 /* command-instance-related variables needed by library */
 struct cmd_context {
-	/*
-	 * Memory handlers.
-	 */
-	struct dm_pool *libmem;			/* for permanent config data */
-	struct dm_pool *mem;			/* transient: cleared between each command */
+	struct dm_pool *libmem;	/* For permanent config data */
+	struct dm_pool *mem;	/* Transient: Cleared between each command */
 
-	/*
-	 * Command line and arguments.
-	 */
+	const struct format_type *fmt;	/* Current format to use by default */
+	struct format_type *fmt_backup;	/* Format to use for backups */
+
+	struct dm_list formats;	/* Available formats */
+	struct dm_list segtypes;	/* Available segment types */
+	const char *system_id;
+	const char *hostname;
+	const char *kernel_vsn;
+
+	unsigned rand_seed;
+	char *linebuffer;
 	const char *cmd_line;
 	struct command *command;
 	char **argv;
 	struct arg_values *arg_values;
 	struct dm_list arg_value_groups;
-
-	/*
-	 * Format handlers.
-	 */
-	const struct format_type *fmt;		/* current format to use by default */
-	struct format_type *fmt_backup;		/* format to use for backups */
-	struct dm_list formats;			/* available formats */
-	struct dm_list segtypes;		/* available segment types */
-
-	/*
-	 * Machine and system identification.
-	 */
-	const char *system_id;
-	const char *hostname;
-	const char *kernel_vsn;
-
-	/*
-	 * Device identification.
-	 */
-	struct dev_types *dev_types;		/* recognized extra device types. */
-
-	/*
-	 * Initialization state.
-	 */
-	struct cmd_context_initialized_parts initialized;
-
-	/*
-	 * Switches.
-	 */
-	unsigned is_long_lived:1;		/* optimises persistent_filter handling */
+	unsigned is_long_lived:1;	/* Optimises persistent_filter handling */
 	unsigned handles_missing_pvs:1;
 	unsigned handles_unknown_segments:1;
 	unsigned use_linear_target:1;
@@ -123,73 +93,69 @@ struct cmd_context {
 	unsigned report_binary_values_as_numeric:1;
 	unsigned metadata_read_only:1;
 	unsigned ignore_clustered_vgs:1;
-	unsigned threaded:1;			/* set if running within a thread e.g. clvmd */
-	unsigned independent_metadata_areas:1;	/* active formats have MDAs outside PVs */
+	unsigned threaded:1;		/* Set if running within a thread e.g. clvmd */
+
+	unsigned independent_metadata_areas:1;	/* Active formats have MDAs outside PVs */
 	unsigned unknown_system_id:1;
-	unsigned include_foreign_vgs:1;		/* report/display cmds can reveal foreign VGs */
-	unsigned include_shared_vgs:1;		/* report/display cmds can reveal lockd VGs */
-	unsigned include_active_foreign_vgs:1;	/* cmd should process foreign VGs with active LVs */
-	unsigned vg_read_print_access_error:1;	/* print access errors from vg_read */
-	unsigned lockd_gl_disable:1;
+	unsigned include_foreign_vgs:1;
+	unsigned include_active_foreign_vgs:1;
+	unsigned error_foreign_vgs:1;
 	unsigned lockd_vg_disable:1;
 	unsigned lockd_lv_disable:1;
-	unsigned lockd_gl_removed:1;
-	unsigned lockd_vg_rescan:1;
 	unsigned lockd_vg_default_sh:1;
-	unsigned lockd_vg_enforce_sh:1;
+
+	struct dev_types *dev_types;
 
 	/*
-	 * Filtering.
+	 * Use of filters depends on whether lvmetad is used or not:
+	 *
+	 *   - if lvmetad is used:
+	 *   	- cmd->lvmetad_filter used when scanning devices for lvmetad
+	 *   	- cmd->filter used when processing lvmetad responses
+	 *   	- cmd->full_filter used for remaining situations
+	 *
+	 *   - if lvmetad is not used:
+	 *   	- cmd->lvmetad_filter is NULL
+	 *   	- cmd->filter == cmd->full_filter used for all situations
+	 *
 	 */
-	struct dev_filter *lvmetad_filter;	/* pre-lvmetad filter chain */
-	struct dev_filter *filter;		/* post-lvmetad filter chain */
-	struct dev_filter *full_filter;		/* lvmetad_filter + filter */
-	int dump_filter;			/* Dump filter when exiting? */
+	struct dev_filter *lvmetad_filter;
+	struct dev_filter *filter;
+	struct dev_filter *full_filter;
+	int dump_filter;	/* Dump filter when exiting? */
 
-	/*
-	 * Configuration.
-	 */
-	struct dm_list config_files; 		/* master lvm config + any existing tag configs */
-	struct profile_params *profile_params;	/* profile handling params including loaded profile configs */
-	struct dm_config_tree *cft;		/* the whole cascade: CONFIG_STRING -> CONFIG_PROFILE -> CONFIG_FILE/CONFIG_MERGED_FILES */
-	struct dm_hash_table *cft_def_hash;	/* config definition hash used for validity check (item type + item recognized) */
-	struct config_info default_settings;	/* selected settings with original default/configured value which can be changed during cmd processing */
-	struct config_info current_settings; 	/* may contain changed values compared to default_settings */
+	struct dm_list config_files; /* master lvm config + any existing tag configs */
+	struct profile_params *profile_params; /* profile handling params including loaded profile configs */
+	struct dm_config_tree *cft; /* the whole cascade: CONFIG_STRING -> CONFIG_PROFILE -> CONFIG_FILE/CONFIG_MERGED_FILES */
+	int config_initialized; /* used to reinitialize config if previous init was not successful */
+
+	struct dm_hash_table *cft_def_hash; /* config definition hash used for validity check (item type + item recognized) */
+
+	/* selected settings with original default/configured value which can be changed during cmd processing */
+	struct config_info default_settings;
+	/* may contain changed values compared to default_settings */
+	struct config_info current_settings;
 
-	/*
-	 * Archives and backups.
-	 */
 	struct archive_params *archive_params;
 	struct backup_params *backup_params;
 	const char *stripe_filler;
 
-	/*
-	 * Host tags.
-	 */
-	struct dm_list tags;			/* list of defined tags */
+	/* List of defined tags */
+	struct dm_list tags;
+	const char *report_list_item_separator;
 	int hosttags;
 
-	/*
-	 * Paths.
-	 */
-	const char *lib_dir;			/* cache value global/library_dir */
+	/* Locking */
+	const char *lock_gl_mode; /* gl mode, from --lock-gl */
+	const char *lock_vg_mode; /* vg mode, from --lock-vg */
+	const char *lock_lv_mode; /* lv mode, from --lock-lv */
+
+	const char *lib_dir;		/* Cache value global/library_dir */
 	char system_dir[PATH_MAX];
 	char dev_dir[PATH_MAX];
 	char proc_dir[PATH_MAX];
-
-	/*
-	 * Buffers.
-	 */
-	char display_buffer[NAME_LEN * 10];	/* ring buffer for upto 10 longest vg/lv names */
-	unsigned display_lvname_idx;		/* index to ring buffer */
-	char *linebuffer;
-
-	/*
-	 * Others - unsorted.
-	 */
-	const char *report_list_item_separator;
-	const char *time_format;
-	unsigned rand_seed;
+	char display_buffer[NAME_LEN * 10];	/* Ring buffer for upto 10 longest vg/lv names */
+	unsigned display_lvname_idx;		/* Index to ring buffer */
 };
 
 /*
@@ -199,17 +165,13 @@ struct cmd_context {
 struct cmd_context *create_toolcontext(unsigned is_long_lived,
 				       const char *system_dir,
 				       unsigned set_buffering,
-				       unsigned threaded,
-				       unsigned set_connections,
-				       unsigned set_filters);
+				       unsigned threaded);
 void destroy_toolcontext(struct cmd_context *cmd);
 int refresh_toolcontext(struct cmd_context *cmd);
 int refresh_filters(struct cmd_context *cmd);
 int process_profilable_config(struct cmd_context *cmd);
 int config_files_changed(struct cmd_context *cmd);
 int init_lvmcache_orphans(struct cmd_context *cmd);
-int init_filters(struct cmd_context *cmd, unsigned load_persistent_cache);
-int init_connections(struct cmd_context *cmd);
 
 struct format_type *get_format_by_name(struct cmd_context *cmd, const char *format);
 

lib/config/config.c

@@ -581,11 +581,8 @@ int config_file_read(struct dm_config_tree *cft)
 		if (!(cf->dev = dev_create_file(filename, NULL, NULL, 1)))
 			return_0;
 
-		if (!dev_open_readonly_buffered(cf->dev)) {
-			dev_destroy_file(cf->dev);
-			cf->dev = NULL;
+		if (!dev_open_readonly_buffered(cf->dev))
 			return_0;
-		}
 	}
 
 	r = config_file_read_fd(cft, cf->dev, 0, (size_t) info.st_size, 0, 0,
@@ -669,18 +666,14 @@ static void _log_type_error(const char *path, cfg_def_type_t actual,
 					     actual_type_name, expected_type_name);
 }
 
-static struct dm_config_value *_get_def_array_values(struct cmd_context *cmd,
-						     struct dm_config_tree *cft,
+static struct dm_config_value *_get_def_array_values(struct dm_config_tree *cft,
 						     const cfg_def_item_t *def,
 						     uint32_t format_flags)
 {
-	const char *def_enc_value;
 	char *enc_value, *token, *p, *r;
 	struct dm_config_value *array = NULL, *v = NULL, *oldv = NULL;
 
-	def_enc_value = cfg_def_get_default_value(cmd, def, CFG_TYPE_ARRAY, NULL);
-
-	if (!def_enc_value) {
+	if (!def->default_value.v_CFG_TYPE_STRING) {
 		if (!(array = dm_config_create_value(cft))) {
 			log_error("Failed to create default empty array for %s.", def->name);
 			return NULL;
@@ -690,7 +683,7 @@ static struct dm_config_value *_get_def_array_values(struct cmd_context *cmd,
 		return array;
 	}
 
-	if (!(p = token = enc_value = dm_strdup(def_enc_value))) {
+	if (!(p = token = enc_value = dm_strdup(def->default_value.v_CFG_TYPE_STRING))) {
 		log_error("_get_def_array_values: dm_strdup failed");
 		return NULL;
 	}
@@ -851,7 +844,7 @@ static int _check_value_differs_from_default(struct cft_check_handle *handle,
 	}
 
 	if (!v_def && (def->type & CFG_TYPE_ARRAY)) {
-		if (!(v_def_array = v_def_iter = _get_def_array_values(handle->cmd, handle->cft, def, 0)))
+		if (!(v_def_array = v_def_iter = _get_def_array_values(handle->cft, def, 0)))
 			return_0;
 		do {
 			/* iterate over each element of the array and check its value */
@@ -1043,14 +1036,9 @@ static int _config_def_check_tree(struct cft_check_handle *handle,
 				  size_t buf_size, struct dm_config_node *root)
 {
 	struct dm_config_node *cn;
-	cfg_def_item_t *def;
 	int valid, r = 1;
 	size_t len;
 
-	def = cfg_def_get_item_p(root->id);
-	if (def->flags & CFG_SECTION_NO_CHECK)
-		return 1;
-
 	for (cn = root->child; cn; cn = cn->sib) {
 		if ((valid = _config_def_check_node(handle, vp, pvp, rp, prp,
 						    buf_size, cn)) && !cn->v) {
@@ -1372,106 +1360,6 @@ int find_config_tree_bool(struct cmd_context *cmd, int id, struct profile *profi
 	return b;
 }
 
-static struct dm_config_node *_get_array_def_node(struct cmd_context *cmd,
-						  cfg_def_item_t *def,
-						  struct profile *profile)
-{
-	struct dm_config_node *cn;
-
-	if (def->flags & CFG_DEFAULT_UNDEFINED)
-		return NULL;
-
-	if (!(cn = dm_config_create_node(cmd->cft, def->name))) {
-		log_error("Failed to create default array node for %s.", def->name);
-		return NULL;
-	}
-
-	if (!(cn->v = _get_def_array_values(cmd, cmd->cft, def, 0))) {
-		dm_pool_free(cmd->cft->mem, cn);
-		return_NULL;
-	}
-
-	return cn;
-}
-
-struct _config_array_out_handle {
-	struct dm_pool *mem;
-	char *str;
-};
-
-static int _config_array_line(const struct dm_config_node *cn, const char *line, void *baton)
-{
-	struct _config_array_out_handle *handle = (struct _config_array_out_handle *) baton;
-
-	if (!(handle->str = dm_pool_strdup(handle->mem, line))) {
-		log_error("_config_array_line: dm_pool_strdup failed");
-		return 0;
-	}
-
-	return 1;
-}
-
-static void _log_array_value_used(struct dm_pool *mem, const struct dm_config_node *cn,
-				  const char *path, int default_used)
-{
-	struct _config_array_out_handle out_handle = { 0 };
-	struct dm_config_node_out_spec out_spec = { 0 };
-	uint32_t old_format_flags;
-
-	out_handle.mem = mem;
-	out_spec.line_fn = _config_array_line;
-
-	old_format_flags = dm_config_value_get_format_flags(cn->v);
-	dm_config_value_set_format_flags(cn->v,
-		DM_CONFIG_VALUE_FMT_COMMON_EXTRA_SPACES |
-		DM_CONFIG_VALUE_FMT_COMMON_ARRAY);
-
-	if (!dm_config_write_one_node_out(cn, &out_spec, &out_handle)) {
-		log_error("_log_array_value_used: failed to write node value");
-		out_handle.mem = NULL;
-	}
-
-	if (default_used)
-		log_very_verbose("%s not found in config: defaulting to %s",
-				 path, out_handle.mem ? out_handle.str : "<unknown>");
-	else
-		log_very_verbose("Setting %s to %s",
-				 path, out_handle.mem ? out_handle.str : "<unknown>");
-
-	if (out_handle.mem)
-		dm_pool_free(out_handle.mem, out_handle.str);
-	dm_config_value_set_format_flags(cn->v, old_format_flags);
-}
-
-const struct dm_config_node *find_config_tree_array(struct cmd_context *cmd, int id, struct profile *profile)
-{
-	cfg_def_item_t *item = cfg_def_get_item_p(id);
-	char path[CFG_PATH_MAX_LEN];
-	int profile_applied;
-	const struct dm_config_node *cn = NULL, *cn_def = NULL;
-	profile_applied = _apply_local_profile(cmd, profile);
-	_cfg_def_make_path(path, sizeof(path), item->id, item, 0);
-
-	if (!(item->type & CFG_TYPE_ARRAY))
-		log_error(INTERNAL_ERROR "%s cfg tree element not declared as array.", path);
-
-	if (_config_disabled(cmd, item, path) ||
-	    !(cn = find_config_tree_node(cmd, id, profile)))
-		cn_def = _get_array_def_node(cmd, item, profile);
-
-	if (cn)
-		_log_array_value_used(cmd->cft->mem, cn, path, 0);
-	else if (cn_def) {
-		_log_array_value_used(cmd->cft->mem, cn_def, path, 1);
-		cn = cn_def;
-	}
-
-	if (profile_applied)
-		remove_config_tree_by_source(cmd, profile->source);
-
-	return cn;
-}
-
 /* Insert cn2 after cn1 */
 static void _insert_config_node(struct dm_config_node **cn1,
 				struct dm_config_node *cn2)
@@ -1670,9 +1558,14 @@ static int _out_prefix_fn(const struct dm_config_node *cn, const char *line, voi
 	char path[CFG_PATH_MAX_LEN];
 	char commentline[MAX_COMMENT_LINE+1];
 
-	if (cn->id <= 0)
+	if (cn->id < 0)
 		return 1;
 
+	if (!cn->id) {
+		log_error(INTERNAL_ERROR "Configuration node %s has invalid id.", cn->key);
+		return 0;
+	}
+
 	if (out->tree_spec->type == CFG_DEF_TREE_LIST)
 		return 1;
 
@@ -1694,11 +1587,6 @@ static int _out_prefix_fn(const struct dm_config_node *cn, const char *line, voi
 		if (cfg_def->comment) {
 			int pos = 0;
 			while (_copy_one_line(cfg_def->comment, commentline, &pos, strlen(cfg_def->comment))) {
-				if ((commentline[0] == '#') && (strlen(commentline) == 1)) {
-					if (!out->tree_spec->withspaces)
-						continue;
-					commentline[0] = '\0';
-				}
 				fprintf(out->fp, "%s# %s\n", line, commentline);
 				/* withsummary prints only the first comment line. */
 				if (!out->tree_spec->withcomments)
@@ -1720,13 +1608,6 @@ static int _out_prefix_fn(const struct dm_config_node *cn, const char *line, voi
 
 		if (cfg_def->flags & CFG_DEFAULT_UNDEFINED)
 			fprintf(out->fp, "%s# This configuration %s does not have a default value defined.\n", line, node_type_name);
-
-		if (cfg_def->flags & CFG_DEFAULT_COMMENTED)
-			fprintf(out->fp, "%s# This configuration %s has an automatic default value.\n", line, node_type_name);
-
-		if ((out->tree_spec->type == CFG_DEF_TREE_FULL) &&
-		    (out->tree_spec->check_status[cn->id] & CFG_USED))
-			fprintf(out->fp, "%s# Value defined in existing configuration has been used for this setting.\n", line);
 	}
 
 	if (out->tree_spec->withversions) {
@@ -1744,16 +1625,6 @@ static int _out_prefix_fn(const struct dm_config_node *cn, const char *line, voi
 	return 1;
 }
 
-static int _should_print_cfg_with_undef_def_val(struct out_baton *out, cfg_def_item_t *cfg_def,
-						const struct dm_config_node *cn)
-{
-	if (!(cfg_def->flags & CFG_DEFAULT_UNDEFINED))
-		return 1;
-
-	/* print it only if the value is directly defined in some config = it's used */
-	return out->tree_spec->check_status && (out->tree_spec->check_status[cn->id] & CFG_USED);
-}
-
 static int _out_line_fn(const struct dm_config_node *cn, const char *line, void *baton)
 {
 	struct out_baton *out = baton;
@@ -1796,23 +1667,14 @@ static int _out_line_fn(const struct dm_config_node *cn, const char *line, void
 	}
 
 	/* Usual tree view with nodes and their values. */
-
 	if ((out->tree_spec->type != CFG_DEF_TREE_CURRENT) &&
 	    (out->tree_spec->type != CFG_DEF_TREE_DIFF) &&
-	    (out->tree_spec->type != CFG_DEF_TREE_FULL) &&
 	    (cfg_def->flags & (CFG_DEFAULT_UNDEFINED | CFG_DEFAULT_COMMENTED))) {
-		/* print with # at the front to comment out the line */
-		if (_should_print_cfg_with_undef_def_val(out, cfg_def, cn)) {
-			space_prefix = ((len = strspn(line, "\t "))) ? dm_pool_strndup(out->mem, line, len) : NULL;
-			fprintf(out->fp, "%s%s%s\n", space_prefix ? : "", "# ", line + len);
-			if (space_prefix)
-				dm_pool_free(out->mem, space_prefix);
-		}
-		return 1;
-	}
-
-	/* print the line as it is */
-	if (_should_print_cfg_with_undef_def_val(out, cfg_def, cn))
+		space_prefix = ((len = strspn(line, "\t "))) ? dm_pool_strndup(out->mem, line, len) : NULL;
+		fprintf(out->fp, "%s%s%s\n", space_prefix ? : "", "# ", line + len);
+		if (space_prefix)
+			dm_pool_free(out->mem, space_prefix);
+	} else
 		fprintf(out->fp, "%s\n", line);
 
 	return 1;
@@ -1941,7 +1803,7 @@ static struct dm_config_node *_add_def_node(struct dm_config_tree *cft,
 		if (spec->withspaces)
 			format_flags |= DM_CONFIG_VALUE_FMT_COMMON_EXTRA_SPACES;
 		format_flags |= DM_CONFIG_VALUE_FMT_COMMON_ARRAY;
-		cn->v = _get_def_array_values(spec->cmd, cft, def, format_flags);
+		cn->v = _get_def_array_values(cft, def, format_flags);
 	}
 
 	cn->child = NULL;
@@ -1974,8 +1836,6 @@ static int _should_skip_def_node(struct config_def_tree_spec *spec, int section_
 		return 1;
 
 	switch (spec->type) {
-		case CFG_DEF_TREE_FULL:
-			/* fall through */
 		case CFG_DEF_TREE_MISSING:
 			if (!spec->check_status) {
 				log_error_once(INTERNAL_ERROR "couldn't determine missing "
@@ -1983,12 +1843,9 @@ static int _should_skip_def_node(struct config_def_tree_spec *spec, int section_
 				return 1;
 			}
 			if ((spec->check_status[id] & CFG_USED) ||
-			    (def->flags & CFG_NAME_VARIABLE))
-				return 1;
-
-			if ((spec->type == CFG_DEF_TREE_MISSING) &&
-			    ((def->since_version > spec->version) ||
-			     _should_skip_deprecated_def_node(def, spec)))
+			    (def->flags & CFG_NAME_VARIABLE) ||
+			    (def->since_version > spec->version) ||
+			    _should_skip_deprecated_def_node(def, spec))
 				return 1;
 			break;
 		case CFG_DEF_TREE_NEW:
@@ -1997,9 +1854,7 @@ static int _should_skip_def_node(struct config_def_tree_spec *spec, int section_
 				return 1;
 			break;
 		case CFG_DEF_TREE_PROFILABLE:
-			/* fall through */
 		case CFG_DEF_TREE_PROFILABLE_CMD:
-			/* fall through */
 		case CFG_DEF_TREE_PROFILABLE_MDA:
 			if (!(def->flags & CFG_PROFILABLE) ||
 			    (def->since_version > spec->version) ||
@@ -2055,7 +1910,7 @@ bad:
 
 struct dm_config_tree *config_def_create_tree(struct config_def_tree_spec *spec)
 {
-	struct dm_config_tree *cft = NULL, *tmp_cft = NULL;
+	struct dm_config_tree *cft;
 	struct dm_config_node *root = NULL, *relay = NULL, *tmp;
 	int id;
 
@@ -2079,33 +1934,7 @@ struct dm_config_tree *config_def_create_tree(struct config_def_tree_spec *spec)
 	}
 
 	cft->root = root;
-
-	if (spec->type == CFG_DEF_TREE_FULL) {
-		if (!(tmp_cft = dm_config_create())) {
-			log_error("Failed to create temporary config tree while creating full tree.");
-			goto bad;
-		}
-
-		if (!(tmp_cft->root = dm_config_clone_node_with_mem(cft->mem, spec->current_cft->root, 1))) {
-			log_error("Failed to clone current config tree.");
-			goto bad;
-		}
-
-		if (!merge_config_tree(spec->cmd, cft, tmp_cft, CONFIG_MERGE_TYPE_RAW)) {
-			log_error("Failed to merge default and current config tree.");
-			goto bad;
-		}
-
-		dm_config_destroy(tmp_cft);
-	}
-
 	return cft;
-bad:
-	if (cft)
-		dm_config_destroy(cft);
-	if (tmp_cft)
-		dm_config_destroy(tmp_cft);
-	return NULL;
 }
 
 static int _check_profile(struct cmd_context *cmd, struct profile *profile)

lib/config/config.h

@@ -50,7 +50,7 @@ struct profile_params {
 	struct dm_list profiles;                 /* list of profiles which are loaded already and which are ready for use */
 };
 
-#define CFG_PATH_MAX_LEN 128
+#define CFG_PATH_MAX_LEN 64
 
 /*
  * Structures used for definition of a configuration tree.
@@ -121,8 +121,6 @@ typedef union {
 #define CFG_DISABLED		0x200
 /* whether to print integers in octal form (prefixed by "0") */
 #define CFG_FORMAT_INT_OCTAL	0x400
-/* whether to disable checks for the whole config section subtree */
-#define CFG_SECTION_NO_CHECK	0x800
 
 /* configuration definition item structure */
 typedef struct cfg_def_item {
@@ -143,7 +141,7 @@ typedef struct cfg_def_item {
 typedef enum {
 	CFG_DEF_TREE_CURRENT,		/* tree of nodes with values currently set in the config */
 	CFG_DEF_TREE_MISSING,		/* tree of nodes missing in current config using default values */
-	CFG_DEF_TREE_FULL,		/* CURRENT + MISSING, the tree actually used within execution */
+	CFG_DEF_TREE_COMPLETE,		/* CURRENT + MISSING, the tree actually used within execution, not implemented yet */
 	CFG_DEF_TREE_DEFAULT,		/* tree of all possible config nodes with default values */
 	CFG_DEF_TREE_NEW,		/* tree of all new nodes that appeared in given version */
 	CFG_DEF_TREE_PROFILABLE,	/* tree of all nodes that are customizable by profiles */
@@ -155,20 +153,19 @@ typedef enum {
 
 /* configuration definition tree specification */
 struct config_def_tree_spec {
-	struct cmd_context *cmd;		/* command context (for run-time defaults */
-	struct dm_config_tree *current_cft;	/* current config tree which is defined explicitly - defaults are not used */
-	cfg_def_tree_t type;			/* tree type */
-	uint16_t version;			/* tree at this LVM2 version */
-	unsigned ignoreadvanced:1;		/* do not include advanced configs */
-	unsigned ignoreunsupported:1;		/* do not include unsupported configs */
-	unsigned ignoredeprecated:1;		/* do not include deprecated configs */
-	unsigned ignorelocal:1;			/* do not include the local section */
-	unsigned withsummary:1;			/* include first line of comments - a summary */
-	unsigned withcomments:1;		/* include all comment lines */
-	unsigned withversions:1;		/* include versions */
-	unsigned withspaces:1;			/* add more spaces in output for better readability */
-	unsigned unconfigured:1;		/* use unconfigured path strings */
-	uint8_t *check_status;			/* status of last tree check (currently needed for CFG_DEF_TREE_MISSING only) */
+	struct cmd_context *cmd;	/* command context (for run-time defaults */
+	cfg_def_tree_t type;		/* tree type */
+	uint16_t version;		/* tree at this LVM2 version */
+	unsigned ignoreadvanced:1;	/* do not include advanced configs */
+	unsigned ignoreunsupported:1;	/* do not include unsupported configs */
+	unsigned ignoredeprecated:1;	/* do not include deprecated configs */
+	unsigned ignorelocal:1;		/* do not include the local section */
+	unsigned withsummary:1;		/* include first line of comments - a summary */
+	unsigned withcomments:1;	/* include all comment lines */
+	unsigned withversions:1;	/* include versions */
+	unsigned withspaces:1;		/* add more spaces in output for better readability */
+	unsigned unconfigured:1;	/* use unconfigured path strings */
+	uint8_t *check_status;		/* status of last tree check (currently needed for CFG_DEF_TREE_MISSING only) */
 };
 
 
@@ -274,7 +271,6 @@ int find_config_tree_int(struct cmd_context *cmd, int id, struct profile *profil
 int64_t find_config_tree_int64(struct cmd_context *cmd, int id, struct profile *profile);
 float find_config_tree_float(struct cmd_context *cmd, int id, struct profile *profile);
 int find_config_tree_bool(struct cmd_context *cmd, int id, struct profile *profile);
-const struct dm_config_node *find_config_tree_array(struct cmd_context *cmd, int id, struct profile *profile);
 
 /*
  * Functions for configuration settings for which the default
@@ -296,7 +292,5 @@ int get_default_allocation_thin_pool_chunk_size_CFG(struct cmd_context *cmd, str
 #define get_default_unconfigured_allocation_thin_pool_chunk_size_CFG NULL
 int get_default_allocation_cache_pool_chunk_size_CFG(struct cmd_context *cmd, struct profile *profile);
 #define get_default_unconfigured_allocation_cache_pool_chunk_size_CFG NULL
-const char *get_default_allocation_cache_policy_CFG(struct cmd_context *cmd, struct profile *profile);
-#define get_default_unconfigured_allocation_cache_policy_CFG NULL
 
 #endif

lib/config/defaults.h

@@ -51,7 +51,7 @@
 #define DEFAULT_FALLBACK_TO_LOCAL_LOCKING 1
 #define DEFAULT_FALLBACK_TO_CLUSTERED_LOCKING 1
 #define DEFAULT_WAIT_FOR_LOCKS 1
-#define DEFAULT_LVMLOCKD_LOCK_RETRIES 3
+#define DEFAULT_LOCK_RETRIES 3
 #define DEFAULT_PRIORITISE_WRITE_LOCKS 1
 #define DEFAULT_USE_MLOCKALL 0
 #define DEFAULT_METADATA_READ_ONLY 0
@@ -63,8 +63,6 @@
 #define DEFAULT_MIRROR_LOG_FAULT_POLICY "allocate"
 #define DEFAULT_MIRROR_IMAGE_FAULT_POLICY "remove"
 #define DEFAULT_MIRROR_MAX_IMAGES 8 /* limited by kernel DM_KCOPYD_MAX_REGIONS */
-#define DEFAULT_RAID_MAX_IMAGES 8
-
 #define DEFAULT_RAID_FAULT_POLICY "warn"
 
 #define DEFAULT_DMEVENTD_RAID_LIB "libdevmapper-event-lvm2raid.so"
@@ -90,8 +88,8 @@
 #  define DEFAULT_THIN_CHECK_OPTIONS_CONFIG "#S" DEFAULT_THIN_CHECK_OPTION1
 #endif
 
-#define DEFAULT_THIN_REPAIR_OPTION1 ""
-#define DEFAULT_THIN_REPAIR_OPTIONS_CONFIG "#S" DEFAULT_THIN_REPAIR_OPTION1
+#define DEFAULT_THIN_REPAIR_OPTIONS ""
+#define DEFAULT_THIN_REPAIR_OPTIONS_CONFIG NULL
 #define DEFAULT_THIN_POOL_METADATA_REQUIRE_SEPARATE_PVS 0
 #define DEFAULT_THIN_POOL_MAX_METADATA_SIZE (16 * 1024 * 1024)  /* KB */
 #define DEFAULT_THIN_POOL_MIN_METADATA_SIZE 2048  /* KB */
@@ -103,27 +101,25 @@
 #define DEFAULT_THIN_POOL_ZERO 1
 #define DEFAULT_POOL_METADATA_SPARE 1 /* thin + cache */
 
-#ifdef CACHE_CHECK_NEEDS_CHECK
-#  define DEFAULT_CACHE_CHECK_OPTION1 "-q"
-#  define DEFAULT_CACHE_CHECK_OPTION2 "--clear-needs-check-flag"
-#  define DEFAULT_CACHE_CHECK_OPTIONS_CONFIG "#S" DEFAULT_CACHE_CHECK_OPTION1 "#S" DEFAULT_CACHE_CHECK_OPTION2
-#else
-#  define DEFAULT_CACHE_CHECK_OPTION1 "-q"
-#  define DEFAULT_CACHE_CHECK_OPTION2 ""
-#  define DEFAULT_CACHE_CHECK_OPTIONS_CONFIG "#S" DEFAULT_CACHE_CHECK_OPTION1
-#endif
-
-#define DEFAULT_CACHE_REPAIR_OPTION1 ""
-#define DEFAULT_CACHE_REPAIR_OPTIONS_CONFIG "#S" DEFAULT_CACHE_REPAIR_OPTION1
+#define DEFAULT_CACHE_CHECK_OPTION1 "-q"
+#define DEFAULT_CACHE_CHECK_OPTIONS_CONFIG "#S" DEFAULT_CACHE_CHECK_OPTION1
+#define DEFAULT_CACHE_REPAIR_OPTIONS ""
+#define DEFAULT_CACHE_REPAIR_OPTIONS_CONFIG NULL
 #define DEFAULT_CACHE_POOL_METADATA_REQUIRE_SEPARATE_PVS 0
 #define DEFAULT_CACHE_POOL_CHUNK_SIZE 64 /* KB */
 #define DEFAULT_CACHE_POOL_MIN_METADATA_SIZE 2048  /* KB */
 #define DEFAULT_CACHE_POOL_MAX_METADATA_SIZE (16 * 1024 * 1024)  /* KB */
-#define DEFAULT_CACHE_POLICY "mq"
-#define DEFAULT_CACHE_MODE "writethrough"
+#define DEFAULT_CACHE_POOL_CACHEMODE "writethrough"
+#define DEFAULT_CACHE_POOL_POLICY "mq"
 
 #define DEFAULT_UMASK 0077
 
+#ifdef LVM1_FALLBACK
+#  define DEFAULT_FALLBACK_TO_LVM1 1
+#else
+#  define DEFAULT_FALLBACK_TO_LVM1 0
+#endif
+
 #define DEFAULT_FORMAT "lvm2"
 
 #define DEFAULT_STRIPESIZE 64	/* KB */
@@ -154,6 +150,11 @@
 #  define DEFAULT_LOG_FACILITY LOG_USER
 #endif
 
+#define DEFAULT_LOGGED_DEBUG_CLASSES (LOG_CLASS_MEM | LOG_CLASS_DEVS | \
+    LOG_CLASS_ACTIVATION | LOG_CLASS_ALLOC | LOG_CLASS_LVMETAD | \
+    LOG_CLASS_METADATA | LOG_CLASS_CACHE | LOG_CLASS_LOCKING | \
+    LOG_CLASS_LVMPOLLD)
+
 #define DEFAULT_SYSLOG 1
 #define DEFAULT_VERBOSE 0
 #define DEFAULT_SILENT 0
@@ -199,9 +200,6 @@
 #define DEFAULT_REP_QUOTED 1
 #define DEFAULT_REP_SEPARATOR " "
 #define DEFAULT_REP_LIST_ITEM_SEPARATOR ","
-#define DEFAULT_TIME_FORMAT "%Y-%m-%d %T %z"
-
-#define DEFAULT_COMPACT_OUTPUT_COLS ""
 
 #define DEFAULT_LVS_COLS "lv_name,vg_name,lv_attr,lv_size,pool_lv,origin,data_percent,metadata_percent,move_pv,mirror_log,copy_percent,convert_lv"
 #define DEFAULT_VGS_COLS "vg_name,pv_count,lv_count,snap_count,vg_attr,vg_size,vg_free"

lib/datastruct/str_list.c

@@ -16,14 +16,11 @@
 #include "lib.h"
 #include "str_list.h"
 
-#include <ctype.h>
-
 struct dm_list *str_list_create(struct dm_pool *mem)
 {
 	struct dm_list *sl;
 
-	if (!(sl = mem ? dm_pool_alloc(mem, sizeof(struct dm_list))
-		       : dm_malloc(sizeof(struct dm_list)))) {
+	if (!(sl = dm_pool_alloc(mem, sizeof(struct dm_list)))) {
 		log_errno(ENOMEM, "str_list allocation failed");
 		return NULL;
 	}
@@ -40,8 +37,7 @@ static int _str_list_add_no_dup_check(struct dm_pool *mem, struct dm_list *sll,
 	if (!str)
 		return_0;
 
-	if (!(sln = mem ? dm_pool_alloc(mem, sizeof(*sln))
-			: dm_malloc(sizeof(*sln))))
+	if (!(sln = dm_pool_alloc(mem, sizeof(*sln))))
 		return_0;
 
 	sln->str = str;
@@ -162,101 +158,3 @@ int str_list_lists_equal(const struct dm_list *sll, const struct dm_list *sll2)
 
 	return 1;
 }
-
-char *str_list_to_str(struct dm_pool *mem, const struct dm_list *list,
-		      const char *delim)
-{
-	size_t delim_len = strlen(delim);
-	unsigned list_size = dm_list_size(list);
-	struct dm_str_list *sl;
-	char *str, *p;
-	size_t len = 0;
-	unsigned i = 0;
-
-	dm_list_iterate_items(sl, list)
-		len += strlen(sl->str);
-	if (list_size > 1)
-		len += ((list_size - 1) * delim_len);
-
-	str = mem ? dm_pool_alloc(mem, len+1) : dm_malloc(len+1);
-	if (!str) {
-		log_error("str_list_to_str: string allocation failed.");
-		return NULL;
-	}
-	str[len] = '\0';
-	p = str;
-
-	dm_list_iterate_items(sl, list) {
-		len = strlen(sl->str);
-		memcpy(p, sl->str, len);
-		p += len;
-
-		if (++i != list_size) {
-			memcpy(p, delim, delim_len);
-			p += delim_len;
-		}
-	}
-
-	return str;
-}
-
-struct dm_list *str_to_str_list(struct dm_pool *mem, const char *str,
-				const char *delim, int ignore_multiple_delim)
-{
-	size_t delim_len = strlen(delim);
-	struct dm_list *list;
-	const char *p1, *p2, *next;
-	char *str_item;
-	size_t len;
-
-	if (!(list = str_list_create(mem))) {
-		log_error("str_to_str_list: string list allocation failed.");
-		return NULL;
-	}
-
-	p1 = p2 = str;
-	while (*p1) {
-		if (!(p2 = strstr(p1, delim)))
-			next = p2 = str + strlen(str);
-		else
-			next = p2 + delim_len;
-
-		len = p2 - p1;
-		str_item = mem ? dm_pool_alloc(mem, len+1) : dm_malloc(len+1);
-		if (!str_item) {
-			log_error("str_to_str_list: string list item allocation failed.");
-			goto bad;
-		}
-		memcpy(str_item, p1, len);
-		str_item[len] = '\0';
-
-		if (!str_list_add_no_dup_check(mem, list, str_item))
-			goto_bad;
-
-		if (ignore_multiple_delim) {
-			while (!strncmp(next, delim, delim_len))
-				next += delim_len;
-		}
-
-		p1 = next;
-	}
-
-	return list;
-bad:
-	if (mem)
-		dm_pool_free(mem, list);
-	return NULL;
-}
-
-void str_list_destroy(struct dm_list *list, int deallocate_strings)
-{
-	struct dm_str_list *sl, *tmp_sl;
-
-	dm_list_iterate_items_safe(sl, tmp_sl, list) {
-		dm_list_del(&sl->list);
-		if (deallocate_strings)
-			dm_free((char *)sl->str);
-		dm_free(sl);
-	}
-	dm_free(list);
-}

lib/datastruct/str_list.h

@@ -30,9 +30,5 @@ int str_list_match_list(const struct dm_list *sll, const struct dm_list *sll2, c
 int str_list_lists_equal(const struct dm_list *sll, const struct dm_list *sll2);
 int str_list_dup(struct dm_pool *mem, struct dm_list *sllnew,
 		 const struct dm_list *sllold);
-char *str_list_to_str(struct dm_pool *mem, const struct dm_list *list, const char *delim);
-struct dm_list *str_to_str_list(struct dm_pool *mem, const char *str, const char *delim, int ignore_multiple_delim);
-/* Only for lists which were *not* allocated from the mem pool! */
-void str_list_destroy(struct dm_list *list, int deallocate_strings);
 
 #endif

lib/device/dev-cache.c

@@ -71,16 +71,6 @@ static void _dev_init(struct device *dev, int max_error_count)
 	dm_list_init(&dev->open_list);
 }
 
-void dev_destroy_file(struct device *dev)
-{
-	if (!(dev->flags & DEV_ALLOCED))
-		return;
-
-	dm_free((void *) dm_list_item(dev->aliases.n, struct dm_str_list)->str);
-	dm_free(dev->aliases.n);
-	dm_free(dev);
-}
-
 struct device *dev_create_file(const char *filename, struct device *dev,
 			       struct dm_str_list *alias, int use_malloc)
 {
@@ -341,13 +331,11 @@ static int _add_alias(struct device *dev, const char *path)
 	if (!dm_list_empty(&dev->aliases)) {
 		oldpath = dm_list_item(dev->aliases.n, struct dm_str_list)->str;
 		prefer_old = _compare_paths(path, oldpath);
-		log_debug_devs("%s: Aliased to %s in device cache%s (%d:%d)",
-			       path, oldpath, prefer_old ? "" : " (preferred name)",
-			       (int) MAJOR(dev->dev), (int) MINOR(dev->dev));
+		log_debug_devs("%s: Aliased to %s in device cache%s",
+			       path, oldpath, prefer_old ? "" : " (preferred name)");
 
 	} else
-		log_debug_devs("%s: Added to device cache (%d:%d)", path,
-			       (int) MAJOR(dev->dev), (int) MINOR(dev->dev));
+		log_debug_devs("%s: Added to device cache", path);
 
 	if (prefer_old)
 		dm_list_add(&dev->aliases, &sl->list);
@@ -693,12 +681,10 @@ static int _init_preferred_names(struct cmd_context *cmd)
 
 	_cache.preferred_names_matcher = NULL;
 
-	if (!(cn = find_config_tree_array(cmd, devices_preferred_names_CFG, NULL)) ||
+	if (!(cn = find_config_tree_node(cmd, devices_preferred_names_CFG, NULL)) ||
 	    cn->v->type == DM_CFG_EMPTY_ARRAY) {
-		log_very_verbose("devices/preferred_names %s: "
-				 "using built-in preferences",
-				 cn && cn->v->type == DM_CFG_EMPTY_ARRAY ? "is empty"
-									 : "not found in config");
+		log_very_verbose("devices/preferred_names not found in config file: "
+				 "using built-in preferences");
 		return 1;
 	}
 
@@ -948,7 +934,6 @@ struct device *dev_cache_get(const char *name, struct dev_filter *f)
 {
 	struct stat buf;
 	struct device *d = (struct device *) dm_hash_lookup(_cache.names, name);
-	int info_available = 0;
 
 	if (d && (d->flags & DEV_REGULAR))
 		return d;
@@ -958,9 +943,8 @@ struct device *dev_cache_get(const char *name, struct dev_filter *f)
 		if (d)
 			dm_hash_remove(_cache.names, name);
 		log_sys_very_verbose("stat", name);
-		d = NULL;
-	} else
-		info_available = 1;
+		return NULL;
+	}
 
 	if (d && (buf.st_rdev != d->dev)) {
 		dm_hash_remove(_cache.names, name);
@@ -968,7 +952,7 @@ struct device *dev_cache_get(const char *name, struct dev_filter *f)
 	}
 
 	if (!d) {
-		_insert(name, info_available ? &buf : NULL, 0, obtain_device_list_from_udev());
+		_insert(name, &buf, 0, obtain_device_list_from_udev());
 		d = (struct device *) dm_hash_lookup(_cache.names, name);
 		if (!d) {
 			_full_scan(0);

lib/device/dev-dasd.c

@@ -1,111 +0,0 @@
-/*
- * 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 Lesser General Public License v.2.1.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include "lib.h"
-#include "metadata.h"
-#include "dev-type.h"
-#include <sys/ioctl.h>
-
-#ifdef __linux__
-
-/*
- * Interface taken from kernel header arch/s390/include/uapi/asm/dasd.h
- */
-
-/* 
- * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
- * Copyright IBM Corp. 1999, 2000
- * EMC Symmetrix ioctl Copyright EMC Corporation, 2008
- * Author.........: Nigel Hislop <hislop_nigel@emc.com>
- */
-
-#define DASD_IOCTL_LETTER 'D'
-#define DASD_API_VERSION 6
-
-/* 
- * struct dasd_information2_t
- * represents any data about the device, which is visible to userspace.
- *  including foramt and featueres.
- */
-typedef struct dasd_information2_t {
-	unsigned int devno;		/* S/390 devno */
-	unsigned int real_devno;	/* for aliases */
-	unsigned int schid;		/* S/390 subchannel identifier */
-	unsigned int cu_type  : 16;	/* from SenseID */
-	unsigned int cu_model :  8;	/* from SenseID */
-	unsigned int dev_type : 16;	/* from SenseID */
-	unsigned int dev_model : 8;	/* from SenseID */
-	unsigned int open_count;
-	unsigned int req_queue_len;
-	unsigned int chanq_len;		/* length of chanq */
-	char type[4];			/* from discipline.name, 'none' for unknown */
-	unsigned int status;		/* current device level */
-	unsigned int label_block;	/* where to find the VOLSER */
-	unsigned int FBA_layout;	/* fixed block size (like AIXVOL) */
-	unsigned int characteristics_size;
-	unsigned int confdata_size;
-	char characteristics[64];	/* from read_device_characteristics */
-	char configuration_data[256];	/* from read_configuration_data */
-	unsigned int format;		/* format info like formatted/cdl/ldl/... */
-	unsigned int features;		/* dasd features like 'ro',... */
-	unsigned int reserved0;		/* reserved for further use ,... */
-	unsigned int reserved1;		/* reserved for further use ,... */
-	unsigned int reserved2;		/* reserved for further use ,... */
-	unsigned int reserved3;		/* reserved for further use ,... */
-	unsigned int reserved4;		/* reserved for further use ,... */
-	unsigned int reserved5;		/* reserved for further use ,... */
-	unsigned int reserved6;		/* reserved for further use ,... */
-	unsigned int reserved7;		/* reserved for further use ,... */
-} dasd_information2_t;
-
-#define DASD_FORMAT_CDL  2
-
-/* Get information on a dasd device (enhanced) */
-#define BIODASDINFO2   _IOR(DASD_IOCTL_LETTER,3,dasd_information2_t)
-
-/*
- * End of included interface.
- */
-
-int dasd_is_cdl_formatted(struct device *dev)
-{
-	int ret = 0;
-	dasd_information2_t dasd_info2;
-
-	if (!dev_open_readonly(dev))
-		return_0;
-
-	if (ioctl(dev->fd, BIODASDINFO2, &dasd_info2)) {
-		log_sys_error("ioctl BIODASDINFO2", dev_name(dev));
-		goto out;
-	}
-
-	if (dasd_info2.format == DASD_FORMAT_CDL)
-		ret = 1;
-
-out:
-	if (!dev_close(dev))
-		stack;
-
-	return ret;
-}
-
-#else
-
-int dasd_is_cdl_formatted(struct device *dev)
-{
-	return 0;
-}
-
-#endif

lib/device/dev-io.c

@@ -586,8 +586,12 @@ static void _close(struct device *dev)
 
 	log_debug_devs("Closed %s", dev_name(dev));
 
-	if (dev->flags & DEV_ALLOCED)
-		dev_destroy_file(dev);
+	if (dev->flags & DEV_ALLOCED) {
+		dm_free((void *) dm_list_item(dev->aliases.n, struct dm_str_list)->
+			 str);
+		dm_free(dev->aliases.n);
+		dm_free(dev);
+	}
 }
 
 static int _dev_close(struct device *dev, int immediate)

lib/device/dev-type.c

@@ -363,7 +363,7 @@ static int _native_dev_is_partitioned(struct dev_types *dt, struct device *dev)
 		return 0;
 
 	/* Unpartitioned DASD devices are not supported. */
-	if ((MAJOR(dev->dev) == dt->dasd_major) && dasd_is_cdl_formatted(dev))
+	if (MAJOR(dev->dev) == dt->dasd_major)
 		return 1;
 
 	if (!dev_open_readonly_quiet(dev)) {
@@ -528,14 +528,12 @@ static inline int _type_in_flag_list(const char *type, uint32_t flag_list)
 		((flag_list & TYPE_DM_SNAPSHOT_COW) && !strcmp(type, "DM_snapshot_cow")));
 }
 
-#define MSG_FAILED_SIG_OFFSET "Failed to get offset of the %s signature on %s."
-#define MSG_FAILED_SIG_LENGTH "Failed to get length of the %s signature on %s."
-#define MSG_WIPING_SKIPPED " Wiping skipped."
-
 static int _blkid_wipe(blkid_probe probe, struct device *dev, const char *name,
 		       uint32_t types_to_exclude, uint32_t types_no_prompt,
 		       int yes, force_t force)
 {
+	static const char _msg_failed_offset[] = "Failed to get offset of the %s signature on %s.";
+	static const char _msg_failed_length[] = "Failed to get length of the %s signature on %s.";
 	static const char _msg_wiping[] = "Wiping %s signature on %s.";
 	const char *offset = NULL, *type = NULL, *magic = NULL,
 		   *usage = NULL, *label = NULL, *uuid = NULL;
@@ -546,41 +544,21 @@ static int _blkid_wipe(blkid_probe probe, struct device *dev, const char *name,
 		if (_type_in_flag_list(type, types_to_exclude))
 			return 2;
 		if (blkid_probe_lookup_value(probe, "SBMAGIC_OFFSET", &offset, NULL)) {
-			if (force < DONT_PROMPT) {
-				log_error(MSG_FAILED_SIG_OFFSET, type, name);
-				return 0;
-			} else {
-				log_error("WARNING: " MSG_FAILED_SIG_OFFSET MSG_WIPING_SKIPPED, type, name);
-				return 2;
-			}
+			log_error(_msg_failed_offset, type, name);
+			return 0;
 		}
 		if (blkid_probe_lookup_value(probe, "SBMAGIC", &magic, &len)) {
-			if (force < DONT_PROMPT) {
-				log_error(MSG_FAILED_SIG_LENGTH, type, name);
-				return 0;
-			} else {
-				log_warn("WARNING: " MSG_FAILED_SIG_LENGTH MSG_WIPING_SKIPPED, type, name);
-				return 2;
-			}
+			log_error(_msg_failed_length, type, name);
+			return 0;
 		}
 	} else if (!blkid_probe_lookup_value(probe, "PTTYPE", &type, NULL)) {
 		if (blkid_probe_lookup_value(probe, "PTMAGIC_OFFSET", &offset, NULL)) {
-			if (force < DONT_PROMPT) {
-				log_error(MSG_FAILED_SIG_OFFSET, type, name);
-				return 0;
-			} else {
-				log_warn("WARNING: " MSG_FAILED_SIG_OFFSET MSG_WIPING_SKIPPED, type, name);
-				return 2;
-			}
+			log_error(_msg_failed_offset, type, name);
+			return 0;
 		}
 		if (blkid_probe_lookup_value(probe, "PTMAGIC", &magic, &len)) {
-			if (force < DONT_PROMPT) {
-				log_error(MSG_FAILED_SIG_LENGTH, type, name);
-				return 0;
-			} else {
-				log_warn("WARNING: " MSG_FAILED_SIG_LENGTH MSG_WIPING_SKIPPED, type, name);
-				return 2;
-			}
+			log_error(_msg_failed_length, type, name);
+			return 0;
 		}
 		usage = "partition table";
 	} else
@@ -651,13 +629,8 @@ static int _wipe_known_signatures_with_blkid(struct device *dev, const char *nam
 						 BLKID_SUBLKS_BADCSUM);
 
 	while (!blkid_do_probe(probe)) {
-		if ((r_wipe = _blkid_wipe(probe, dev, name, types_to_exclude, types_no_prompt, yes, force)) == 1) {
+		if ((r_wipe = _blkid_wipe(probe, dev, name, types_to_exclude, types_no_prompt, yes, force)) == 1)
 			(*wiped)++;
-			if (blkid_probe_step_back(probe)) {
-				log_error("Failed to step back blkid probe to check just wiped signature.");
-				goto out;
-			}
-		}
 		/* do not count excluded types */
 		if (r_wipe != 2)
 			found++;
@@ -739,20 +712,13 @@ int wipe_known_signatures(struct cmd_context *cmd, struct device *dev,
 			  uint32_t types_no_prompt, int yes, force_t force,
 			  int *wiped)
 {
-	int blkid_wiping_enabled = find_config_tree_bool(cmd, allocation_use_blkid_wiping_CFG, NULL);
-
 #ifdef BLKID_WIPING_SUPPORT
-	if (blkid_wiping_enabled)
+	if (find_config_tree_bool(cmd, allocation_use_blkid_wiping_CFG, NULL))
 		return _wipe_known_signatures_with_blkid(dev, name,
 							 types_to_exclude,
 							 types_no_prompt,
 							 yes, force, wiped);
 #endif
-	if (blkid_wiping_enabled) {
-		log_warn("allocation/use_blkid_wiping=1 configuration setting is set "
-			 "while LVM is not compiled with blkid wiping support.");
-		log_warn("Falling back to native LVM signature detection.");
-	}
 	return _wipe_known_signatures_with_lvm(dev, name,
 					       types_to_exclude,
 					       types_no_prompt,

lib/device/dev-type.h

@@ -59,7 +59,6 @@ int major_is_scsi_device(struct dev_types *dt, int major);
 int dev_is_md(struct device *dev, uint64_t *sb);
 int dev_is_swap(struct device *dev, uint64_t *signature);
 int dev_is_luks(struct device *dev, uint64_t *signature);
-int dasd_is_cdl_formatted(struct device *dev);
 
 /* Signature wiping. */
 #define TYPE_LVM1_MEMBER	0x001

lib/device/device.h

@@ -123,7 +123,6 @@ void dev_flush(struct device *dev);
 
 struct device *dev_create_file(const char *filename, struct device *dev,
 			       struct dm_str_list *alias, int use_malloc);
-void dev_destroy_file(struct device *dev);
 
 /* Return a valid device name from the alias list; NULL otherwise */
 const char *dev_name_confirmed(struct device *dev, int quiet);

lib/display/display.c

@@ -24,6 +24,10 @@
 
 #include <stdarg.h>
 
+#define SIZE_BUF 128
+
+typedef enum { SIZE_LONG = 0, SIZE_SHORT = 1, SIZE_UNIT = 2 } size_len_t;
+
 static const struct {
 	alloc_policy_t alloc;
 	const char str[14]; /* must be changed when size extends 13 chars */
@@ -137,35 +141,169 @@ const char *display_lvname(const struct logical_volume *lv)
 		return NULL;
 	}
 
-	lv->vg->cmd->display_lvname_idx += r + 1;
+	lv->vg->cmd->display_lvname_idx += r;
 
 	return name;
 }
 
+#define BASE_UNKNOWN 0
+#define BASE_SHARED 1
+#define BASE_1024 8
+#define BASE_1000 15
+#define BASE_SPECIAL 21
+#define NUM_UNIT_PREFIXES 6
+#define NUM_SPECIAL 3
+
 /* Size supplied in sectors */
 static const char *_display_size(const struct cmd_context *cmd,
-				 uint64_t size, dm_size_suffix_t suffix_type)
+				 uint64_t size, size_len_t sl)
 {
-	return dm_size_to_string(cmd->mem, size, cmd->current_settings.unit_type,
-				 cmd->si_unit_consistency, 
-				 cmd->current_settings.unit_factor,
-				 cmd->current_settings.suffix,
-				 suffix_type);
+	unsigned base = BASE_UNKNOWN;
+	unsigned s;
+	int suffix, precision;
+	uint64_t byte = UINT64_C(0);
+	uint64_t units = UINT64_C(1024);
+	char *size_buf = NULL;
+	const char * const size_str[][3] = {
+		/* BASE_UNKNOWN */
+		{"         ", "   ", " "},	/* [0] */
+
+		/* BASE_SHARED - Used if cmd->si_unit_consistency = 0 */
+		{" Exabyte", " EB", "E"},	/* [1] */
+		{" Petabyte", " PB", "P"},	/* [2] */
+		{" Terabyte", " TB", "T"},	/* [3] */
+		{" Gigabyte", " GB", "G"},	/* [4] */
+		{" Megabyte", " MB", "M"},	/* [5] */
+		{" Kilobyte", " KB", "K"},	/* [6] */
+		{" Byte    ", " B", "B"},	/* [7] */
+
+		/* BASE_1024 - Used if cmd->si_unit_consistency = 1 */
+		{" Exbibyte", " EiB", "e"},	/* [8] */
+		{" Pebibyte", " PiB", "p"},	/* [9] */
+		{" Tebibyte", " TiB", "t"},	/* [10] */
+		{" Gibibyte", " GiB", "g"},	/* [11] */
+		{" Mebibyte", " MiB", "m"},	/* [12] */
+		{" Kibibyte", " KiB", "k"},	/* [13] */
+		{" Byte    ", " B", "b"},	/* [14] */
+
+		/* BASE_1000 - Used if cmd->si_unit_consistency = 1 */
+		{" Exabyte",  " EB", "E"},	/* [15] */
+		{" Petabyte", " PB", "P"},	/* [16] */
+		{" Terabyte", " TB", "T"},	/* [17] */
+		{" Gigabyte", " GB", "G"},	/* [18] */
+		{" Megabyte", " MB", "M"},	/* [19] */
+		{" Kilobyte", " kB", "K"},	/* [20] */
+
+		/* BASE_SPECIAL */
+		{" Byte    ", " B ", "B"},	/* [21] (shared with BASE_1000) */
+		{" Units   ", " Un", "U"},	/* [22] */
+		{" Sectors ", " Se", "S"},	/* [23] */
+	};
+
+	if (!(size_buf = dm_pool_alloc(cmd->mem, SIZE_BUF))) {
+		log_error("no memory for size display buffer");
+		return "";
+	}
+
+	suffix = cmd->current_settings.suffix;
+
+	if (!cmd->si_unit_consistency) {
+		/* Case-independent match */
+		for (s = 0; s < NUM_UNIT_PREFIXES; s++)
+			if (toupper((int) cmd->current_settings.unit_type) ==
+			    *size_str[BASE_SHARED + s][2]) {
+				base = BASE_SHARED;
+				break;
+			}
+	} else {
+		/* Case-dependent match for powers of 1000 */
+		for (s = 0; s < NUM_UNIT_PREFIXES; s++)
+			if (cmd->current_settings.unit_type ==
+			    *size_str[BASE_1000 + s][2]) {
+				base = BASE_1000;
+				break;
+			}
+
+		/* Case-dependent match for powers of 1024 */
+		if (base == BASE_UNKNOWN)
+			for (s = 0; s < NUM_UNIT_PREFIXES; s++)
+			if (cmd->current_settings.unit_type ==
+			    *size_str[BASE_1024 + s][2]) {
+				base = BASE_1024;
+				break;
+			}
+	}
+
+	if (base == BASE_UNKNOWN)
+		/* Check for special units - s, b or u */
+		for (s = 0; s < NUM_SPECIAL; s++)
+			if (toupper((int) cmd->current_settings.unit_type) ==
+			    *size_str[BASE_SPECIAL + s][2]) {
+				base = BASE_SPECIAL;
+				break;
+			}
+
+	if (size == UINT64_C(0)) {
+		if (base == BASE_UNKNOWN)
+			s = 0;
+		sprintf(size_buf, "0%s", suffix ? size_str[base + s][sl] : "");
+		return size_buf;
+	}
+
+	size *= UINT64_C(512);
+
+	if (base != BASE_UNKNOWN)
+		byte = cmd->current_settings.unit_factor;
+	else {
+		/* Human-readable style */
+		if (cmd->current_settings.unit_type == 'H') {
+			units = UINT64_C(1000);
+			base = BASE_1000;
+		} else {
+			units = UINT64_C(1024);
+			base = BASE_1024;
+		}
+
+		if (!cmd->si_unit_consistency)
+			base = BASE_SHARED;
+
+		byte = units * units * units * units * units * units;
+
+		for (s = 0; s < NUM_UNIT_PREFIXES && size < byte; s++)
+			byte /= units;
+
+		suffix = 1;
+	}
+
+	/* FIXME Make precision configurable */
+	switch (toupper(*size_str[base + s][SIZE_UNIT])) {
+	case 'B':
+	case 'S':
+		precision = 0;
+		break;
+	default:
+		precision = 2;
+	}
+
+	snprintf(size_buf, SIZE_BUF - 1, "%.*f%s", precision,
+		 (double) size / byte, suffix ? size_str[base + s][sl] : "");
+
+	return size_buf;
 }
 
 const char *display_size_long(const struct cmd_context *cmd, uint64_t size)
 {
-	return _display_size(cmd, size, DM_SIZE_LONG);
+	return _display_size(cmd, size, SIZE_LONG);
 }
 
 const char *display_size_units(const struct cmd_context *cmd, uint64_t size)
 {
-	return _display_size(cmd, size, DM_SIZE_UNIT);
+	return _display_size(cmd, size, SIZE_UNIT);
 }
 
 const char *display_size(const struct cmd_context *cmd, uint64_t size)
 {
-	return _display_size(cmd, size, DM_SIZE_SHORT);
+	return _display_size(cmd, size, SIZE_SHORT);
 }
 
 void pvdisplay_colons(const struct physical_volume *pv)
@@ -383,7 +521,7 @@ int lvdisplay_full(struct cmd_context *cmd,
 	log_print("LV UUID                %s", uuid);
 	log_print("LV Write Access        %s", access_str);
 	log_print("LV Creation host, time %s, %s",
-		  lv_host_dup(cmd->mem, lv), lv_time_dup(cmd->mem, lv, 1));
+		  lv_host_dup(cmd->mem, lv), lv_time_dup(cmd->mem, lv));
 
 	if (lv_is_origin(lv)) {
 		log_print("LV snapshot status     source of");

lib/error/errseg.c

@@ -95,7 +95,7 @@ struct segment_type *init_error_segtype(struct cmd_context *cmd)
 		return_NULL;
 
 	segtype->ops = &_error_ops;
-	segtype->name = SEG_TYPE_NAME_ERROR;
+	segtype->name = "error";
 	segtype->flags = SEG_CAN_SPLIT | SEG_VIRTUAL | SEG_CANNOT_BE_ZEROED;
 
 	log_very_verbose("Initialised segtype: %s", segtype->name);

lib/filters/filter-fwraid.c

@@ -61,8 +61,6 @@ static int _dev_is_fwraid(struct device *dev)
 	return 0;
 }
 
-#define MSG_SKIPPING "%s: Skipping firmware RAID component device"
-
 static int _ignore_fwraid(struct dev_filter *f __attribute__((unused)),
 			   struct device *dev)
 {
@@ -74,11 +72,8 @@ static int _ignore_fwraid(struct dev_filter *f __attribute__((unused)),
 	ret = _dev_is_fwraid(dev);
 
 	if (ret == 1) {
-		if (dev->ext.src == DEV_EXT_NONE)
-			log_debug_devs(MSG_SKIPPING, dev_name(dev));
-		else
-			log_debug_devs(MSG_SKIPPING " [%s:%p]", dev_name(dev),
-					dev_ext_name(dev), dev->ext.handle);
+		log_debug_devs("%s: Skipping firmware RAID component device [%s:%p]",
+				dev_name(dev), dev_ext_name(dev), dev->ext.handle);
 		return 0;
 	}
 

lib/filters/filter-md.c

@@ -18,8 +18,6 @@
 
 #ifdef __linux__
 
-#define MSG_SKIPPING "%s: Skipping md component device"
-
 static int _ignore_md(struct dev_filter *f __attribute__((unused)),
 		      struct device *dev)
 {
@@ -31,11 +29,8 @@ static int _ignore_md(struct dev_filter *f __attribute__((unused)),
 	ret = dev_is_md(dev, NULL);
 
 	if (ret == 1) {
-		if (dev->ext.src == DEV_EXT_NONE)
-			log_debug_devs(MSG_SKIPPING, dev_name(dev));
-		else
-			log_debug_devs(MSG_SKIPPING " [%s:%p]", dev_name(dev),
-					dev_ext_name(dev), dev->ext.handle);
+		log_debug_devs("%s: Skipping md component device [%s:%p]",
+				dev_name(dev), dev_ext_name(dev), dev->ext.handle);
 		return 0;
 	}
 

lib/filters/filter-mpath.c

@@ -244,16 +244,11 @@ static int _dev_is_mpath(struct dev_filter *f, struct device *dev)
 	return 0;
 }
 
-#define MSG_SKIPPING "%s: Skipping mpath component device"
-
 static int _ignore_mpath(struct dev_filter *f, struct device *dev)
 {
 	if (_dev_is_mpath(f, dev) == 1) {
-		if (dev->ext.src == DEV_EXT_NONE)
-			log_debug_devs(MSG_SKIPPING, dev_name(dev));
-		else
-			log_debug_devs(MSG_SKIPPING " [%s:%p]", dev_name(dev),
-					dev_ext_name(dev), dev->ext.handle);
+		log_debug_devs("%s: Skipping mpath component device [%s:%p]",
+				dev_name(dev), dev_ext_name(dev), dev->ext.handle);
 		return 0;
 	}
 

lib/filters/filter-partitioned.c

@@ -16,18 +16,13 @@
 #include "lib.h"
 #include "filter.h"
 
-#define MSG_SKIPPING "%s: Skipping: Partition table signature found"
-
 static int _passes_partitioned_filter(struct dev_filter *f, struct device *dev)
 {
 	struct dev_types *dt = (struct dev_types *) f->private;
 
 	if (dev_is_partitioned(dt, dev)) {
-		if (dev->ext.src == DEV_EXT_NONE)
-			log_debug_devs(MSG_SKIPPING, dev_name(dev));
-		else
-			log_debug_devs(MSG_SKIPPING " [%s:%p]", dev_name(dev),
-					dev_ext_name(dev), dev->ext.handle);
+		log_debug_devs("%s: Skipping: Partition table signature found [%s:%p]",
+			       dev_name(dev), dev_ext_name(dev), dev->ext.handle);
 		return 0;
 	}
 

lib/filters/filter-usable.c

@@ -29,19 +29,22 @@ static int _native_check_pv_min_size(struct device *dev)
 
 	/* Check it's accessible */
 	if (!dev_open_readonly_quiet(dev)) {
-		log_debug_devs("%s: Skipping: open failed", dev_name(dev));
+		log_debug_devs("%s: Skipping: open failed [%s:%p]",
+				dev_name(dev), dev_ext_name(dev), dev->ext.handle);
 		return 0;
 	}
 
 	/* Check it's not too small */
 	if (!dev_get_size(dev, &size)) {
-		log_debug_devs("%s: Skipping: dev_get_size failed", dev_name(dev));
+		log_debug_devs("%s: Skipping: dev_get_size failed [%s:%p]",
+				dev_name(dev), dev_ext_name(dev), dev->ext.handle);
 		goto out;
 	}
 
 	if (size < pv_min_size()) {
-		log_debug_devs("%s: Skipping: %s", dev_name(dev),
-				_too_small_to_hold_pv_msg);
+		log_debug_devs("%s: Skipping: %s [%s:%p]", dev_name(dev),
+				_too_small_to_hold_pv_msg,
+				dev_ext_name(dev), dev->ext.handle);
 		goto out;
 	}
 
@@ -112,11 +115,26 @@ static int _passes_usable_filter(struct dev_filter *f, struct device *dev)
 {
 	filter_mode_t mode = *((filter_mode_t *) f->private);
 	struct dev_usable_check_params ucp = {0};
-	int r = 1;
+	int r;
+
+	/* check if the device is not too small to hold a PV */
+	switch (mode) {
+		case FILTER_MODE_NO_LVMETAD:
+			/* fall through */
+		case FILTER_MODE_PRE_LVMETAD:
+			if (!_check_pv_min_size(dev))
+				return 0;
+			break;
+		case FILTER_MODE_POST_LVMETAD:
+			/* nothing to do here */
+			break;
+	}
 
 	/* further checks are done on dm devices only */
-	if (dm_is_dm_major(MAJOR(dev->dev))) {
-		switch (mode) {
+	if (!dm_is_dm_major(MAJOR(dev->dev)))
+		return 1;
+
+	switch (mode) {
 		case FILTER_MODE_NO_LVMETAD:
 			ucp.check_empty = 1;
 			ucp.check_blocked = 1;
@@ -145,25 +163,10 @@ static int _passes_usable_filter(struct dev_filter *f, struct device *dev)
 			ucp.check_error_target = 0;
 			ucp.check_reserved = 0;
 			break;
-		}
-
-		if (!(r = device_is_usable(dev, ucp)))
-			log_debug_devs("%s: Skipping unusable device.", dev_name(dev));
 	}
 
-	if (r) {
-		/* check if the device is not too small to hold a PV */
-		switch (mode) {
-		case FILTER_MODE_NO_LVMETAD:
-			/* fall through */
-		case FILTER_MODE_PRE_LVMETAD:
-			r = _check_pv_min_size(dev);
-			break;
-		case FILTER_MODE_POST_LVMETAD:
-			/* nothing to do here */
-			break;
-		}
-	}
+	if (!(r = device_is_usable(dev, ucp)))
+		log_debug_devs("%s: Skipping unusable device", dev_name(dev));
 
 	return r;
 }

lib/format1/import-export.c

@@ -164,7 +164,7 @@ int export_pv(struct cmd_context *cmd, struct dm_pool *mem __attribute__((unused
 	/* Is VG already exported or being exported? */
 	if (vg && vg_is_exported(vg)) {
 		/* Does system_id need setting? */
-		if (!vg->lvm1_system_id || !*vg->lvm1_system_id ||
+		if (!*vg->lvm1_system_id ||
 		    strncmp(vg->lvm1_system_id, EXPORTED_TAG,
 			    sizeof(EXPORTED_TAG) - 1)) {
 			if (!generate_lvm1_system_id(cmd, (char *)pvd->system_id, EXPORTED_TAG))

lib/format1/import-extents.c

@@ -219,7 +219,7 @@ static int _read_linear(struct cmd_context *cmd, struct lv_map *lvm)
 	struct lv_segment *seg;
 	struct segment_type *segtype;
 
-	if (!(segtype = get_segtype_from_string(cmd, SEG_TYPE_NAME_STRIPED)))
+	if (!(segtype = get_segtype_from_string(cmd, "striped")))
 		return_0;
 
 	while (le < lvm->lv->le_count) {
@@ -281,7 +281,7 @@ static int _read_stripes(struct cmd_context *cmd, struct lv_map *lvm)
 
 	total_area_len = lvm->lv->le_count / lvm->stripes;
 
-	if (!(segtype = get_segtype_from_string(cmd, SEG_TYPE_NAME_STRIPED)))
+	if (!(segtype = get_segtype_from_string(cmd, "striped")))
 		return_0;
 
 	while (first_area_le < total_area_len) {

lib/format_pool/import_export.c

@@ -188,7 +188,8 @@ static int _add_stripe_seg(struct dm_pool *mem,
 
 	area_len = (usp->devs[0].blocks) / POOL_PE_SIZE;
 
-	if (!(segtype = get_segtype_from_string(lv->vg->cmd, SEG_TYPE_NAME_STRIPED)))
+	if (!(segtype = get_segtype_from_string(lv->vg->cmd,
+						     "striped")))
 		return_0;
 
 	if (!(seg = alloc_lv_segment(segtype, lv, *le_cur,
@@ -225,7 +226,7 @@ static int _add_linear_seg(struct dm_pool *mem,
 	unsigned j;
 	uint32_t area_len;
 
-	if (!(segtype = get_segtype_from_string(lv->vg->cmd, SEG_TYPE_NAME_STRIPED)))
+	if (!(segtype = get_segtype_from_string(lv->vg->cmd, "striped")))
 		return_0;
 
 	for (j = 0; j < usp->num_devs; j++) {

lib/format_text/export.c

@@ -372,61 +372,19 @@ static int _print_flag_config(struct formatter *f, uint64_t status, int type)
 	return 1;
 }
 
-static char *_alloc_printed_str_list(struct dm_list *list)
+
+static int _out_tags(struct formatter *f, struct dm_list *tagsl)
 {
-	struct dm_str_list *sl;
-	int first = 1;
-	size_t size = 0;
-	char *buffer, *buf;
+	char *tag_buffer;
 
-	dm_list_iterate_items(sl, list)
-		/* '"' + item + '"' + ',' + ' ' */
-		size += strlen(sl->str) + 4;
-	/* '[' + ']' + '\0' */
-	size += 3;
-
-	if (!(buffer = buf = dm_malloc(size))) {
-		log_error("Could not allocate memory for string list buffer.");
-		return NULL;
-	}
-
-	if (!emit_to_buffer(&buf, &size, "["))
-		goto_bad;
-
-	dm_list_iterate_items(sl, list) {
-		if (!first) {
-			if (!emit_to_buffer(&buf, &size, ", "))
-				goto_bad;
-		} else
-			first = 0;
-
-		if (!emit_to_buffer(&buf, &size, "\"%s\"", sl->str))
-			goto_bad;
-	}
-
-	if (!emit_to_buffer(&buf, &size, "]"))
-		goto_bad;
-
-	return buffer;
-
-bad:
-	dm_free(buffer);
-	return_NULL;
-}
-
-static int _out_list(struct formatter *f, struct dm_list *list,
-		     const char *list_name)
-{
-	char *buffer;
-
-	if (!dm_list_empty(list)) {
-		if (!(buffer = _alloc_printed_str_list(list)))
+	if (!dm_list_empty(tagsl)) {
+		if (!(tag_buffer = alloc_printed_tags(tagsl)))
 			return_0;
-		if (!out_text(f, "%s = %s", list_name, buffer)) {
-			dm_free(buffer);
+		if (!out_text(f, "tags = %s", tag_buffer)) {
+			dm_free(tag_buffer);
 			return_0;
 		}
-		dm_free(buffer);
+		dm_free(tag_buffer);
 	}
 
 	return 1;
@@ -464,7 +422,7 @@ static int _print_vg(struct formatter *f, struct volume_group *vg)
 	if (!_print_flag_config(f, status, VG_FLAGS))
 		return_0;
 
-	if (!_out_list(f, &vg->tags, "tags"))
+	if (!_out_tags(f, &vg->tags))
 		return_0;
  
 	if (vg->system_id && *vg->system_id)
@@ -554,7 +512,7 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 		if (!_print_flag_config(f, pv->status, PV_FLAGS))
 			return_0;
 
-		if (!_out_list(f, &pv->tags, "tags"))
+		if (!_out_tags(f, &pv->tags))
 			return_0;
 
 		outsize(f, pv->size, "dev_size = %" PRIu64, pv->size);
@@ -590,7 +548,7 @@ static int _print_segment(struct formatter *f, struct volume_group *vg,
 	outnl(f);
 	outf(f, "type = \"%s\"", seg->segtype->name);
 
-	if (!_out_list(f, &seg->tags, "tags"))
+	if (!_out_tags(f, &seg->tags))
 		return_0;
 
 	if (seg->segtype->ops->text_export &&
@@ -686,7 +644,7 @@ static int _print_lv(struct formatter *f, struct logical_volume *lv)
 	if (!_print_flag_config(f, status, LV_FLAGS))
 		return_0;
 
-	if (!_out_list(f, &lv->tags, "tags"))
+	if (!_out_tags(f, &lv->tags))
 		return_0;
 
 	if (lv->timestamp) {

lib/format_text/format-text.c

@@ -453,9 +453,8 @@ static struct raw_locn *_find_vg_rlocn(struct device_area *dev_area,
 				   "not match expected name %s.", vgname);
 
       bad:
-	if ((info = lvmcache_info_from_pvid(dev_area->dev->pvid, 0)) &&
-	    !lvmcache_update_vgname_and_id(info, &vgsummary_orphan))
-		stack;
+	if ((info = lvmcache_info_from_pvid(dev_area->dev->pvid, 0)))
+		lvmcache_update_vgname_and_id(info, &vgsummary_orphan);
 
 	return NULL;
 }
@@ -654,7 +653,7 @@ static int _vg_write_raw(struct format_instance *fid, struct volume_group *vg,
 
 	if ((new_wrap && old_wrap) ||
 	    (rlocn && (new_wrap || old_wrap) && (new_end > rlocn->offset)) ||
-	    (MDA_HEADER_SIZE + (rlocn ? rlocn->size : 0) + mdac->rlocn.size >= mdah->size)) {
+	    (mdac->rlocn.size >= mdah->size)) {
 		log_error("VG %s metadata too large for circular buffer",
 			  vg->name);
 		goto out;
@@ -1339,7 +1338,6 @@ static int _text_pv_write(const struct format_type *fmt, struct physical_volume
 
 	label = lvmcache_get_label(info);
 	label->sector = pv->label_sector;
-	label->dev = pv->dev;
 
 	lvmcache_update_pv(info, pv, fmt);
 
@@ -2146,6 +2144,7 @@ static int _text_pv_add_metadata_area(const struct format_type *fmt,
 					goto bad;
 			}
 			/* Otherwise, give up and take any usable space. */
+			/* FIXME: We should probably check for some minimum MDA size here. */
 			else
 				mda_size = limit - mda_start;
 
@@ -2238,16 +2237,10 @@ static int _text_pv_add_metadata_area(const struct format_type *fmt,
 	if (limit_applied)
 		log_very_verbose("Using limited metadata area size on %s "
 				 "with value %" PRIu64 " (limited by %s of "
-				 FMTu64 ").", pv_dev_name(pv),
+				 "%" PRIu64 ").", pv_dev_name(pv),
 				  mda_size, limit_name, limit);
 
 	if (mda_size) {
-		if (mda_size < MDA_SIZE_MIN) {
-			log_error("Metadata area size too small: %" PRIu64" bytes. "
-				  "It must be at least %u bytes.", mda_size, MDA_SIZE_MIN);
-			goto bad;
-		}
-
 		/* Wipe metadata area with zeroes. */
 		if (!dev_set((struct device *) pv->dev, mda_start,
 			(size_t) ((mda_size > wipe_size) ?
@@ -2498,7 +2491,7 @@ struct format_type *create_text_format(struct cmd_context *cmd)
 		goto bad;
 	}
 
-	if ((cn = find_config_tree_array(cmd, metadata_dirs_CFG, NULL))) {
+	if ((cn = find_config_tree_node(cmd, metadata_dirs_CFG, NULL))) {
 		for (cv = cn->v; cv; cv = cv->next) {
 			if (cv->type != DM_CFG_STRING) {
 				log_error("Invalid string in config file: "

lib/format_text/import-export.h

@@ -61,6 +61,9 @@ struct text_vg_version_ops *text_vg_vsn1_init(void);
 int print_flags(uint64_t status, int type, char *buffer, size_t size);
 int read_flags(uint64_t *status, int type, const struct dm_config_value *cv);
 
+char *alloc_printed_tags(struct dm_list *tags);
+int read_tags(struct dm_pool *mem, struct dm_list *tags, const struct dm_config_value *cv);
+
 int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp);
 size_t text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf);
 struct volume_group *text_vg_import_file(struct format_instance *fid,

lib/format_text/import_vsn1.c

@@ -26,7 +26,6 @@
 #include "segtype.h"
 #include "text_import.h"
 #include "defaults.h"
-#include "str_list.h"
 
 typedef int (*section_fn) (struct format_instance * fid,
 			   struct volume_group * vg, const struct dm_config_node * pvn,
@@ -155,26 +154,6 @@ static int _read_flag_config(const struct dm_config_node *n, uint64_t *status, i
 	return 1;
 }
 
-static int _read_str_list(struct dm_pool *mem, struct dm_list *list, const struct dm_config_value *cv)
-{
-	if (cv->type == DM_CFG_EMPTY_ARRAY)
-		return 1;
-
-	while (cv) {
-		if (cv->type != DM_CFG_STRING) {
-			log_error("Found an item that is not a string");
-			return 0;
-		}
-
-		if (!str_list_add(mem, list, dm_pool_strdup(mem, cv->v.str)))
-			return_0;
-
-		cv = cv->next;
-	}
-
-	return 1;
-}
-
 static int _read_pv(struct format_instance *fid,
 		    struct volume_group *vg, const struct dm_config_node *pvn,
 		    const struct dm_config_node *vgn __attribute__((unused)),
@@ -291,7 +270,7 @@ static int _read_pv(struct format_instance *fid,
 
 	/* Optional tags */
 	if (dm_config_get_list(pvn, "tags", &cv) &&
-	    !(_read_str_list(mem, &pv->tags, cv))) {
+	    !(read_tags(mem, &pv->tags, cv))) {
 		log_error("Couldn't read tags for physical volume %s in %s.",
 			  pv_dev_name(pv), vg->name);
 		return 0;
@@ -375,7 +354,7 @@ static int _read_segment(struct logical_volume *lv, const struct dm_config_node
 		return 0;
 	}
 
-	segtype_str = SEG_TYPE_NAME_STRIPED;
+	segtype_str = "striped";
 
 	if (!dm_config_get_str(sn_child, "type", &segtype_str)) {
 		log_error("Segment type must be a string.");
@@ -402,7 +381,7 @@ static int _read_segment(struct logical_volume *lv, const struct dm_config_node
 
 	/* Optional tags */
 	if (dm_config_get_list(sn_child, "tags", &cv) &&
-	    !(_read_str_list(mem, &seg->tags, cv))) {
+	    !(read_tags(mem, &seg->tags, cv))) {
 		log_error("Couldn't read tags for a segment of %s/%s.",
 			  lv->vg->name, lv->name);
 		return 0;
@@ -600,25 +579,6 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
 		return 0;
 	}
 
-	/*
-	 * The LV lock_args string is generated in lvmlockd, and the content
-	 * depends on the lock_type.
-	 *
-	 * lock_type dlm does not use LV lock_args, so the LV lock_args field
-	 * is just set to "dlm".
-	 *
-	 * lock_type sanlock uses the LV lock_args field to save the
-	 * location on disk of that LV's sanlock lock.  The disk name is
-	 * specified in the VG lock_args.  The lock_args string begins
-	 * with a version number, e.g. 1.0.0, followed by a colon, followed
-	 * by a number.  The number is the offset on disk where sanlock is
-	 * told to find the LV's lock.
-	 * e.g. lock_args = 1.0.0:70254592
-	 * means that the lock is located at offset 70254592.
-	 *
-	 * The lvmlockd code for each specific lock manager also validates
-	 * the lock_args before using it to access the lock manager.
-	 */
 	if (dm_config_get_str(lvn, "lock_args", &str)) {
 		if (!(lv->lock_args = dm_pool_strdup(mem, str)))
 			return_0;
@@ -662,7 +622,7 @@ static int _read_lvnames(struct format_instance *fid __attribute__((unused)),
 
 	/* Optional tags */
 	if (dm_config_get_list(lvn, "tags", &cv) &&
-	    !(_read_str_list(mem, &lv->tags, cv))) {
+	    !(read_tags(mem, &lv->tags, cv))) {
 		log_error("Couldn't read tags for logical volume %s/%s.",
 			  vg->name, lv->name);
 		return 0;
@@ -847,27 +807,6 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 			goto bad;
 	}
 
-	/*
-	 * The VG lock_args string is generated in lvmlockd, and the content
-	 * depends on the lock_type.  lvmlockd begins the lock_args string
-	 * with a version number, e.g. 1.0.0, followed by a colon, followed
-	 * by a string that depends on the lock manager.  The string after
-	 * the colon is information needed to use the lock manager for the VG.
-	 *
-	 * For sanlock, the string is the name of the internal LV used to store
-	 * sanlock locks.  lvmlockd needs to know where the locks are located
-	 * so it can pass that location to sanlock which needs to access the locks.
-	 * e.g. lock_args = 1.0.0:lvmlock
-	 * means that the locks are located on the the LV "lvmlock".
-	 *
-	 * For dlm, the string is the dlm cluster name.  lvmlockd needs to use
-	 * a dlm lockspace in this cluster to use the VG.
-	 * e.g. lock_args = 1.0.0:foo
-	 * means that the host needs to be a member of the cluster "foo".
-	 *
-	 * The lvmlockd code for each specific lock manager also validates
-	 * the lock_args before using it to access the lock manager.
-	 */
 	if (dm_config_get_str(vgn, "lock_args", &str)) {
 		if (!(vg->lock_args = dm_pool_strdup(vg->vgmem, str)))
 			goto bad;
@@ -969,7 +908,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 
 	/* Optional tags */
 	if (dm_config_get_list(vgn, "tags", &cv) &&
-	    !(_read_str_list(vg->vgmem, &vg->tags, cv))) {
+	    !(read_tags(vg->vgmem, &vg->tags, cv))) {
 		log_error("Couldn't read tags for volume group %s.", vg->name);
 		goto bad;
 	}
@@ -1031,11 +970,6 @@ static void _read_desc(struct dm_pool *mem,
 	*when = u;
 }
 
-/*
- * It would be more accurate to call this _read_vgsummary().
- * It is used to read vgsummary information about a VG
- * before locking and reading the VG via vg_read().
- */
 static int _read_vgname(const struct format_type *fmt, const struct dm_config_tree *cft, 
 			struct lvmcache_vgsummary *vgsummary)
 {
@@ -1072,8 +1006,6 @@ static int _read_vgname(const struct format_type *fmt, const struct dm_config_tr
 		return 0;
 	}
 
-	dm_config_get_str(vgn, "lock_type", &vgsummary->lock_type);
-
 	return 1;
 }
 

lib/format_text/tags.c

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "metadata.h"
+#include "import-export.h"
+#include "str_list.h"
+#include "lvm-string.h"
+
+char *alloc_printed_tags(struct dm_list *tagsl)
+{
+	struct dm_str_list *sl;
+	int first = 1;
+	size_t size = 0;
+	char *buffer, *buf;
+
+	dm_list_iterate_items(sl, tagsl)
+		/* '"' + tag + '"' + ',' + ' ' */
+		size += strlen(sl->str) + 4;
+	/* '[' + ']' + '\0' */
+	size += 3;
+
+	if (!(buffer = buf = dm_malloc(size))) {
+		log_error("Could not allocate memory for tag list buffer.");
+		return NULL;
+	}
+
+	if (!emit_to_buffer(&buf, &size, "["))
+		goto_bad;
+
+	dm_list_iterate_items(sl, tagsl) {
+		if (!first) {
+			if (!emit_to_buffer(&buf, &size, ", "))
+				goto_bad;
+		} else
+			first = 0;
+
+		if (!emit_to_buffer(&buf, &size, "\"%s\"", sl->str))
+			goto_bad;
+	}
+
+	if (!emit_to_buffer(&buf, &size, "]"))
+		goto_bad;
+
+	return buffer;
+
+bad:
+	dm_free(buffer);
+	return_NULL;
+}
+
+int read_tags(struct dm_pool *mem, struct dm_list *tagsl, const struct dm_config_value *cv)
+{
+	if (cv->type == DM_CFG_EMPTY_ARRAY)
+		return 1;
+
+	while (cv) {
+		if (cv->type != DM_CFG_STRING) {
+			log_error("Found a tag that is not a string");
+			return 0;
+		}
+
+		if (!str_list_add(mem, tagsl, dm_pool_strdup(mem, cv->v.str)))
+			return_0;
+
+		cv = cv->next;
+	}
+
+	return 1;
+}

lib/freeseg/freeseg.c

@@ -33,7 +33,7 @@ struct segment_type *init_free_segtype(struct cmd_context *cmd)
 		return_NULL;
 
 	segtype->ops = &_freeseg_ops;
-	segtype->name = SEG_TYPE_NAME_FREE;
+	segtype->name = "free";
 	segtype->flags = SEG_VIRTUAL | SEG_CANNOT_BE_ZEROED;
 
 	log_very_verbose("Initialised segtype: %s", segtype->name);

lib/label/label.c

@@ -105,8 +105,7 @@ static void _update_lvmcache_orphan(struct lvmcache_info *info)
 
         memcpy(&vgsummary_orphan.vgid, lvmcache_fmt(info)->orphan_vg_name, strlen(lvmcache_fmt(info)->orphan_vg_name));
 
-	if (!lvmcache_update_vgname_and_id(info, &vgsummary_orphan))
-		stack;
+	lvmcache_update_vgname_and_id(info, &vgsummary_orphan);
 }
 
 static struct labeller *_find_labeller(struct device *dev, char *buf,

lib/locking/locking.c

@@ -119,9 +119,8 @@ int init_locking(int type, struct cmd_context *cmd, int suppress_messages)
 	switch (type) {
 	case 0:
 		init_no_locking(&_locking, cmd, suppress_messages);
-		log_warn_suppress(suppress_messages,
-			"WARNING: Locking disabled. Be careful! "
-			"This could corrupt your metadata.");
+		log_warn("WARNING: Locking disabled. Be careful! "
+			  "This could corrupt your metadata.");
 		return 1;
 
 	case 1:

lib/locking/locking.h

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

lib/locking/lvmlockd.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2015 Red Hat, Inc.
+ * Copyright (C) 2014 Red Hat, Inc.
  *
  * This file is part of LVM2.
  *
@@ -17,17 +17,25 @@
 #define LOCKD_SANLOCK_LV_NAME "lvmlock"
 
 /* lockd_gl flags */
-#define LDGL_UPDATE_NAMES         0x00000001
+#define LDGL_MODE_NOARG           0x00000001
+#define LDGL_SKIP_CACHE_VALIDATE  0x00000002
+#define LDGL_UPDATE_NAMES         0x00000004
+
+/* lockd_vg flags */
+#define LDVG_MODE_NOARG           0x00000001
 
 /* lockd_lv flags */
-#define LDLV_MODE_NO_SH           0x00000001
-#define LDLV_PERSISTENT           0x00000002
+#define LDLV_MODE_NOARG           0x00000001
+#define LDLV_MODE_NO_SH           0x00000002
+#define LDLV_PERSISTENT           0x00000004
 
 /* lvmlockd result flags */
 #define LD_RF_NO_LOCKSPACES     0x00000001
 #define LD_RF_NO_GL_LS          0x00000002
-#define LD_RF_WARN_GL_REMOVED   0x00000004
+#define LD_RF_LOCAL_LS          0x00000004
 #define LD_RF_DUP_GL_LS         0x00000008
+#define LD_RF_INACTIVE_LS       0x00000010
+#define LD_RF_ADD_LS_ERROR      0x00000020
 
 /* lockd_state flags */
 #define LDST_EX			0x00000001
@@ -38,6 +46,25 @@
 #define LDST_FAIL_OTHER		0x00000020
 #define LDST_FAIL		(LDST_FAIL_REQUEST | LDST_FAIL_NOLS | LDST_FAIL_STARTING | LDST_FAIL_OTHER)
 
+/*
+ * Check if a lock_type uses lvmlockd.
+ * If not (none, clvm), return 0.
+ * If so (dlm, sanlock), return 1.
+ */
+
+static inline int is_lockd_type(const char *lock_type)
+{
+	if (!lock_type)
+		return 0;
+
+	if (!strcmp(lock_type, "dlm"))
+		return 1;
+	if (!strcmp(lock_type, "sanlock"))
+		return 1;
+
+	return 0;
+}
+
 #ifdef LVMLOCKD_SUPPORT
 
 /* lvmlockd connection and communication */
@@ -51,8 +78,8 @@ void lvmlockd_disconnect(void);
 
 /* vgcreate/vgremove use init/free */
 
-int lockd_init_vg(struct cmd_context *cmd, struct volume_group *vg, const char *lock_type, int lv_lock_count);
-int lockd_free_vg_before(struct cmd_context *cmd, struct volume_group *vg, int changing);
+int lockd_init_vg(struct cmd_context *cmd, struct volume_group *vg, const char *lock_type);
+int lockd_free_vg_before(struct cmd_context *cmd, struct volume_group *vg);
 void lockd_free_vg_final(struct cmd_context *cmd, struct volume_group *vg);
 
 /* vgrename */
@@ -62,7 +89,7 @@ int lockd_rename_vg_final(struct cmd_context *cmd, struct volume_group *vg, int
 
 /* start and stop the lockspace for a vg */
 
-int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init);
+int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg);
 int lockd_stop_vg(struct cmd_context *cmd, struct volume_group *vg);
 int lockd_start_wait(struct cmd_context *cmd);
 
@@ -89,7 +116,7 @@ int lockd_init_lv_args(struct cmd_context *cmd, struct volume_group *vg,
 int lockd_free_lv(struct cmd_context *cmd, struct volume_group *vg,
 		  const char *lv_name, struct id *lv_id, const char *lock_args);
 
-const char *lockd_running_lock_type(struct cmd_context *cmd, int *found_multiple);
+const char *lockd_running_lock_type(struct cmd_context *cmd);
 
 int handle_sanlock_lv(struct cmd_context *cmd, struct volume_group *vg);
 
@@ -122,12 +149,12 @@ static inline int lvmlockd_use(void)
 	return 0;
 }
 
-static inline int lockd_init_vg(struct cmd_context *cmd, struct volume_group *vg, const char *lock_type, int lv_lock_count)
+static inline int lockd_init_vg(struct cmd_context *cmd, struct volume_group *vg, const char *lock_type)
 {
 	return 1;
 }
 
-static inline int lockd_free_vg_before(struct cmd_context *cmd, struct volume_group *vg, int changing)
+static inline int lockd_free_vg_before(struct cmd_context *cmd, struct volume_group *vg)
 {
 	return 1;
 }
@@ -147,7 +174,7 @@ static inline int lockd_rename_vg_final(struct cmd_context *cmd, struct volume_g
 	return 1;
 }
 
-static inline int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg, int start_init)
+static inline int lockd_start_vg(struct cmd_context *cmd, struct volume_group *vg)
 {
 	return 0;
 }
@@ -164,14 +191,6 @@ static inline int lockd_start_wait(struct cmd_context *cmd)
 
 static inline int lockd_gl_create(struct cmd_context *cmd, const char *def_mode, const char *vg_lock_type)
 {
-	/*
-	 * When lvm is built without lvmlockd support, creating a VG with
-	 * a shared lock type should fail.
-	 */
-	if (is_lockd_type(vg_lock_type)) {
-		log_error("Using a shared lock type requires lvmlockd.");
-		return 0;
-	}
 	return 1;
 }
 
@@ -183,7 +202,6 @@ static inline int lockd_gl(struct cmd_context *cmd, const char *def_mode, uint32
 static inline int lockd_vg(struct cmd_context *cmd, const char *vg_name, const char *def_mode,
 	     uint32_t flags, uint32_t *lockd_state)
 {
-	*lockd_state = 0;
 	return 1;
 }
 
@@ -208,24 +226,23 @@ static inline int lockd_lv(struct cmd_context *cmd, struct logical_volume *lv,
 static inline int lockd_init_lv(struct cmd_context *cmd, struct volume_group *vg,
 		  	struct logical_volume *lv, struct lvcreate_params *lp)
 {
-	return 1;
+	return 0;
 }
 
 static inline int lockd_init_lv_args(struct cmd_context *cmd, struct volume_group *vg,
 		       struct logical_volume *lv, const char *lock_type, const char **lock_args)
 {
-	return 1;
+	return 0;
 }
 
 static inline int lockd_free_lv(struct cmd_context *cmd, struct volume_group *vg,
 		  const char *lv_name, struct id *lv_id, const char *lock_args)
 {
-	return 1;
+	return 0;
 }
 
-static inline const char *lockd_running_lock_type(struct cmd_context *cmd, int *found_multiple)
+static inline const char *lockd_running_lock_type(struct cmd_context *cmd)
 {
-	log_error("Using a shared lock type requires lvmlockd.");
 	return NULL;
 }
 
@@ -239,6 +256,7 @@ static inline int lockd_lv_uses_lock(struct logical_volume *lv)
 	return 0;
 }
 
-#endif	/* LVMLOCKD_SUPPORT */
+#endif /* LVMLOCKD_SUPPORT */
+
+#endif
 
-#endif	/* _LVMLOCKD_H */

lib/locking/no_locking.c

@@ -19,6 +19,8 @@
 #include "lvm-string.h"
 #include "activate.h"
 
+#include <signal.h>
+
 /*
  * No locking
  */

lib/log/log.c

@@ -36,7 +36,7 @@ static int _indent = 1;
 static int _log_suppress = 0;
 static char _msg_prefix[30] = "  ";
 static int _already_logging = 0;
-static int _abort_on_internal_errors_config = 0;
+static int _abort_on_internal_errors = 0;
 
 static lvm2_log_fn_t _lvm2_log_fn = NULL;
 
@@ -49,7 +49,10 @@ static size_t _lvm_errmsg_len = 0;
 
 void init_log_fn(lvm2_log_fn_t log_fn)
 {
-	_lvm2_log_fn = log_fn;
+	if (log_fn)
+		_lvm2_log_fn = log_fn;
+	else
+		_lvm2_log_fn = NULL;
 }
 
 /*
@@ -66,7 +69,7 @@ void init_log_file(const char *log_file, int append)
 	static const char statfile[] = "/proc/self/stat";
 	const char *env;
 	int pid;
-	unsigned long long starttime;
+	long long starttime;
 	FILE *st;
 	int i = 0;
 
@@ -89,6 +92,9 @@ void init_log_file(const char *log_file, int append)
 			   "%llu", &pid, &starttime) != 2) {
 			log_warn("WARNING: Cannot parse content of %s.", statfile);
 		} else {
+			if (fclose(st))
+				log_sys_debug("fclose", statfile);
+
 			if (dm_snprintf(_log_file_path, sizeof(_log_file_path),
 					"%s_%s_%d_%lld", log_file, env, pid, starttime) < 0) {
 				log_warn("WARNING: Debug log file path is too long for epoch.");
@@ -98,11 +104,7 @@ void init_log_file(const char *log_file, int append)
 				append = 1; /* force */
 			}
 		}
-
-		if (st && fclose(st))
-			log_sys_debug("fclose", statfile);
 	}
-
 no_epoch:
 	if (!(_log_file = fopen(log_file, append ? "a" : "w"))) {
 		log_sys_error("fopen", log_file);
@@ -215,10 +217,9 @@ void init_indent(int indent)
 	_indent = indent;
 }
 
-/* If present, environment setting will override this. */
 void init_abort_on_internal_errors(int fatal)
 {
-	_abort_on_internal_errors_config = fatal;
+	_abort_on_internal_errors = fatal;
 }
 
 void reset_lvm_errno(int store_errmsg)
@@ -275,24 +276,10 @@ void print_log(int level, const char *file, int line, int dm_errno_or_class,
 	size_t msglen;
 	const char *indent_spaces = "";
 	FILE *stream;
-	static int _abort_on_internal_errors_env_present = -1;
-	static int _abort_on_internal_errors_env = 0;
-	char *env_str;
 
 	level &= ~(_LOG_STDERR|_LOG_ONCE);
 
-	if (_abort_on_internal_errors_env_present < 0) {
-		if ((env_str = getenv("DM_ABORT_ON_INTERNAL_ERRORS"))) {
-			_abort_on_internal_errors_env_present = 1;
-			/* Set when env DM_ABORT_ON_INTERNAL_ERRORS is not "0" */
-			_abort_on_internal_errors_env = strcmp(env_str, "0");
-		} else
-			_abort_on_internal_errors_env_present = 0;
-	}
-
-	/* Use value from environment if present, otherwise use value from config. */
-	if (((_abort_on_internal_errors_env_present && _abort_on_internal_errors_env) ||
-	     (!_abort_on_internal_errors_env_present && _abort_on_internal_errors_config)) &&
+	if (_abort_on_internal_errors &&
 	    !strncmp(format, INTERNAL_ERROR, sizeof(INTERNAL_ERROR) - 1)) {
 		fatal_internal_error = 1;
 		/* Internal errors triggering abort cannot be suppressed. */

lib/log/log.h

@@ -37,6 +37,8 @@
  *
  */
 
+#include <stdio.h>		/* FILE */
+#include <string.h>		/* strerror() */
 #include <errno.h>
 
 #define EUNCLASSIFIED -1	/* Generic error code */

lib/log/lvm-logging.h

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