pre-release

Update dmsetup man page.

Makefile.in

@@ -38,6 +38,7 @@ ifeq ($(MAKECMDGOALS),distclean)
 	     lib/snapshot \
 	     po \
 	     test/mm test/device test/format1 test/regex test/filters
+  DISTCLEAN_TARGETS += lib/misc/configure.h
 endif
 
 include make.tmpl

VERSION

@@ -1 +1 @@
-2.02.06-cvs (2006-04-21)
+2.02.07-cvs (2006-07-17)

WHATS_NEW

@@ -1,5 +1,33 @@
-Version 2.02.06 -
-=================================
+Version 2.02.07 - 17th July 2006
+================================
+  Fix activation logic in lvchange --persistent.
+  Don't ignore persistent minor numbers when activating.
+  Use RTLD_GLOBAL when loading shared libraries.
+  Add some forgotten memlock checks to _vg_read to protect against full scans.
+  Add mutex to dmeventd_mirror to avoid concurrent execution.
+  Fix vgreduce --removemissing to return success if VG is already consistent.
+  Fix return code if VG specified on command line is not found.
+  Fix PV tools to include orphaned PVs in default output again.
+  Fixed unaligned access when using clvm.
+  Fix an extra dev_close in a label_read error path.
+  Append patches to commit emails.
+  Fix target_register_events args.
+  Prevent snapshots of mirrors.
+  Add DISTCLEAN_TARGETS to make template for configure.h.
+  More fixes to error paths.
+  Fix lvcreate corelog validation.
+  Add --config for overriding most config file settings from cmdline.
+  Quote arguments when printing command line.
+  Remove linefeed from 'initialising logging' message.
+  Add 'Completed' debug message.
+  Don't attempt library exit after reloading config files.
+  Always compile with libdevmapper, even if device-mapper is disabled.
+
+Version 2.02.06 - 12th May 2006
+===============================
+  Propagate --monitor around cluster.
+  Add --monitor to vgcreate and lvcreate to control dmeventd registration.
+  Filter LCK_NONBLOCK in clvmd lock_vg.
   Add --nosync to lvcreate with LV flag NOTSYNCED.
   Use mirror's uuid for a core log.
   Add mirror log fault-handling policy.

WHATS_NEW_DM

@@ -1,3 +1,14 @@
+Version 1.02.08 - 17 July 2006
+==============================
+  Append full patch to check in emails.
+  Avoid duplicate dmeventd subdir with 'make distclean'.
+  Update dmsetup man page.
+  Add --force to dmsetup remove* to load error target.
+  dmsetup remove_all also performs mknodes.
+  Don't suppress identical table reloads if permission changes.
+  Fix corelog segment line.
+  Suppress some compiler warnings.
+
 Version 1.02.07 - 11 May 2006
 =============================
   Add DM_CORELOG flag to dm_tree_node_add_mirror_target().

configure

@@ -10699,7 +10699,6 @@ done
 
 fi
 
-if test x$DEVMAPPER = xyes; then
 
 for ac_header in libdevmapper.h
 do
@@ -10854,7 +10853,6 @@ fi
 
 done
 
-fi
 
 if test x$HAVE_SELINUX = xyes; then
 
@@ -11053,45 +11051,6 @@ else
 echo "${ECHO_T}no" >&6
 fi
 
-# Extract the first word of "ifconfig", so it can be a program name with args.
-set dummy ifconfig; ac_word=$2
-echo "$as_me:$LINENO: checking for $ac_word" >&5
-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
-if test "${ac_cv_path_MODPROBE_CMD+set}" = set; then
-  echo $ECHO_N "(cached) $ECHO_C" >&6
-else
-  case $MODPROBE_CMD in
-  [\\/]* | ?:[\\/]*)
-  ac_cv_path_MODPROBE_CMD="$MODPROBE_CMD" # Let the user override the test with a path.
-  ;;
-  *)
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-  for ac_exec_ext in '' $ac_executable_extensions; do
-  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_path_MODPROBE_CMD="$as_dir/$ac_word$ac_exec_ext"
-    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-done
-
-  ;;
-esac
-fi
-MODPROBE_CMD=$ac_cv_path_MODPROBE_CMD
-
-if test -n "$MODPROBE_CMD"; then
-  echo "$as_me:$LINENO: result: $MODPROBE_CMD" >&5
-echo "${ECHO_T}$MODPROBE_CMD" >&6
-else
-  echo "$as_me:$LINENO: result: no" >&5
-echo "${ECHO_T}no" >&6
-fi
-
 
 if test x$MODPROBE_CMD != x; then
 

configure.in

@@ -538,9 +538,7 @@ if test x$INTL = xyes; then
 	AC_CHECK_HEADERS(libintl.h,,AC_MSG_ERROR(bailing out))
 fi
 
-if test x$DEVMAPPER = xyes; then
-	AC_CHECK_HEADERS(libdevmapper.h,,AC_MSG_ERROR(bailing out))
-fi
+AC_CHECK_HEADERS(libdevmapper.h,,AC_MSG_ERROR(bailing out))
 
 if test x$HAVE_SELINUX = xyes; then
 	AC_CHECK_HEADERS(selinux/selinux.h,,AC_MSG_ERROR(bailing out))

daemons/clvmd/Makefile.in

@@ -59,9 +59,7 @@ ifeq ("@DMEVENTD@", "yes")
 	LVMLIBS += -ldevmapper-event
 endif
  
-ifeq ("@DEVMAPPER@", "yes")
-	LVMLIBS += -ldevmapper
-endif
+LVMLIBS += -ldevmapper
 
 DEFS += -D_REENTRANT
 CFLAGS += -fno-strict-aliasing

daemons/clvmd/clvmd-command.c

@@ -180,7 +180,7 @@ static int lock_vg(struct local_client *client)
     }
     else {
 
-	status = sync_lock(lockname, (int)lock_cmd, (int)lock_flags, &lkid);
+	status = sync_lock(lockname, (int)lock_cmd, (lock_flags & LCK_NONBLOCK) ? LKF_NOQUEUE : 0, &lkid);
 	if (status)
 	    status = errno;
 	else

daemons/clvmd/lvm-functions.c

@@ -45,6 +45,7 @@
 #include "log.h"
 #include "activate.h"
 #include "locking.h"
+#include "defaults.h"
 
 static struct cmd_context *cmd = NULL;
 static struct dm_hash_table *lv_hash = NULL;
@@ -309,6 +310,9 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 	if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
 		init_mirror_in_sync(1);
 
+	if (!(lock_flags & LCK_DMEVENTD_REGISTER_MODE))
+		init_dmeventd_register(0);
+
 	switch (command) {
 	case LCK_LV_EXCLUSIVE:
 		status = do_activate_lv(resource, lock_flags, LKM_EXMODE);
@@ -340,6 +344,12 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 	if (lock_flags & LCK_PARTIAL_MODE)
 		init_partial(0);
 
+	if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
+		init_mirror_in_sync(0);
+
+	if (!(lock_flags & LCK_DMEVENTD_REGISTER_MODE))
+		init_dmeventd_register(DEFAULT_DMEVENTD_MONITOR);
+
 	/* clean the pool for another command */
 	dm_pool_empty(cmd->mem);
 
@@ -500,7 +510,7 @@ static void check_config()
 {
 	int locking_type;
 
-	locking_type = find_config_int(cmd->cft->root, "global/locking_type", 1);
+	locking_type = find_config_tree_int(cmd, "global/locking_type", 1);
 
 	if (locking_type == 3) /* compiled-in cluster support */
 		return;
@@ -508,7 +518,7 @@ static void check_config()
 	if (locking_type == 2) { /* External library, check name */
 		const char *libname;
 
-		libname = find_config_str(cmd->cft->root, "global/locking_library",
+		libname = find_config_tree_str(cmd, "global/locking_library",
 					  "");
 		if (strstr(libname, "liblvm2clusterlock.so"))
 			return;

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -31,6 +31,8 @@
 #define ME_INSYNC    1
 #define ME_FAILURE   2
 
+static pthread_mutex_t _lock = PTHREAD_MUTEX_INITIALIZER;
+
 /* FIXME: We may need to lock around operations to these */
 static int register_count = 0;
 static struct dm_pool *mem_pool = NULL;
@@ -150,6 +152,10 @@ void process_event(const char *device, enum dm_event_type event)
 	char *target_type = NULL;
 	char *params;
 
+	if (pthread_mutex_trylock(&_lock)) {
+		syslog(LOG_NOTICE, "Another thread is handling an event.  Waiting...");
+		pthread_mutex_lock(&_lock);
+	}
 	/* FIXME Move inside libdevmapper */
 	if (!(dmt = dm_task_create(DM_DEVICE_STATUS))) {
 		syslog(LOG_ERR, "Unable to create dm_task.\n");
@@ -204,6 +210,7 @@ void process_event(const char *device, enum dm_event_type event)
  fail:
 	if (dmt)
 		dm_task_destroy(dmt);
+	pthread_mutex_unlock(&_lock);
 }
 
 int register_device(const char *device)

dmeventd/mirror/dmeventd_mirror.c

@@ -31,6 +31,8 @@
 #define ME_INSYNC    1
 #define ME_FAILURE   2
 
+static pthread_mutex_t _lock = PTHREAD_MUTEX_INITIALIZER;
+
 /* FIXME: We may need to lock around operations to these */
 static int register_count = 0;
 static struct dm_pool *mem_pool = NULL;
@@ -150,6 +152,10 @@ void process_event(const char *device, enum dm_event_type event)
 	char *target_type = NULL;
 	char *params;
 
+	if (pthread_mutex_trylock(&_lock)) {
+		syslog(LOG_NOTICE, "Another thread is handling an event.  Waiting...");
+		pthread_mutex_lock(&_lock);
+	}
 	/* FIXME Move inside libdevmapper */
 	if (!(dmt = dm_task_create(DM_DEVICE_STATUS))) {
 		syslog(LOG_ERR, "Unable to create dm_task.\n");
@@ -204,6 +210,7 @@ void process_event(const char *device, enum dm_event_type event)
  fail:
 	if (dmt)
 		dm_task_destroy(dmt);
+	pthread_mutex_unlock(&_lock);
 }
 
 int register_device(const char *device)

doc/example.conf

@@ -295,7 +295,7 @@ activation {
     #            device and space can be allocated for the replacement.
 
     mirror_log_fault_policy = "allocate"
-    mirror_dev_fault_policy = "remove"
+    mirror_device_fault_policy = "remove"
 }
 
 

lib/activate/activate.c

@@ -152,11 +152,16 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
 }
 
 int pv_uses_vg(struct cmd_context *cmd, struct physical_volume *pv,
-               struct volume_group *vg)
+	       struct volume_group *vg)
 {
 	return 0;
 }
 
+void activation_release(void)
+{
+	return;
+}
+
 void activation_exit(void)
 {
 	return;
@@ -193,7 +198,7 @@ static int _passes_activation_filter(struct cmd_context *cmd,
 	char *str;
 	char path[PATH_MAX];
 
-	if (!(cn = find_config_node(cmd->cft->root, "activation/volume_list"))) {
+	if (!(cn = find_config_tree_node(cmd, "activation/volume_list"))) {
 		/* If no host tags defined, activate */
 		if (list_empty(&cmd->tags))
 			return 1;
@@ -574,14 +579,29 @@ int lvs_in_vg_opened(struct volume_group *vg)
 	return count;
 }
 
-static int _register_dev_for_events(struct cmd_context *cmd,
-				    struct logical_volume *lv, int do_reg)
+/*
+ * register_dev_for_events
+ *
+ * This function uses proper error codes (but breaks convention)
+ * to return:
+ *      -1 on error
+ *       0 if the lv's targets don't do event [un]registration
+ *       0 if the lv is already [un]registered -- FIXME: not implemented
+ *       1 if the lv had a segment which was [un]registered
+ *
+ * Returns: -1 on error
+ */
+int register_dev_for_events(struct cmd_context *cmd,
+			    struct logical_volume *lv, int do_reg)
 {
 #ifdef DMEVENTD
+	int r = 0;
 	struct list *tmp;
 	struct lv_segment *seg;
-	int (*reg) (struct dm_pool *mem, struct lv_segment *,
-		    struct config_tree *cft, int events);
+	int (*reg) (struct lv_segment *, int events);
+
+	if (do_reg && !dmeventd_register_mode())
+		return 1;
 
 	list_iterate(tmp, &lv->segments) {
 		seg = list_item(tmp, struct lv_segment);
@@ -595,17 +615,21 @@ static int _register_dev_for_events(struct cmd_context *cmd,
 			reg = seg->segtype->ops->target_unregister_events;
 
 		if (!reg)
-			return_0;
+			continue;
 
-			/* FIXME specify events */
-		if (!reg(cmd->mem, seg, cmd->cft, 0)) {
+		/* FIXME specify events */
+		if (!reg(seg, 0)) {
 			stack;
-			return 0;
+			return -1;
 		}
+
+		r = 1;
 	}
 
-#endif
+	return r;
+#else
 	return 1;
+#endif
 }
 
 static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
@@ -643,7 +667,7 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 		}
 	}
 
-	if (!_register_dev_for_events(cmd, lv, 0))
+	if (register_dev_for_events(cmd, lv, 0) != 1)
 		/* FIXME Consider aborting here */
 		stack;
 
@@ -697,7 +721,7 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 	memlock_dec();
 	fs_unlock();
 
-	if (!_register_dev_for_events(cmd, lv, 1))
+	if (register_dev_for_events(cmd, lv, 1) != 1)
 		stack;
 
 	return 1;
@@ -743,7 +767,7 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
 		return 0;
 	}
 
-	if (!_register_dev_for_events(cmd, lv, 0))
+	if (register_dev_for_events(cmd, lv, 0) != 1)
 		stack;
 
 	memlock_inc();
@@ -816,7 +840,7 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
 	memlock_dec();
 	fs_unlock();
 
-	if (!_register_dev_for_events(cmd, lv, 1))
+	if (!register_dev_for_events(cmd, lv, 1) != 1)
 		stack;
 
 	return r;
@@ -863,7 +887,7 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
  * Returns 1 on failure.
  */
 int pv_uses_vg(struct physical_volume *pv,
-               struct volume_group *vg)
+	       struct volume_group *vg)
 {
 	if (!activation())
 		return 0;
@@ -874,6 +898,11 @@ int pv_uses_vg(struct physical_volume *pv,
 	return dev_manager_device_uses_vg(pv->dev, vg);
 }
 
+void activation_release(void)
+{
+	dev_manager_release();
+}
+
 void activation_exit(void)
 {
 	dev_manager_exit();

lib/activate/activate.h

@@ -40,6 +40,7 @@ int target_present(const char *target_name, int use_modprobe);
 int target_version(const char *target_name, uint32_t *maj,
                    uint32_t *min, uint32_t *patchlevel);
 
+void activation_release(void);
 void activation_exit(void);
 
 int lv_suspend(struct cmd_context *cmd, const char *lvid_s);
@@ -80,6 +81,10 @@ int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv,
 int lvs_in_vg_activated(struct volume_group *vg);
 int lvs_in_vg_opened(struct volume_group *vg);
 
+
+int register_dev_for_events(struct cmd_context *cmd,
+			    struct logical_volume *lv, int do_reg);
+
 /*
  * Returns 1 if PV has a dependency tree that uses anything in VG.
  */

lib/activate/dev_manager.c

@@ -329,7 +329,7 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 
 		if (segtype->ops->target_percent &&
 		    !segtype->ops->target_percent(&dm->target_state, dm->mem,
-						  dm->cmd->cft, seg, params,
+						  dm->cmd, seg, params,
 						  &total_numerator,
 						  &total_denominator,
 						  percent))
@@ -401,7 +401,7 @@ struct dev_manager *dev_manager_create(struct cmd_context *cmd,
 	dm->mem = mem;
 
 	if (!stripe_filler) {
-		stripe_filler = find_config_str(cmd->cft->root,
+		stripe_filler = find_config_tree_str(cmd,
 						"activation/missing_stripe_filler",
 						DEFAULT_STRIPE_FILLER);
 	}
@@ -426,6 +426,11 @@ void dev_manager_destroy(struct dev_manager *dm)
 	dm_pool_destroy(dm->mem);
 }
 
+void dev_manager_release(void)
+{
+	dm_lib_release();
+}
+
 void dev_manager_exit(void)
 {
 	dm_lib_exit();
@@ -758,7 +763,7 @@ static int _add_target_to_dtree(struct dev_manager *dm,
 		return 0;
 	}
 
-	return seg->segtype->ops->add_target_line(dm, dm->mem, dm->cmd->cft,
+	return seg->segtype->ops->add_target_line(dm, dm->mem, dm->cmd,
 						  &dm->target_state, seg,
 						  dnode,
 						  extent_size * seg->len,
@@ -861,8 +866,8 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	 * Major/minor settings only apply to the visible layer.
 	 */
 	if (!(dnode = dm_tree_add_new_dev(dtree, name, dlid,
-					     layer ? (uint32_t) lv->major : UINT32_C(0),
-					     layer ? (uint32_t) lv->minor : UINT32_C(0),
+					     layer ? UINT32_C(0) : (uint32_t) lv->major,
+					     layer ? UINT32_C(0) : (uint32_t) lv->minor,
 					     _read_only_lv(lv),
 					     (lv->vg->status & PRECOMMITTED) ? 1 : 0,
 					     lvlayer)))

lib/activate/dev_manager.h

@@ -29,6 +29,7 @@ struct device;
 struct dev_manager *dev_manager_create(struct cmd_context *cmd,
 				       const char *vg_name);
 void dev_manager_destroy(struct dev_manager *dm);
+void dev_manager_release(void);
 void dev_manager_exit(void);
 
 /*

lib/cache/lvmcache.c

@@ -169,14 +169,18 @@ struct lvmcache_vginfo *vginfo_from_vgid(const char *vgid)
 const char *vgname_from_vgid(struct dm_pool *mem, const char *vgid)
 {
 	struct lvmcache_vginfo *vginfo;
+	const char *vgname = NULL;
 
-	if ((vginfo = vginfo_from_vgid(vgid))) {
-		if (mem)
-			return dm_pool_strdup(mem, vginfo->vgname);
-		return vginfo->vgname;
-	}
+	if (!*vgid)
+		vgname = ORPHAN;
 
-	return NULL;
+	if ((vginfo = vginfo_from_vgid(vgid)))
+		vgname = vginfo->vgname;
+
+	if (mem && vgname)
+		return dm_pool_strdup(mem, vgname);
+
+	return vgname;
 }
 
 struct lvmcache_info *info_from_pvid(const char *pvid)

lib/commands/toolcontext.c

@@ -84,10 +84,11 @@ static void _init_logging(struct cmd_context *cmd)
 	time_t t;
 
 	const char *log_file;
+	char timebuf[26];
 
 	/* Syslog */
 	cmd->default_settings.syslog =
-	    find_config_int(cmd->cft->root, "log/syslog", DEFAULT_SYSLOG);
+	    find_config_tree_int(cmd, "log/syslog", DEFAULT_SYSLOG);
 	if (cmd->default_settings.syslog != 1)
 		fin_syslog();
 
@@ -96,37 +97,37 @@ static void _init_logging(struct cmd_context *cmd)
 
 	/* Debug level for log file output */
 	cmd->default_settings.debug =
-	    find_config_int(cmd->cft->root, "log/level", DEFAULT_LOGLEVEL);
+	    find_config_tree_int(cmd, "log/level", DEFAULT_LOGLEVEL);
 	init_debug(cmd->default_settings.debug);
 
 	/* Verbose level for tty output */
 	cmd->default_settings.verbose =
-	    find_config_int(cmd->cft->root, "log/verbose", DEFAULT_VERBOSE);
+	    find_config_tree_int(cmd, "log/verbose", DEFAULT_VERBOSE);
 	init_verbose(cmd->default_settings.verbose + VERBOSE_BASE_LEVEL);
 
 	/* Log message formatting */
-	init_indent(find_config_int(cmd->cft->root, "log/indent",
+	init_indent(find_config_tree_int(cmd, "log/indent",
 				    DEFAULT_INDENT));
 
-	cmd->default_settings.msg_prefix = find_config_str(cmd->cft->root,
+	cmd->default_settings.msg_prefix = find_config_tree_str(cmd,
 							   "log/prefix",
 							   DEFAULT_MSG_PREFIX);
 	init_msg_prefix(cmd->default_settings.msg_prefix);
 
-	cmd->default_settings.cmd_name = find_config_int(cmd->cft->root,
+	cmd->default_settings.cmd_name = find_config_tree_int(cmd,
 							 "log/command_names",
 							 DEFAULT_CMD_NAME);
 	init_cmd_name(cmd->default_settings.cmd_name);
 
 	/* Test mode */
 	cmd->default_settings.test =
-	    find_config_int(cmd->cft->root, "global/test", 0);
+	    find_config_tree_int(cmd, "global/test", 0);
 
 	/* Settings for logging to file */
-	if (find_config_int(cmd->cft->root, "log/overwrite", DEFAULT_OVERWRITE))
+	if (find_config_tree_int(cmd, "log/overwrite", DEFAULT_OVERWRITE))
 		append = 0;
 
-	log_file = find_config_str(cmd->cft->root, "log/file", 0);
+	log_file = find_config_tree_str(cmd, "log/file", 0);
 
 	if (log_file) {
 		release_log_memory();
@@ -134,15 +135,17 @@ static void _init_logging(struct cmd_context *cmd)
 		init_log_file(log_file, append);
 	}
 
-	log_file = find_config_str(cmd->cft->root, "log/activate_file", 0);
+	log_file = find_config_tree_str(cmd, "log/activate_file", 0);
 	if (log_file)
 		init_log_direct(log_file, append);
 
-	init_log_while_suspended(find_config_int(cmd->cft->root,
+	init_log_while_suspended(find_config_tree_int(cmd,
 						 "log/activation", 0));
 
 	t = time(NULL);
-	log_verbose("Logging initialised at %s", ctime(&t));
+	ctime_r(&t, &timebuf[0]);
+	timebuf[24] = '\0';
+	log_verbose("Logging initialised at %s", timebuf);
 
 	/* Tell device-mapper about our logging */
 #ifdef DEVMAPPER_SUPPORT
@@ -155,7 +158,7 @@ static int _process_config(struct cmd_context *cmd)
 	mode_t old_umask;
 
 	/* umask */
-	cmd->default_settings.umask = find_config_int(cmd->cft->root,
+	cmd->default_settings.umask = find_config_tree_int(cmd,
 						      "global/umask",
 						      DEFAULT_UMASK);
 
@@ -165,7 +168,7 @@ static int _process_config(struct cmd_context *cmd)
 
 	/* dev dir */
 	if (lvm_snprintf(cmd->dev_dir, sizeof(cmd->dev_dir), "%s/",
-			 find_config_str(cmd->cft->root, "devices/dir",
+			 find_config_tree_str(cmd, "devices/dir",
 					 DEFAULT_DEV_DIR)) < 0) {
 		log_error("Device directory given in config file too long");
 		return 0;
@@ -176,7 +179,7 @@ static int _process_config(struct cmd_context *cmd)
 
 	/* proc dir */
 	if (lvm_snprintf(cmd->proc_dir, sizeof(cmd->proc_dir), "%s",
-			 find_config_str(cmd->cft->root, "global/proc",
+			 find_config_tree_str(cmd, "global/proc",
 					 DEFAULT_PROC_DIR)) < 0) {
 		log_error("Device directory given in config file too long");
 		return 0;
@@ -189,17 +192,17 @@ static int _process_config(struct cmd_context *cmd)
 	}
 
 	/* activation? */
-	cmd->default_settings.activation = find_config_int(cmd->cft->root,
+	cmd->default_settings.activation = find_config_tree_int(cmd,
 							   "global/activation",
 							   DEFAULT_ACTIVATION);
 	set_activation(cmd->default_settings.activation);
 
-	cmd->default_settings.suffix = find_config_int(cmd->cft->root,
+	cmd->default_settings.suffix = find_config_tree_int(cmd,
 						       "global/suffix",
 						       DEFAULT_SUFFIX);
 
 	if (!(cmd->default_settings.unit_factor =
-	      units_to_bytes(find_config_str(cmd->cft->root,
+	      units_to_bytes(find_config_tree_str(cmd,
 					     "global/units",
 					     DEFAULT_UNITS),
 			     &cmd->default_settings.unit_type))) {
@@ -469,7 +472,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
 		return 0;
 	}
 
-	if (!(cn = find_config_node(cmd->cft->root, "devices/scan"))) {
+	if (!(cn = find_config_tree_node(cmd, "devices/scan"))) {
 		if (!dev_cache_add_dir("/dev")) {
 			log_error("Failed to add /dev to internal "
 				  "device cache");
@@ -494,7 +497,7 @@ static int _init_dev_cache(struct cmd_context *cmd)
 		}
 	}
 
-	if (!(cn = find_config_node(cmd->cft->root, "devices/loopfiles")))
+	if (!(cn = find_config_tree_node(cmd, "devices/loopfiles")))
 		return 1;
 
 	for (cv = cn->v; cv; cv = cv->next) {
@@ -536,14 +539,14 @@ static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
 	 * Listed first because it's very efficient at eliminating 
 	 * unavailable devices.
 	 */
-	if (find_config_bool(cmd->cft->root, "devices/sysfs_scan",
+	if (find_config_tree_bool(cmd, "devices/sysfs_scan",
 			     DEFAULT_SYSFS_SCAN)) {
 		if ((filters[nr_filt] = sysfs_filter_create(cmd->proc_dir)))
 			nr_filt++;
 	}
 
 	/* regex filter. Optional. */
-	if (!(cn = find_config_node(cmd->cft->root, "devices/filter")))
+	if (!(cn = find_config_tree_node(cmd, "devices/filter")))
 		log_very_verbose("devices/filter not found in config file: "
 				 "no regex filter installed");
 
@@ -553,14 +556,14 @@ static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
 	}
 
 	/* device type filter. Required. */
-	cn = find_config_node(cmd->cft->root, "devices/types");
+	cn = find_config_tree_node(cmd, "devices/types");
 	if (!(filters[nr_filt++] = lvm_type_filter_create(cmd->proc_dir, cn))) {
 		log_error("Failed to create lvm type filter");
 		return NULL;
 	}
 
 	/* md component filter. Optional, non-critical. */
-	if (find_config_bool(cmd->cft->root, "devices/md_component_detection",
+	if (find_config_tree_bool(cmd, "devices/md_component_detection",
 			     DEFAULT_MD_COMPONENT_DETECTION)) {
 		init_md_filtering(1);
 		if ((filters[nr_filt] = md_filter_create()))
@@ -591,7 +594,7 @@ static int _init_filters(struct cmd_context *cmd)
 		return 0;
 	}
 
-	dev_cache = find_config_str(cmd->cft->root, "devices/cache",
+	dev_cache = find_config_tree_str(cmd, "devices/cache",
 				    cache_file);
 	if (!(f4 = persistent_filter_create(f3, dev_cache))) {
 		log_error("Failed to create persistent device filter");
@@ -599,7 +602,7 @@ static int _init_filters(struct cmd_context *cmd)
 	}
 
 	/* Should we ever dump persistent filter state? */
-	if (find_config_int(cmd->cft->root, "devices/write_cache_state", 1))
+	if (find_config_tree_int(cmd, "devices/write_cache_state", 1))
 		cmd->dump_filter = 1;
 
 	if (!*cmd->sys_dir)
@@ -644,7 +647,7 @@ static int _init_formats(struct cmd_context *cmd)
 
 #ifdef HAVE_LIBDL
 	/* Load any formats in shared libs */
-	if ((cn = find_config_node(cmd->cft->root, "global/format_libraries"))) {
+	if ((cn = find_config_tree_node(cmd, "global/format_libraries"))) {
 
 		struct config_value *cv;
 		struct format_type *(*init_format_fn) (struct cmd_context *);
@@ -656,7 +659,7 @@ static int _init_formats(struct cmd_context *cmd)
 					  "global/format_libraries");
 				return 0;
 			}
-			if (!(lib = load_shared_library(cmd->cft, cv->v.str,
+			if (!(lib = load_shared_library(cmd, cv->v.str,
 							"format", 0))) {
 				stack;
 				return 0;
@@ -684,7 +687,7 @@ static int _init_formats(struct cmd_context *cmd)
 
 	cmd->fmt_backup = fmt;
 
-	format = find_config_str(cmd->cft->root, "global/format",
+	format = find_config_tree_str(cmd, "global/format",
 				 DEFAULT_FORMAT);
 
 	list_iterate_items(fmt, &cmd->formats) {
@@ -738,7 +741,7 @@ static int _init_segtypes(struct cmd_context *cmd)
 
 #ifdef HAVE_LIBDL
 	/* Load any formats in shared libs */
-	if ((cn = find_config_node(cmd->cft->root, "global/segment_libraries"))) {
+	if ((cn = find_config_tree_node(cmd, "global/segment_libraries"))) {
 
 		struct config_value *cv;
 		struct segment_type *(*init_segtype_fn) (struct cmd_context *);
@@ -752,7 +755,7 @@ static int _init_segtypes(struct cmd_context *cmd)
 					  "global/segment_libraries");
 				return 0;
 			}
-			if (!(lib = load_shared_library(cmd->cft, cv->v.str,
+			if (!(lib = load_shared_library(cmd, cv->v.str,
 							"segment type", 0))) {
 				stack;
 				return 0;
@@ -827,13 +830,13 @@ static int _init_backup(struct cmd_context *cmd)
 
 	/* set up archiving */
 	cmd->default_settings.archive =
-	    find_config_bool(cmd->cft->root, "backup/archive",
+	    find_config_tree_bool(cmd, "backup/archive",
 			     DEFAULT_ARCHIVE_ENABLED);
 
-	days = (uint32_t) find_config_int(cmd->cft->root, "backup/retain_days",
+	days = (uint32_t) find_config_tree_int(cmd, "backup/retain_days",
 					  DEFAULT_ARCHIVE_DAYS);
 
-	min = (uint32_t) find_config_int(cmd->cft->root, "backup/retain_min",
+	min = (uint32_t) find_config_tree_int(cmd, "backup/retain_min",
 					 DEFAULT_ARCHIVE_NUMBER);
 
 	if (lvm_snprintf
@@ -844,7 +847,7 @@ static int _init_backup(struct cmd_context *cmd)
 		return 0;
 	}
 
-	dir = find_config_str(cmd->cft->root, "backup/archive_dir",
+	dir = find_config_tree_str(cmd, "backup/archive_dir",
 			      default_dir);
 
 	if (!archive_init(cmd, dir, days, min)) {
@@ -854,7 +857,7 @@ static int _init_backup(struct cmd_context *cmd)
 
 	/* set up the backup */
 	cmd->default_settings.backup =
-	    find_config_bool(cmd->cft->root, "backup/backup",
+	    find_config_tree_bool(cmd, "backup/backup",
 			     DEFAULT_BACKUP_ENABLED);
 
 	if (lvm_snprintf
@@ -865,7 +868,7 @@ static int _init_backup(struct cmd_context *cmd)
 		return 0;
 	}
 
-	dir = find_config_str(cmd->cft->root, "backup/backup_dir", default_dir);
+	dir = find_config_tree_str(cmd, "backup/backup_dir", default_dir);
 
 	if (!backup_init(cmd, dir)) {
 		log_debug("backup_init failed.");
@@ -921,7 +924,7 @@ struct cmd_context *create_toolcontext(struct arg *the_args)
 
 	if (!(cmd->libmem = dm_pool_create("library", 4 * 1024))) {
 		log_error("Library memory pool creation failed");
-		return 0;
+		goto error;
 	}
 
 	if (!_init_lvm_conf(cmd))
@@ -1021,7 +1024,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
 			persistent_filter_dump(cmd->filter);
 	}
 
-	activation_exit();
+	activation_release();
 	lvmcache_destroy();
 	label_exit();
 	_destroy_segtypes(&cmd->segtypes);

lib/commands/toolcontext.h

@@ -71,6 +71,7 @@ struct cmd_context {
 	struct list config_files;
 	int config_valid;
 	struct config_tree *cft;
+	struct config_tree *cft_override;
 	struct config_info default_settings;
 	struct config_info current_settings;
 

lib/config/config.c

@@ -41,10 +41,10 @@ enum {
 };
 
 struct parser {
-	char *fb, *fe;		/* file limits */
+	const char *fb, *fe;		/* file limits */
 
 	int t;			/* token limits and type */
-	char *tb, *te;
+	const char *tb, *te;
 
 	int fd;			/* descriptor for file being parsed */
 	int line;		/* line number we are on */
@@ -77,7 +77,7 @@ static const int sep = '/';
 
 #define match(t) do {\
    if (!_match_aux(p, (t))) {\
-	log_error("Parse error at line %d: unexpected token", p->line); \
+	log_error("Parse error at byte %d (line %d): unexpected token", p->tb - p->fb + 1, p->line); \
       return 0;\
    } \
 } while(0);
@@ -101,12 +101,12 @@ struct config_tree *create_config_tree(const char *filename)
 	struct dm_pool *mem = dm_pool_create("config", 10 * 1024);
 
 	if (!mem) {
-		stack;
+		log_error("Failed to allocate config pool.");
 		return 0;
 	}
 
 	if (!(c = dm_pool_zalloc(mem, sizeof(*c)))) {
-		stack;
+		log_error("Failed to allocate config tree.");
 		dm_pool_destroy(mem);
 		return 0;
 	}
@@ -125,6 +125,46 @@ void destroy_config_tree(struct config_tree *cft)
 	dm_pool_destroy(((struct cs *) cft)->mem);
 }
 
+static int _parse_config_file(struct parser *p, struct config_tree *cft)
+{
+	p->tb = p->te = p->fb;
+	p->line = 1;
+	_get_token(p, TOK_SECTION_E);
+	if (!(cft->root = _file(p)))
+		return_0;
+
+	return 1;
+}
+
+struct config_tree *create_config_tree_from_string(struct cmd_context *cmd,
+						   const char *config_settings)
+{
+	struct cs *c;
+	struct config_tree *cft;
+	struct parser *p;
+
+	if (!(cft = create_config_tree(NULL)))
+		return_NULL;
+
+	c = (struct cs *) cft;
+	if (!(p = dm_pool_alloc(c->mem, sizeof(*p)))) {
+		log_error("Failed to allocate config tree parser.");
+		destroy_config_tree(cft);
+		return NULL;
+	}
+
+	p->mem = c->mem;
+	p->fb = config_settings;
+	p->fe = config_settings + strlen(config_settings);
+
+	if (!_parse_config_file(p, cft)) {
+		destroy_config_tree(cft);
+		return_NULL;
+	}
+
+	return cft;
+}
+
 int read_config_fd(struct config_tree *cft, struct device *dev,
 		   off_t offset, size_t size, off_t offset2, size_t size2,
 		   checksum_fn_t checksum_fn, uint32_t checksum)
@@ -134,6 +174,7 @@ int read_config_fd(struct config_tree *cft, struct device *dev,
 	int r = 0;
 	int use_mmap = 1;
 	off_t mmap_offset = 0;
+	char *buf;
 
 	if (!(p = dm_pool_alloc(c->mem, sizeof(*p)))) {
 		stack;
@@ -156,22 +197,23 @@ int read_config_fd(struct config_tree *cft, struct device *dev,
 		}
 		p->fb = p->fb + mmap_offset;
 	} else {
-		if (!(p->fb = dm_malloc(size + size2))) {
+		if (!(buf = dm_malloc(size + size2))) {
 			stack;
 			return 0;
 		}
-		if (!dev_read(dev, (uint64_t) offset, size, p->fb)) {
+		if (!dev_read(dev, (uint64_t) offset, size, buf)) {
 			log_error("Read from %s failed", dev_name(dev));
 			goto out;
 		}
 		if (size2) {
 			if (!dev_read(dev, (uint64_t) offset2, size2,
-				      p->fb + size)) {
+				      buf + size)) {
 				log_error("Circular read from %s failed",
 					  dev_name(dev));
 				goto out;
 			}
 		}
+		p->fb = buf;
 	}
 
 	if (checksum_fn && checksum !=
@@ -183,11 +225,7 @@ int read_config_fd(struct config_tree *cft, struct device *dev,
 
 	p->fe = p->fb + size + size2;
 
-	/* parse */
-	p->tb = p->te = p->fb;
-	p->line = 1;
-	_get_token(p, TOK_SECTION_E);
-	if (!(cft->root = _file(p))) {
+	if (!_parse_config_file(p, cft)) {
 		stack;
 		goto out;
 	}
@@ -196,7 +234,7 @@ int read_config_fd(struct config_tree *cft, struct device *dev,
 
       out:
 	if (!use_mmap)
-		dm_free(p->fb);
+		dm_free(buf);
 	else {
 		/* unmap the file */
 		if (munmap((char *) (p->fb - mmap_offset), size + mmap_offset)) {
@@ -529,7 +567,7 @@ static struct config_value *_type(struct parser *p)
 		break;
 
 	default:
-		log_error("Parse error at line %d: expected a value", p->line);
+		log_error("Parse error at byte %d (line %d): expected a value", p->tb - p->fb + 1, p->line);
 		return 0;
 	}
 	return v;
@@ -721,8 +759,8 @@ static char *_dup_tok(struct parser *p)
 /*
  * utility functions
  */
-struct config_node *find_config_node(const struct config_node *cn,
-				     const char *path)
+static struct config_node *_find_config_node(const struct config_node *cn,
+					     const char *path)
 {
 	const char *e;
 
@@ -753,10 +791,32 @@ struct config_node *find_config_node(const struct config_node *cn,
 	return (struct config_node *) cn;
 }
 
-const char *find_config_str(const struct config_node *cn,
-			    const char *path, const char *fail)
+static struct config_node *_find_first_config_node(const struct config_node *cn1,
+						   const struct config_node *cn2,
+						   const char *path)
 {
-	const struct config_node *n = find_config_node(cn, path);
+	struct config_node *cn;
+
+	if (cn1 && (cn = _find_config_node(cn1, path)))
+		return cn;
+
+	if (cn2 && (cn = _find_config_node(cn2, path)))
+		return cn;
+
+	return NULL;
+}
+
+struct config_node *find_config_node(const struct config_node *cn,
+				     const char *path)
+{
+	return _find_config_node(cn, path);
+}
+
+static const char *_find_config_str(const struct config_node *cn1,
+				    const struct config_node *cn2,
+				    const char *path, const char *fail)
+{
+	const struct config_node *n = _find_first_config_node(cn1, cn2, path);
 
 	/* Empty strings are ignored */
 	if ((n && n->v->type == CFG_STRING) && (*n->v->v.str)) {
@@ -770,9 +830,17 @@ const char *find_config_str(const struct config_node *cn,
 	return fail;
 }
 
-int find_config_int(const struct config_node *cn, const char *path, int fail)
+const char *find_config_str(const struct config_node *cn,
+			    const char *path, const char *fail)
 {
-	const struct config_node *n = find_config_node(cn, path);
+	return _find_config_str(cn, NULL, path, fail);
+}
+
+static int _find_config_int(const struct config_node *cn1,
+			    const struct config_node *cn2,
+			    const char *path, int fail)
+{
+	const struct config_node *n = _find_first_config_node(cn1, cn2, path);
 
 	if (n && n->v->type == CFG_INT) {
 		log_very_verbose("Setting %s to %d", path, n->v->v.i);
@@ -784,10 +852,16 @@ int find_config_int(const struct config_node *cn, const char *path, int fail)
 	return fail;
 }
 
-float find_config_float(const struct config_node *cn, const char *path,
-			float fail)
+int find_config_int(const struct config_node *cn, const char *path, int fail)
 {
-	const struct config_node *n = find_config_node(cn, path);
+	return _find_config_int(cn, NULL, path, fail);
+}
+
+static float _find_config_float(const struct config_node *cn1,
+				const struct config_node *cn2,
+				const char *path, float fail)
+{
+	const struct config_node *n = _find_first_config_node(cn1, cn2, path);
 
 	if (n && n->v->type == CFG_FLOAT) {
 		log_very_verbose("Setting %s to %f", path, n->v->v.r);
@@ -801,6 +875,36 @@ float find_config_float(const struct config_node *cn, const char *path,
 
 }
 
+float find_config_float(const struct config_node *cn, const char *path,
+			float fail)
+{
+	return _find_config_float(cn, NULL, path, fail);
+}
+
+struct config_node *find_config_tree_node(struct cmd_context *cmd,
+                                          const char *path)
+{
+	return _find_first_config_node(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path);
+}
+
+const char *find_config_tree_str(struct cmd_context *cmd,
+                                 const char *path, const char *fail)
+{
+	return _find_config_str(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
+}
+
+int find_config_tree_int(struct cmd_context *cmd, const char *path,
+                         int fail)
+{
+	return _find_config_int(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
+}
+
+float find_config_tree_float(struct cmd_context *cmd, const char *path,
+                             float fail)
+{
+	return _find_config_float(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
+}
+
 static int _str_in_array(const char *str, const char *values[])
 {
 	int i;
@@ -827,9 +931,11 @@ static int _str_to_bool(const char *str, int fail)
 	return fail;
 }
 
-int find_config_bool(const struct config_node *cn, const char *path, int fail)
+static int _find_config_bool(const struct config_node *cn1,
+			     const struct config_node *cn2,
+			     const char *path, int fail)
 {
-	const struct config_node *n = find_config_node(cn, path);
+	const struct config_node *n = _find_first_config_node(cn1, cn2, path);
 	struct config_value *v;
 
 	if (!n)
@@ -848,6 +954,16 @@ int find_config_bool(const struct config_node *cn, const char *path, int fail)
 	return fail;
 }
 
+int find_config_bool(const struct config_node *cn, const char *path, int fail)
+{
+	return _find_config_bool(cn, NULL, path, fail);
+}
+
+int find_config_tree_bool(struct cmd_context *cmd, const char *path, int fail)
+{
+	return _find_config_bool(cmd->cft_override ? cmd->cft_override->root : NULL, cmd->cft->root, path, fail);
+}
+
 int get_config_uint32(const struct config_node *cn, const char *path,
 		      uint32_t *result)
 {

lib/config/config.h

@@ -54,9 +54,11 @@ struct config_tree_list {
 };
 
 struct config_tree *create_config_tree(const char *filename);
+struct config_tree *create_config_tree_from_string(struct cmd_context *cmd,
+						   const char *config_settings);
 void destroy_config_tree(struct config_tree *cft);
 
-typedef uint32_t (*checksum_fn_t) (uint32_t initial, void *buf, uint32_t size);
+typedef uint32_t (*checksum_fn_t) (uint32_t initial, const void *buf, uint32_t size);
 
 int read_config_fd(struct config_tree *cft, struct device *dev,
 		   off_t offset, size_t size, off_t offset2, size_t size2,
@@ -71,20 +73,30 @@ int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
 
 struct config_node *find_config_node(const struct config_node *cn,
 				     const char *path);
-
 const char *find_config_str(const struct config_node *cn, const char *path,
 			    const char *fail);
-
 int find_config_int(const struct config_node *cn, const char *path, int fail);
-
 float find_config_float(const struct config_node *cn, const char *path,
 			float fail);
 
+/*
+ * These versions check an override tree, if present, first.
+ */
+struct config_node *find_config_tree_node(struct cmd_context *cmd,
+					  const char *path);
+const char *find_config_tree_str(struct cmd_context *cmd,
+				 const char *path, const char *fail);
+int find_config_tree_int(struct cmd_context *cmd, const char *path,
+			 int fail);
+float find_config_tree_float(struct cmd_context *cmd, const char *path,
+			     float fail);
+
 /*
  * Understands (0, ~0), (y, n), (yes, no), (on,
  * off), (true, false).
  */
 int find_config_bool(const struct config_node *cn, const char *path, int fail);
+int find_config_tree_bool(struct cmd_context *cmd, const char *path, int fail);
 
 int get_config_uint32(const struct config_node *cn, const char *path,
 		      uint32_t *result);

lib/config/defaults.h

@@ -37,6 +37,7 @@
 #define DEFAULT_MIRROR_LOG_FAULT_POLICY "allocate"
 #define DEFAULT_MIRROR_DEV_FAULT_POLICY "remove"
 #define DEFAULT_DMEVENTD_MIRROR_LIB "libdevmapper-event-lvm2mirror.so"
+#define DEFAULT_DMEVENTD_MONITOR 1
 
 #define DEFAULT_UMASK 0077
 

lib/error/errseg.c

@@ -40,7 +40,7 @@ static int _errseg_merge_segments(struct lv_segment *seg1, struct lv_segment *se
 #ifdef DEVMAPPER_SUPPORT
 static int _errseg_add_target_line(struct dev_manager *dm __attribute((unused)),
 				struct dm_pool *mem __attribute((unused)),
-				struct config_tree *cft __attribute((unused)),
+				struct cmd_context *cmd __attribute((unused)),
 				void **target_state __attribute((unused)),
 				struct lv_segment *seg __attribute((unused)),
 				struct dm_tree_node *node, uint64_t len,

lib/format_text/export.c

@@ -613,46 +613,27 @@ static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 	struct physical_volume *pv;
 	char buffer[32], *name;
 
-	if (!(f->mem = dm_pool_create("text pv_names", 512))) {
-		stack;
-		goto bad;
-	}
+	if (!(f->mem = dm_pool_create("text pv_names", 512)))
+		return_0;
 
-	if (!(f->pv_names = dm_hash_create(128))) {
-		stack;
-		goto bad;
-	}
+	if (!(f->pv_names = dm_hash_create(128)))
+		return_0;
 
 	list_iterate_items(pvl, &vg->pvs) {
 		pv = pvl->pv;
 
 		/* FIXME But skip if there's already an LV called pv%d ! */
-		if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0) {
-			stack;
-			goto bad;
-		}
+		if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0)
+			return_0;
 
-		if (!(name = dm_pool_strdup(f->mem, buffer))) {
-			stack;
-			goto bad;
-		}
+		if (!(name = dm_pool_strdup(f->mem, buffer)))
+			return_0;
 
-		if (!dm_hash_insert(f->pv_names, dev_name(pv->dev), name)) {
-			stack;
-			goto bad;
-		}
+		if (!dm_hash_insert(f->pv_names, dev_name(pv->dev), name))
+			return_0;
 	}
 
 	return 1;
-
-      bad:
-	if (f->mem)
-		dm_pool_destroy(f->mem);
-
-	if (f->pv_names)
-		dm_hash_destroy(f->pv_names);
-
-	return 0;
 }
 
 static int _text_vg_export(struct formatter *f,
@@ -664,35 +645,33 @@ static int _text_vg_export(struct formatter *f,
 		stack;
 		goto out;
 	}
-#define fail do {stack; goto out;} while(0)
 
 	if (f->header && !_print_header(f, desc))
-		fail;
+		goto_out;
 
 	if (!out_text(f, "%s {", vg->name))
-		fail;
+		goto_out;
 
 	_inc_indent(f);
 
 	if (!_print_vg(f, vg))
-		fail;
+		goto_out;
 
 	outnl(f);
 	if (!_print_pvs(f, vg))
-		fail;
+		goto_out;
 
 	outnl(f);
 	if (!_print_lvs(f, vg))
-		fail;
+		goto_out;
 
 	_dec_indent(f);
 	if (!out_text(f, "}"))
-		fail;
+		goto_out;
 
 	if (!f->header && !_print_header(f, desc))
-		fail;
+		goto_out;
 
-#undef fail
 	r = 1;
 
       out:

lib/format_text/format-text.c

@@ -1783,7 +1783,7 @@ struct format_type *create_text_format(struct cmd_context *cmd)
 		return NULL;
 	}
 
-	if ((cn = find_config_node(cmd->cft->root, "metadata/dirs"))) {
+	if ((cn = find_config_tree_node(cmd, "metadata/dirs"))) {
 		for (cv = cn->v; cv; cv = cv->next) {
 			if (cv->type != CFG_STRING) {
 				log_error("Invalid string in config file: "
@@ -1799,7 +1799,7 @@ struct format_type *create_text_format(struct cmd_context *cmd)
 		}
 	}
 
-	if ((cn = find_config_node(cmd->cft->root, "metadata/disk_areas"))) {
+	if ((cn = find_config_tree_node(cmd, "metadata/disk_areas"))) {
 		for (cn = cn->child; cn; cn = cn->sib) {
 			if (!_get_config_disk_area(cmd, cn, &mda_lists->raws))
 				goto err;

lib/label/label.c

@@ -271,7 +271,7 @@ int label_read(struct device *dev, struct label **result)
 			lvmcache_update_vgname_and_id(info, ORPHAN, ORPHAN,
 						      0, NULL);
 
-		goto out;
+		return r;
 	}
 
 	if (!(l = _find_labeller(dev, buf, &sector)))

lib/locking/cluster_locking.c

@@ -256,7 +256,7 @@ static int _cluster_request(char cmd, const char *node, void *data, int len,
 		strcpy(rarray[i].node, inptr);
 		inptr += strlen(inptr) + 1;
 
-		rarray[i].status = *(int *) inptr;
+		memcpy(&rarray[i].status, inptr, sizeof(int));
 		inptr += sizeof(int);
 
 		rarray[i].response = dm_malloc(strlen(inptr) + 1);
@@ -333,9 +333,12 @@ static int _lock_for_cluster(unsigned char cmd, unsigned int flags, char *name)
 	if (partial_mode())
 		args[1] |= LCK_PARTIAL_MODE;
 
-	if (mirror_sync())
+	if (mirror_in_sync())
 		args[1] |= LCK_MIRROR_NOSYNC_MODE;
 
+	if (dmeventd_register_mode())
+		args[1] |= LCK_DMEVENTD_REGISTER_MODE;
+
 	/*
 	 * VG locks are just that: locks, and have no side effects
 	 * so we only need to do them on the local node because all
@@ -449,7 +452,7 @@ void reset_locking(void)
 }
 
 #ifdef CLUSTER_LOCKING_INTERNAL
-int init_cluster_locking(struct locking_type *locking, struct config_tree *cft)
+int init_cluster_locking(struct locking_type *locking, struct cmd_context *cmd)
 {
 	locking->lock_resource = _lock_resource;
 	locking->fin_locking = _locking_end;

lib/locking/external_locking.c

@@ -17,6 +17,7 @@
 #include "locking_types.h"
 #include "defaults.h"
 #include "sharedlib.h"
+#include "toolcontext.h"
 
 static void *_locking_lib = NULL;
 static void (*_reset_fn) (void) = NULL;
@@ -55,7 +56,7 @@ static void _reset_external_locking(void)
 		_reset_fn();
 }
 
-int init_external_locking(struct locking_type *locking, struct config_tree *cft)
+int init_external_locking(struct locking_type *locking, struct cmd_context *cmd)
 {
 	const char *libname;
 
@@ -69,10 +70,10 @@ int init_external_locking(struct locking_type *locking, struct config_tree *cft)
 	locking->reset_locking = _reset_external_locking;
 	locking->flags = 0;
 
-	libname = find_config_str(cft->root, "global/locking_library",
-				  DEFAULT_LOCKING_LIB);
+	libname = find_config_tree_str(cmd, "global/locking_library",
+				       DEFAULT_LOCKING_LIB);
 
-	if (!(_locking_lib = load_shared_library(cft, libname, "locking", 1))) {
+	if (!(_locking_lib = load_shared_library(cmd, libname, "locking", 1))) {
 		stack;
 		return 0;
 	}
@@ -90,5 +91,5 @@ int init_external_locking(struct locking_type *locking, struct config_tree *cft)
 	}
 
 	log_verbose("Loaded external locking library %s", libname);
-	return _init_fn(2, cft, &locking->flags);
+	return _init_fn(2, cmd->cft, &locking->flags);
 }

lib/locking/file_locking.c

@@ -271,7 +271,7 @@ static int _file_lock_resource(struct cmd_context *cmd, const char *resource,
 	return 1;
 }
 
-int init_file_locking(struct locking_type *locking, struct config_tree *cft)
+int init_file_locking(struct locking_type *locking, struct cmd_context *cmd)
 {
 	locking->lock_resource = _file_lock_resource;
 	locking->reset_locking = _reset_file_locking;
@@ -279,8 +279,8 @@ int init_file_locking(struct locking_type *locking, struct config_tree *cft)
 	locking->flags = 0;
 
 	/* Get lockfile directory from config file */
-	strncpy(_lock_dir, find_config_str(cft->root, "global/locking_dir",
-					   DEFAULT_LOCK_DIR),
+	strncpy(_lock_dir, find_config_tree_str(cmd, "global/locking_dir",
+						DEFAULT_LOCK_DIR),
 		sizeof(_lock_dir));
 
 	if (!create_dir(_lock_dir))

lib/locking/locking.c

@@ -122,26 +122,26 @@ static void _update_vg_lock_count(int flags)
 /*
  * Select a locking type
  */
-int init_locking(int type, struct config_tree *cft)
+int init_locking(int type, struct cmd_context *cmd)
 {
 	init_lockingfailed(0);
 
 	switch (type) {
 	case 0:
-		init_no_locking(&_locking, cft);
+		init_no_locking(&_locking, cmd);
 		log_print("WARNING: Locking disabled. Be careful! "
 			  "This could corrupt your metadata.");
 		return 1;
 
 	case 1:
-		if (!init_file_locking(&_locking, cft))
+		if (!init_file_locking(&_locking, cmd))
 			break;
 		log_very_verbose("File-based locking enabled.");
 		return 1;
 
 #ifdef HAVE_LIBDL
 	case 2:
-		if (!init_external_locking(&_locking, cft))
+		if (!init_external_locking(&_locking, cmd))
 			break;
 		log_very_verbose("External locking enabled.");
 		return 1;
@@ -149,7 +149,7 @@ int init_locking(int type, struct config_tree *cft)
 
 #ifdef CLUSTER_LOCKING_INTERNAL
 	case 3:
-		if (!init_cluster_locking(&_locking, cft))
+		if (!init_cluster_locking(&_locking, cmd))
 			break;
 		log_very_verbose("Cluster locking enabled.");
 		return 1;
@@ -166,7 +166,7 @@ int init_locking(int type, struct config_tree *cft)
 	/* FIXME Ensure only read ops are permitted */
 	log_verbose("Locking disabled - only read operations permitted.");
 
-	init_no_locking(&_locking, cft);
+	init_no_locking(&_locking, cmd);
 	init_lockingfailed(1);
 
 	return 1;

lib/locking/locking.h

@@ -19,7 +19,7 @@
 #include "uuid.h"
 #include "config.h"
 
-int init_locking(int type, struct config_tree *cf);
+int init_locking(int type, struct cmd_context *cmd);
 void fin_locking(void);
 void reset_locking(void);
 int vg_write_lock_held(void);
@@ -75,6 +75,8 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
  */
 #define LCK_PARTIAL_MODE	0x00000001	/* Running in partial mode */
 #define LCK_MIRROR_NOSYNC_MODE	0x00000002	/* Mirrors don't require sync */
+#define LCK_DMEVENTD_REGISTER_MODE	0x00000004	/* Register with dmeventd */
+
 
 /*
  * Common combinations

lib/locking/locking_types.h

@@ -36,10 +36,10 @@ struct locking_type {
 /*
  * Locking types
  */
-int init_no_locking(struct locking_type *locking, struct config_tree *cf);
+int init_no_locking(struct locking_type *locking, struct cmd_context *cmd);
 
-int init_file_locking(struct locking_type *locking, struct config_tree *cf);
+int init_file_locking(struct locking_type *locking, struct cmd_context *cmd);
 
-int init_external_locking(struct locking_type *locking, struct config_tree *cf);
+int init_external_locking(struct locking_type *locking, struct cmd_context *cmd);
 
-int init_cluster_locking(struct locking_type *locking, struct config_tree *cf);
+int init_cluster_locking(struct locking_type *locking, struct cmd_context *cmd);

lib/locking/no_locking.c

@@ -76,7 +76,7 @@ static int _no_lock_resource(struct cmd_context *cmd, const char *resource,
 	return 1;
 }
 
-int init_no_locking(struct locking_type *locking, struct config_tree *cft)
+int init_no_locking(struct locking_type *locking, struct cmd_context *cmd)
 {
 	locking->lock_resource = _no_lock_resource;
 	locking->reset_locking = _no_reset_locking;

lib/log/log.c

@@ -17,6 +17,7 @@
 #include "device.h"
 #include "memlock.h"
 #include "lvm-string.h"
+#include "defaults.h"
 
 #include <stdarg.h>
 #include <syslog.h>
@@ -46,6 +47,7 @@ static char _cmd_name[30] = "";
 static char _msg_prefix[30] = "  ";
 static int _already_logging = 0;
 static int _mirror_in_sync = 0;
+static int _dmeventd_register = DEFAULT_DMEVENTD_MONITOR;
 
 static lvm2_log_fn_t _lvm2_log_fn = NULL;
 
@@ -181,6 +183,11 @@ void init_mirror_in_sync(int in_sync)
 	_mirror_in_sync = in_sync;
 }
 
+void init_dmeventd_register(int reg)
+{
+	_dmeventd_register = reg;
+}
+
 void init_cmd_name(int status)
 {
 	_log_cmd_name = status;
@@ -250,6 +257,11 @@ int mirror_in_sync(void)
 	return _mirror_in_sync;
 }
 
+int dmeventd_register_mode(void)
+{
+	return _dmeventd_register;
+}
+
 void init_debug(int level)
 {
 	_debug_level = level;

lib/log/log.h

@@ -74,6 +74,7 @@ void init_ignorelockingfailure(int level);
 void init_lockingfailed(int level);
 void init_security_level(int level);
 void init_mirror_in_sync(int in_sync);
+void init_dmeventd_register(int reg);
 
 void set_cmd_name(const char *cmd_name);
 
@@ -87,6 +88,7 @@ int ignorelockingfailure(void);
 int lockingfailed(void);
 int security_level(void);
 int mirror_in_sync(void);
+int dmeventd_register_mode(void);
 
 /* Suppress messages to stdout/stderr (1) or everywhere (2) */
 /* Returns previous setting */

lib/metadata/metadata.c

@@ -993,7 +993,11 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
 		if (list_size(&correct_vg->pvs) != list_size(pvids)) {
 			log_debug("Cached VG %s had incorrect PV list",
 				  vg->name);
-			correct_vg = NULL;
+
+			if (memlock())
+				inconsistent = 1;
+			else
+				correct_vg = NULL;
 		} else list_iterate_items(pvl, &correct_vg->pvs) {
 			if (!str_list_match_item(pvids, pvl->pv->dev->pvid)) {
 				log_debug("Cached VG %s had incorrect PV list",
@@ -1008,6 +1012,10 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
 	if (!correct_vg) {
 		inconsistent = 0;
 
+		if (memlock()) {
+			stack;
+			return NULL;
+		}
 		lvmcache_label_scan(cmd, 2);
 		if (!(fmt = fmt_from_vgname(vgname, vgid))) {
 			stack;
@@ -1149,7 +1157,8 @@ static struct volume_group *_vg_read_by_vgid(struct cmd_context *cmd,
 			if (!consistent) {
 				log_error("Volume group %s metadata is "
 					  "inconsistent", vginfo->vgname);
-				return NULL;
+				if (!partial_mode())
+					return NULL;
 			}
 			return vg;
 		}

lib/metadata/mirror.c

@@ -245,7 +245,7 @@ static int get_mirror_fault_policy(struct cmd_context *cmd, int log_policy)
 		policy = find_config_str(NULL, "activation/mirror_log_fault_policy",
 					 DEFAULT_MIRROR_LOG_FAULT_POLICY);
 	else
-		policy = find_config_str(NULL, "activation/mirror_dev_fault_policy",
+		policy = find_config_str(NULL, "activation/mirror_device_fault_policy",
 					 DEFAULT_MIRROR_DEV_FAULT_POLICY);
 
 	if (!strcmp(policy, "remove"))
@@ -258,7 +258,7 @@ static int get_mirror_fault_policy(struct cmd_context *cmd, int log_policy)
 	if (log_policy)
 		log_error("Bad activation/mirror_log_fault_policy");
 	else
-		log_error("Bad activation/mirror_dev_fault_policy");
+		log_error("Bad activation/mirror_device_fault_policy");
 
 	return MIRROR_REMOVE;
 }
@@ -268,7 +268,7 @@ static int get_mirror_log_fault_policy(struct cmd_context *cmd)
 	return get_mirror_fault_policy(cmd, 1);
 }
 
-static int get_mirror_dev_fault_policy(struct cmd_context *cmd)
+static int get_mirror_device_fault_policy(struct cmd_context *cmd)
 {
 	return get_mirror_fault_policy(cmd, 0);
 }
@@ -363,7 +363,7 @@ int reconfigure_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirr
 		  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
 
 	log_policy = get_mirror_log_fault_policy(mirrored_seg->lv->vg->cmd);
-	dev_policy = get_mirror_dev_fault_policy(mirrored_seg->lv->vg->cmd);
+	dev_policy = get_mirror_device_fault_policy(mirrored_seg->lv->vg->cmd);
 
 	r = replace_mirror_images(mirrored_seg,
 				  (dev_policy != MIRROR_REMOVE) ?

lib/metadata/segtype.h

@@ -67,23 +67,19 @@ struct segtype_handler {
 	int (*merge_segments) (struct lv_segment * seg1,
 			       struct lv_segment * seg2);
 	int (*add_target_line) (struct dev_manager *dm, struct dm_pool *mem,
-                                struct config_tree *cft, void **target_state,
+                                struct cmd_context *cmd, void **target_state,
                                 struct lv_segment *seg,
                                 struct dm_tree_node *node, uint64_t len,
                                 uint32_t *pvmove_mirror_count);
 	int (*target_percent) (void **target_state, struct dm_pool * mem,
-			       struct config_tree * cft,
-			       struct lv_segment * seg, char *params,
+			       struct cmd_context *cmd,
+			       struct lv_segment *seg, char *params,
 			       uint64_t *total_numerator,
 			       uint64_t *total_denominator, float *percent);
 	int (*target_present) (void);
 	void (*destroy) (const struct segment_type * segtype);
-	int (*target_register_events) (struct dm_pool *mem,
-				       struct lv_segment *seg,
-				       struct config_tree *cft, int events);
-	int (*target_unregister_events) (struct dm_pool *mem,
-					 struct lv_segment *seg,
-					 struct config_tree *cft, int events);
+	int (*target_register_events) (struct lv_segment *seg, int events);
+	int (*target_unregister_events) (struct lv_segment *seg, int events);
 };
 
 struct segment_type *get_segtype_from_string(struct cmd_context *cmd,

lib/mirror/mirrored.c

@@ -154,7 +154,7 @@ static int _mirrored_text_export(const struct lv_segment *seg, struct formatter
 
 #ifdef DEVMAPPER_SUPPORT
 static struct mirror_state *_mirrored_init_target(struct dm_pool *mem,
-					 struct config_tree *cft)
+					 struct cmd_context *cmd)
 {
 	struct mirror_state *mirr_state;
 
@@ -164,7 +164,7 @@ static struct mirror_state *_mirrored_init_target(struct dm_pool *mem,
 	}
 
 	mirr_state->default_region_size = 2 *
-	    find_config_int(cft->root,
+	    find_config_tree_int(cmd,
 			    "activation/mirror_region_size",
 			    DEFAULT_MIRROR_REGION_SIZE);
 
@@ -172,7 +172,7 @@ static struct mirror_state *_mirrored_init_target(struct dm_pool *mem,
 }
 
 static int _mirrored_target_percent(void **target_state, struct dm_pool *mem,
-			   struct config_tree *cft, struct lv_segment *seg,
+			   struct cmd_context *cmd, struct lv_segment *seg,
 			   char *params, uint64_t *total_numerator,
 			   uint64_t *total_denominator,
 			   float *percent __attribute((unused)))
@@ -184,7 +184,7 @@ static int _mirrored_target_percent(void **target_state, struct dm_pool *mem,
 	char *pos = params;
 
 	if (!*target_state)
-		*target_state = _mirrored_init_target(mem, cft);
+		*target_state = _mirrored_init_target(mem, cmd);
 
 	mirr_state = *target_state;
 
@@ -265,7 +265,7 @@ static int _add_log(struct dev_manager *dm, struct lv_segment *seg,
 }
 
 static int _mirrored_add_target_line(struct dev_manager *dm, struct dm_pool *mem,
-                                struct config_tree *cft, void **target_state,
+                                struct cmd_context *cmd, void **target_state,
                                 struct lv_segment *seg,
                                 struct dm_tree_node *node, uint64_t len,
                                 uint32_t *pvmove_mirror_count)
@@ -278,7 +278,7 @@ static int _mirrored_add_target_line(struct dev_manager *dm, struct dm_pool *mem
 	int r;
 
 	if (!*target_state)
-		*target_state = _mirrored_init_target(mem, cft);
+		*target_state = _mirrored_init_target(mem, cmd);
 
 	mirr_state = *target_state;
 
@@ -367,7 +367,7 @@ static int _mirrored_target_present(void)
 }
 
 #ifdef DMEVENTD
-static int _setup_registration(struct dm_pool *mem, struct config_tree *cft,
+static int _setup_registration(struct dm_pool *mem, struct cmd_context *cmd,
 			       char **dso)
 {
 	char *path;
@@ -378,10 +378,10 @@ static int _setup_registration(struct dm_pool *mem, struct config_tree *cft,
 		return 0;
 	}
 
-	libpath = find_config_str(cft->root, "dmeventd/mirror_library",
-				  DEFAULT_DMEVENTD_MIRROR_LIB);
+	libpath = find_config_tree_str(cmd, "dmeventd/mirror_library",
+				       DEFAULT_DMEVENTD_MIRROR_LIB);
 
-	get_shared_library_path(cft, libpath, path, PATH_MAX);
+	get_shared_library_path(cmd, libpath, path, PATH_MAX);
 
 	*dso = path;
 
@@ -390,9 +390,8 @@ static int _setup_registration(struct dm_pool *mem, struct config_tree *cft,
 
 /* FIXME This gets run while suspended and performs banned operations. */
 /* FIXME Merge these two functions */
-static int _target_register_events(struct dm_pool *mem,
-				   struct lv_segment *seg,
-				   struct config_tree *cft, int events)
+static int _target_register_events(struct lv_segment *seg,
+				   int events)
 {
 	char *dso, *name;
 	struct logical_volume *lv;
@@ -401,12 +400,12 @@ static int _target_register_events(struct dm_pool *mem,
 	lv = seg->lv;
 	vg = lv->vg;
 
-	if (!_setup_registration(mem, cft, &dso)) {
+	if (!_setup_registration(vg->cmd->mem, vg->cmd, &dso)) {
 		stack;
 		return 0;
 	}
 
-	if (!(name = build_dm_name(mem, vg->name, lv->name, NULL)))
+	if (!(name = build_dm_name(vg->cmd->mem, vg->name, lv->name, NULL)))
 		return_0;
 
 	/* FIXME Save a returned handle here so we can unregister it later */
@@ -418,9 +417,8 @@ static int _target_register_events(struct dm_pool *mem,
 	return 1;
 }
 
-static int _target_unregister_events(struct dm_pool *mem,
-				     struct lv_segment *seg,
-				     struct config_tree *cft, int events)
+static int _target_unregister_events(struct lv_segment *seg,
+				     int events)
 {
 	char *dso;
 	char *name;
@@ -431,10 +429,10 @@ static int _target_unregister_events(struct dm_pool *mem,
 	vg = lv->vg;
 
 	/* FIXME Remove this and use handle to avoid config file race */
-	if (!_setup_registration(mem, cft, &dso))
+	if (!_setup_registration(vg->cmd->mem, vg->cmd, &dso))
 		return_0;
 
-	if (!(name = build_dm_name(mem, vg->name, lv->name, NULL)))
+	if (!(name = build_dm_name(vg->cmd->mem, vg->name, lv->name, NULL)))
 		return_0;
 
 	/* FIXME Use handle returned by registration function instead of dso */

lib/misc/configure.h

@@ -1,430 +0,0 @@
-/* lib/misc/configure.h.  Generated by configure.  */
-/* lib/misc/configure.h.in.  Generated from configure.in by autoheader.  */
-
-/* Define to 1 if the `closedir' function returns void instead of `int'. */
-/* #undef CLOSEDIR_VOID */
-
-/* Define to 1 to include built-in support for clustered LVM locking. */
-/* #undef CLUSTER_LOCKING_INTERNAL */
-
-/* Define to 1 to build the shared command library. */
-/* #undef CMDLIB */
-
-/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
-   systems. This function is required for `alloca.c' support on those systems.
-   */
-/* #undef CRAY_STACKSEG_END */
-
-/* Define to 1 if using `alloca.c'. */
-/* #undef C_ALLOCA */
-
-/* Define to 1 to enable device-mapper interaction. */
-#define DEVMAPPER_SUPPORT 1
-
-/* Define to 1 to enable the device-mapper event daemon. */
-/* #undef DMEVENTD */
-
-/* Define to 1 if you have `alloca', as a function or macro. */
-#define HAVE_ALLOCA 1
-
-/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
-   */
-#define HAVE_ALLOCA_H 1
-
-/* Define to 1 if you have the <asm/byteorder.h> header file. */
-/* #undef HAVE_ASM_BYTEORDER_H */
-
-/* Define to 1 if you have the <assert.h> header file. */
-#define HAVE_ASSERT_H 1
-
-/* Define to 1 if you have the <ctype.h> header file. */
-#define HAVE_CTYPE_H 1
-
-/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
-   */
-#define HAVE_DIRENT_H 1
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#define HAVE_DLFCN_H 1
-
-/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
-/* #undef HAVE_DOPRNT */
-
-/* Define to 1 if you have the `dup2' function. */
-/* #undef HAVE_DUP2 */
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#define HAVE_FCNTL_H 1
-
-/* Define to 1 if you have the `fork' function. */
-#define HAVE_FORK 1
-
-/* Define to 1 if you have the <fstab.h> header file. */
-/* #undef HAVE_FSTAB_H */
-
-/* Define to 1 if you have the `gethostname' function. */
-#define HAVE_GETHOSTNAME 1
-
-/* Define to 1 if you have the `getmntent' function. */
-/* #undef HAVE_GETMNTENT */
-
-/* Define to 1 to if getopt_long is available. */
-#define HAVE_GETOPTLONG 1
-
-/* Define to 1 if you have the <getopt.h> header file. */
-#define HAVE_GETOPT_H 1
-
-/* Define to 1 if you have the `getpagesize' function. */
-#define HAVE_GETPAGESIZE 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the <libdevmapper.h> header file. */
-#define HAVE_LIBDEVMAPPER_H 1
-
-/* Define to 1 if dynamic libraries are available. */
-#define HAVE_LIBDL 1
-
-/* Define to 1 if you have the <libgen.h> header file. */
-#define HAVE_LIBGEN_H 1
-
-/* Define to 1 if you have the <libintl.h> header file. */
-/* #undef HAVE_LIBINTL_H */
-
-/* Define to 1 if you have the `readline' library (-lreadline). */
-/* #undef HAVE_LIBREADLINE */
-
-/* Define to 1 if you have the <limits.h> header file. */
-#define HAVE_LIMITS_H 1
-
-/* Define to 1 if you have the <linux/fs.h> header file. */
-/* #undef HAVE_LINUX_FS_H */
-
-/* Define to 1 if you have the <locale.h> header file. */
-#define HAVE_LOCALE_H 1
-
-/* Define to 1 if `lstat' has the bug that it succeeds when given the
-   zero-length file name argument. */
-/* #undef HAVE_LSTAT_EMPTY_STRING_BUG */
-
-/* Define to 1 if you have the <machine/endian.h> header file. */
-#define HAVE_MACHINE_ENDIAN_H 1
-
-/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
-   to 0 otherwise. */
-#define HAVE_MALLOC 1
-
-/* Define to 1 if you have the <malloc.h> header file. */
-/* #undef HAVE_MALLOC_H */
-
-/* Define to 1 if you have the `memmove' function. */
-/* #undef HAVE_MEMMOVE */
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* Define to 1 if you have the `memset' function. */
-#define HAVE_MEMSET 1
-
-/* Define to 1 if you have the `mkdir' function. */
-#define HAVE_MKDIR 1
-
-/* Define to 1 if you have a working `mmap' system call. */
-#define HAVE_MMAP 1
-
-/* Define to 1 if you have the <mntent.h> header file. */
-/* #undef HAVE_MNTENT_H */
-
-/* Define to 1 if you have the `munmap' function. */
-#define HAVE_MUNMAP 1
-
-/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
-/* #undef HAVE_NDIR_H */
-
-/* Define to 1 if you have the <netdb.h> header file. */
-/* #undef HAVE_NETDB_H */
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-/* #undef HAVE_NETINET_IN_H */
-
-/* Define to 1 if you have the <pthread.h> header file. */
-/* #undef HAVE_PTHREAD_H */
-
-/* Define to 1 if you have the <readline/history.h> header file. */
-/* #undef HAVE_READLINE_HISTORY_H */
-
-/* Define to 1 if you have the <readline/readline.h> header file. */
-/* #undef HAVE_READLINE_READLINE_H */
-
-/* Define to 1 if rl_completion_matches() is available. */
-/* #undef HAVE_RL_COMPLETION_MATCHES */
-
-/* Define to 1 if you have the `rmdir' function. */
-#define HAVE_RMDIR 1
-
-/* Define to 1 if you have the <search.h> header file. */
-/* #undef HAVE_SEARCH_H */
-
-/* Define to 1 if you have the `select' function. */
-/* #undef HAVE_SELECT */
-
-/* Define to 1 to include support for selinux. */
-/* #undef HAVE_SELINUX */
-
-/* Define to 1 if you have the <selinux/selinux.h> header file. */
-/* #undef HAVE_SELINUX_SELINUX_H */
-
-/* Define to 1 if you have the `setlocale' function. */
-#define HAVE_SETLOCALE 1
-
-/* Define to 1 if you have the <signal.h> header file. */
-#define HAVE_SIGNAL_H 1
-
-/* Define to 1 if you have the `socket' function. */
-/* #undef HAVE_SOCKET */
-
-/* Define to 1 if `stat' has the bug that it succeeds when given the
-   zero-length file name argument. */
-/* #undef HAVE_STAT_EMPTY_STRING_BUG */
-
-/* Define to 1 if you have the <stddef.h> header file. */
-#define HAVE_STDDEF_H 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdio.h> header file. */
-#define HAVE_STDIO_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the `strcasecmp' function. */
-#define HAVE_STRCASECMP 1
-
-/* Define to 1 if you have the `strchr' function. */
-#define HAVE_STRCHR 1
-
-/* Define to 1 if you have the `strdup' function. */
-#define HAVE_STRDUP 1
-
-/* Define to 1 if you have the `strerror' function. */
-#define HAVE_STRERROR 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the `strncasecmp' function. */
-#define HAVE_STRNCASECMP 1
-
-/* Define to 1 if you have the `strrchr' function. */
-#define HAVE_STRRCHR 1
-
-/* Define to 1 if you have the `strstr' function. */
-#define HAVE_STRSTR 1
-
-/* Define to 1 if you have the `strtol' function. */
-#define HAVE_STRTOL 1
-
-/* Define to 1 if you have the `strtoul' function. */
-#define HAVE_STRTOUL 1
-
-/* Define to 1 if `st_rdev' is member of `struct stat'. */
-#define HAVE_STRUCT_STAT_ST_RDEV 1
-
-/* Define to 1 if your `struct stat' has `st_rdev'. Deprecated, use
-   `HAVE_STRUCT_STAT_ST_RDEV' instead. */
-#define HAVE_ST_RDEV 1
-
-/* Define to 1 if you have the <syslog.h> header file. */
-#define HAVE_SYSLOG_H 1
-
-/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
-   */
-/* #undef HAVE_SYS_DIR_H */
-
-/* Define to 1 if you have the <sys/disk.h> header file. */
-#define HAVE_SYS_DISK_H 1
-
-/* Define to 1 if you have the <sys/file.h> header file. */
-#define HAVE_SYS_FILE_H 1
-
-/* Define to 1 if you have the <sys/ioctl.h> header file. */
-#define HAVE_SYS_IOCTL_H 1
-
-/* Define to 1 if you have the <sys/mman.h> header file. */
-#define HAVE_SYS_MMAN_H 1
-
-/* Define to 1 if you have the <sys/mount.h> header file. */
-/* #undef HAVE_SYS_MOUNT_H */
-
-/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
-   */
-/* #undef HAVE_SYS_NDIR_H */
-
-/* Define to 1 if you have the <sys/param.h> header file. */
-#define HAVE_SYS_PARAM_H 1
-
-/* Define to 1 if you have the <sys/resource.h> header file. */
-#define HAVE_SYS_RESOURCE_H 1
-
-/* Define to 1 if you have the <sys/select.h> header file. */
-/* #undef HAVE_SYS_SELECT_H */
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-/* #undef HAVE_SYS_SOCKET_H */
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#define HAVE_SYS_TIME_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <sys/uio.h> header file. */
-/* #undef HAVE_SYS_UIO_H */
-
-/* Define to 1 if you have the <sys/un.h> header file. */
-/* #undef HAVE_SYS_UN_H */
-
-/* Define to 1 if you have the <sys/utsname.h> header file. */
-#define HAVE_SYS_UTSNAME_H 1
-
-/* Define to 1 if you have the <sys/vfs.h> header file. */
-/* #undef HAVE_SYS_VFS_H */
-
-/* Define to 1 if you have the <sys/wait.h> header file. */
-#define HAVE_SYS_WAIT_H 1
-
-/* Define to 1 if you have the <time.h> header file. */
-#define HAVE_TIME_H 1
-
-/* Define to 1 if you have the `uname' function. */
-#define HAVE_UNAME 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* Define to 1 if you have the <utmpx.h> header file. */
-/* #undef HAVE_UTMPX_H */
-
-/* Define to 1 if you have the `vfork' function. */
-#define HAVE_VFORK 1
-
-/* Define to 1 if you have the <vfork.h> header file. */
-/* #undef HAVE_VFORK_H */
-
-/* Define to 1 if you have the `vprintf' function. */
-#define HAVE_VPRINTF 1
-
-/* Define to 1 if `fork' works. */
-#define HAVE_WORKING_FORK 1
-
-/* Define to 1 if `vfork' works. */
-#define HAVE_WORKING_VFORK 1
-
-/* Define to 1 if `lstat' dereferences a symlink specified with a trailing
-   slash. */
-/* #undef LSTAT_FOLLOWS_SLASHED_SYMLINK */
-
-/* Define to 1 if 'lvm' should fall back to using LVM1 binaries if
-   device-mapper is missing from the kernel */
-/* #undef LVM1_FALLBACK */
-
-/* Define to 1 to include built-in support for LVM1 metadata. */
-#define LVM1_INTERNAL 1
-
-/* Define to 1 to include built-in support for mirrors. */
-#define MIRRORED_INTERNAL 1
-
-/* The path to 'modprobe', if available. */
-#define MODPROBE_CMD "/sbin/ifconfig"
-
-/* Define to 1 to enable O_DIRECT support. */
-/* #undef O_DIRECT_SUPPORT */
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT ""
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME ""
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING ""
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME ""
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION ""
-
-/* Define to 1 to include built-in support for GFS pool metadata. */
-#define POOL_INTERNAL 1
-
-/* Define to 1 to include the LVM readline shell. */
-/* #undef READLINE_SUPPORT */
-
-/* Define as the return type of signal handlers (`int' or `void'). */
-#define RETSIGTYPE void
-
-/* Define to the type of arg 1 for `select'. */
-/* #undef SELECT_TYPE_ARG1 */
-
-/* Define to the type of args 2, 3 and 4 for `select'. */
-/* #undef SELECT_TYPE_ARG234 */
-
-/* Define to the type of arg 5 for `select'. */
-/* #undef SELECT_TYPE_ARG5 */
-
-/* Define to 1 to include built-in support for snapshots. */
-#define SNAPSHOT_INTERNAL 1
-
-/* If using the C implementation of alloca, define if you know the
-   direction of stack growth for your system; otherwise it will be
-   automatically deduced at run-time.
-	STACK_DIRECTION > 0 => grows toward higher addresses
-	STACK_DIRECTION < 0 => grows toward lower addresses
-	STACK_DIRECTION = 0 => direction of growth unknown */
-/* #undef STACK_DIRECTION */
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
-#define TIME_WITH_SYS_TIME 1
-
-/* Define to 1 if your <sys/time.h> declares `struct tm'. */
-/* #undef TM_IN_SYS_TIME */
-
-/* Define to empty if `const' does not conform to ANSI C. */
-/* #undef const */
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-/* #undef inline */
-#endif
-
-/* Define to rpl_malloc if the replacement function should be used. */
-/* #undef malloc */
-
-/* Define to `int' if <sys/types.h> does not define. */
-/* #undef mode_t */
-
-/* Define to `long' if <sys/types.h> does not define. */
-/* #undef off_t */
-
-/* Define to `int' if <sys/types.h> does not define. */
-/* #undef pid_t */
-
-/* Define to `unsigned' if <sys/types.h> does not define. */
-/* #undef size_t */
-
-/* Define as `fork' if `vfork' does not work. */
-/* #undef vfork */

lib/misc/crc.c

@@ -18,7 +18,7 @@
 #include "crc.h"
 
 /* Calculate an endian-independent CRC of supplied buffer */
-uint32_t calc_crc(uint32_t initial, void *buf, uint32_t size)
+uint32_t calc_crc(uint32_t initial, const void *buf, uint32_t size)
 {
 	static const uint32_t crctab[] = {
 		0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
@@ -27,7 +27,7 @@ uint32_t calc_crc(uint32_t initial, void *buf, uint32_t size)
 		0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
 	};
 	uint32_t i, crc = initial;
-	uint8_t *data = (uint8_t *) buf;
+	const uint8_t *data = (const uint8_t *) buf;
 
 	for (i = 0; i < size; i++) {
 		crc ^= *data++;

lib/misc/crc.h

@@ -18,6 +18,6 @@
 
 #define INITIAL_CRC 0xf597a6cf
 
-uint32_t calc_crc(uint32_t initial, void *buf, uint32_t size);
+uint32_t calc_crc(uint32_t initial, const void *buf, uint32_t size);
 
 #endif

lib/misc/sharedlib.c

@@ -22,7 +22,7 @@
 #include <sys/stat.h>
 #include <dlfcn.h>
 
-void get_shared_library_path(struct config_tree *cft, const char *libname,
+void get_shared_library_path(struct cmd_context *cmd, const char *libname,
 			     char *path, size_t path_len)
 {
 	struct stat info;
@@ -31,29 +31,29 @@ void get_shared_library_path(struct config_tree *cft, const char *libname,
 	/* If libname doesn't begin with '/' then use lib_dir/libname,
 	 * if present */
 	if (libname[0] == '/' ||
-	    !(lib_dir = find_config_str(cft->root, "global/library_dir", 0)) ||
+	    !(lib_dir = find_config_tree_str(cmd, "global/library_dir", 0)) ||
 	    (lvm_snprintf(path, path_len, "%s/%s", lib_dir,
 			  libname) == -1) || stat(path, &info) == -1)
 		strncpy(path, libname, path_len);
 }
 
-void *load_shared_library(struct config_tree *cft, const char *libname,
+void *load_shared_library(struct cmd_context *cmd, const char *libname,
 			  const char *desc, int silent)
 {
 	char path[PATH_MAX];
 	void *library;
 
-	get_shared_library_path(cft, libname, path, sizeof(path));
+	get_shared_library_path(cmd, libname, path, sizeof(path));
 
 	log_very_verbose("Opening shared %s library %s", desc, path);
 
-	if (!(library = dlopen(path, RTLD_LAZY))) {
+	if (!(library = dlopen(path, RTLD_LAZY | RTLD_GLOBAL))) {
 		if (silent && ignorelockingfailure())
-			log_verbose("Unable to open external %s library %s",
-				    desc, path);
+			log_verbose("Unable to open external %s library %s: %s",
+				    desc, path, dlerror());
 		else
-			log_error("Unable to open external %s library %s",
-				  desc, path);
+			log_error("Unable to open external %s library %s: %s",
+				  desc, path, dlerror());
 	}
 
 	return library;

lib/misc/sharedlib.h

@@ -19,9 +19,9 @@
 #include "config.h"
 #include <dlfcn.h>
 
-void get_shared_library_path(struct config_tree *cft, const char *libname,
+void get_shared_library_path(struct cmd_context *cmd, const char *libname,
 			     char *path, size_t path_len);
-void *load_shared_library(struct config_tree *cf, const char *libname,
+void *load_shared_library(struct cmd_context *cmd, const char *libname,
 			  const char *what, int silent);
 
 #endif

lib/mm/memlock.c

@@ -144,13 +144,13 @@ int memlock(void)
 
 void memlock_init(struct cmd_context *cmd)
 {
-	_size_stack = find_config_int(cmd->cft->root,
+	_size_stack = find_config_tree_int(cmd,
 				      "activation/reserved_stack",
 				      DEFAULT_RESERVED_STACK) * 1024;
-	_size_malloc_tmp = find_config_int(cmd->cft->root,
+	_size_malloc_tmp = find_config_tree_int(cmd,
 					   "activation/reserved_memory",
 					   DEFAULT_RESERVED_MEMORY) * 1024;
-	_default_priority = find_config_int(cmd->cft->root,
+	_default_priority = find_config_tree_int(cmd,
 				            "activation/process_priority",
 				            DEFAULT_PROCESS_PRIORITY);
 }

lib/snapshot/snapshot.c

@@ -89,7 +89,7 @@ static int _snap_text_export(const struct lv_segment *seg, struct formatter *f)
 #ifdef DEVMAPPER_SUPPORT
 static int _snap_target_percent(void **target_state __attribute((unused)),
 			   struct dm_pool *mem __attribute((unused)),
-			   struct config_tree *cft __attribute((unused)),
+			   struct cmd_context *cmd __attribute((unused)),
 			   struct lv_segment *seg __attribute((unused)),
 			   char *params, uint64_t *total_numerator,
 			   uint64_t *total_denominator, float *percent)

lib/striped/striped.c

@@ -153,7 +153,7 @@ static int _striped_merge_segments(struct lv_segment *seg1, struct lv_segment *s
 #ifdef DEVMAPPER_SUPPORT
 static int _striped_add_target_line(struct dev_manager *dm,
 				struct dm_pool *mem __attribute((unused)),
-                                struct config_tree *cft __attribute((unused)),
+                                struct cmd_context *cmd __attribute((unused)),
 				void **target_state __attribute((unused)),
                                 struct lv_segment *seg,
                                 struct dm_tree_node *node, uint64_t len,

lib/zero/zero.c

@@ -40,7 +40,7 @@ static int _zero_merge_segments(struct lv_segment *seg1, struct lv_segment *seg2
 #ifdef DEVMAPPER_SUPPORT
 static int _zero_add_target_line(struct dev_manager *dm __attribute((unused)),
 				struct dm_pool *mem __attribute((unused)),
-                                struct config_tree *cft __attribute((unused)),
+                                struct cmd_context *cmd __attribute((unused)),
 				void **target_state __attribute((unused)),
                                 struct lv_segment *seg __attribute((unused)),
                                 struct dm_tree_node *node,uint64_t len,

libdm/ioctl/libdm-iface.c

@@ -1461,7 +1461,6 @@ static int _reload_with_suppression_v4(struct dm_task *dmt)
 {
 	struct dm_task *task;
 	struct target *t1, *t2;
-	int matches = 1;
 	int r;
 
 	/* New task to get existing table information */
@@ -1491,6 +1490,9 @@ static int _reload_with_suppression_v4(struct dm_task *dmt)
 		return r;
 	}
 
+	if ((task->dmi.v4->flags & DM_READONLY_FLAG) ? 1 : 0 != dmt->read_only)
+		goto no_match;
+
 	t1 = dmt->head;
 	t2 = task->head;
 
@@ -1498,21 +1500,20 @@ static int _reload_with_suppression_v4(struct dm_task *dmt)
 		if ((t1->start != t2->start) ||
 		    (t1->length != t2->length) ||
 		    (strcmp(t1->type, t2->type)) ||
-		    (strcmp(t1->params, t2->params))) {
-			matches = 0;
-			break;
-		}
+		    (strcmp(t1->params, t2->params)))
+			goto no_match;
 		t1 = t1->next;
 		t2 = t2->next;
 	}
 	
-	if (matches && !t1 && !t2) {
+	if (!t1 && !t2) {
 		dmt->dmi.v4 = task->dmi.v4;
 		task->dmi.v4 = NULL;
 		dm_task_destroy(task);
 		return 1;
 	}
 
+no_match:
 	dm_task_destroy(task);
 
 	/* Now do the original reload */

libdm/libdm-deptree.c

@@ -1242,9 +1242,12 @@ static int _emit_segment_line(struct dm_task *dmt, struct load_segment *seg, uin
 		log_parm_count = 1;	/* Region size */
 		log_parm_count += hweight32(seg->flags);	/* [no]sync, block_on_error etc. */
 
+		if (seg->flags & DM_CORELOG)
+			log_parm_count--;   /* DM_CORELOG does not count in the param list */
+
 		if (seg->clustered) {
-			if (seg->uuid && !(seg->flags & DM_CORELOG))
-				log_parm_count++;	/* uuid (already counted for core log) */
+			if (seg->uuid)
+				log_parm_count++;
 			if ((tw = _dm_snprintf(params + pos, paramsize - pos, "clustered_")) < 0) {
                         	stack;	/* Out of space */
                         	return -1;

make.tmpl.in

@@ -195,8 +195,8 @@ clean: $(SUBDIRS.clean)
 	      $(SOURCES:%.c=%.pot) $(LDDEPS)
 
 distclean: $(SUBDIRS.distclean)
-	$(RM) $(OBJECTS) $(TARGETS) $(CLEAN_TARGETS) $(SOURCES:%.c=%.d) \
-	      $(SOURCES:%.c=%.pot) $(LDDEPS) \
+	$(RM) $(OBJECTS) $(TARGETS) $(CLEAN_TARGETS) $(DISTCLEAN_TARGETS) \
+	      $(SOURCES:%.c=%.d) $(SOURCES:%.c=%.pot) $(LDDEPS) \
 	      config.cache config.log config.status \
 	      Makefile make.tmpl core \
 	      version.h lvm2.po

man/dmsetup.8.in

@@ -7,9 +7,10 @@ dmsetup \- low level logical volume management
 .I device_name [-u uuid] [--notable] [table_file]
 .br
 .B dmsetup remove
-.I device_name
+.I [-f|--force] device_name
 .br
 .B dmsetup remove_all
+.I [-f|--force]
 .br
 .B dmsetup suspend
 .I [--nolockfs] device_name
@@ -103,7 +104,7 @@ Set the table being loaded read-only.
 .IP \fB-u|--uuid
 .br
 Specify the uuid.
-.IP \fB-v|--verbose [-v|--verbose]
+.IP \fB-v|--verbose\ [-v|--verbose]
 .br
 Produce additional output.
 .IP \fB--version
@@ -163,15 +164,34 @@ ascii, utf, vt100; compact, inverted, notrunc.
 .br
 Loads table_file into the inactive table slot for device_name.
 If table_file is not supplied, reads a table from standard input.
-.IP \fBremove
-.I device_name
+.IP \fBmknodes
+.I [device_name]
 .br
-Removes a device.  It will no longer be visible to dmsetup and
-will be deleted when its open_count is zero.
+Ensure that the node in /dev/mapper for device_name is correct.
+If no device_name is supplied, ensure that all nodes in /dev/mapper 
+correspond to mapped devices currently loaded by the device-mapper kernel
+driver, adding, changing or removing nodes as necessary.
+.IP \fBremove
+.I [-f|--force] device_name
+.br
+Removes a device.  It will no longer be visible to dmsetup.
+Open devices cannot be removed except with older kernels
+that contain a version of device-mapper prior to 4.8.0.
+In this case the device will be deleted when its open_count 
+drops to zero.  From version 4.8.0 onwards, if a device can't
+be removed because an uninterruptible process is waiting for
+I/O to return from it, adding --force will replace the table 
+with one that fails all I/O, which might allow the 
+process to be killed.
 .IP \fBremove_all
+.I [-f|--force]
 .br
 Attempts to remove all device definitions i.e. reset the driver.
-Use with care!
+Use with care!  From version 4.8.0 onwards, if devices can't
+be removed because uninterruptible processess are waiting for
+I/O to return from them, adding --force will replace the table 
+with one that fails all I/O, which might allow the 
+process to be killed.  This also runs \fBmknodes\fP afterwards.
 .IP \fBrename
 .I device_name new_name
 .br

scripts/vg_convert

@@ -16,4 +16,3 @@ CMDS=`./pvscan -u | sed -ne "s/.*PV \(.*\) with UUID \(.*\) VG $1 .*/.\/pvcreate
 sh -x -c "$CMDS" || exit 1
 
 ./vgcfgrestore --file lvmbackup -M lvm2 $1 || exit 1
-

tools/Makefile.in

@@ -91,9 +91,7 @@ ifeq ("@DMEVENTD@", "yes")
 	LVMLIBS += -ldevmapper-event -lpthread
 endif
 
-ifeq ("@DEVMAPPER@", "yes")
-	LVMLIBS += -ldevmapper
-endif
+LVMLIBS += -ldevmapper
 
 DEFS += -DLVM_SHARED_PATH=\"$(exec_prefix)/sbin/lvm\"
 

tools/args.h

@@ -47,6 +47,8 @@ arg(separator_ARG, '\0', "separator", string_arg)
 arg(mirrorsonly_ARG, '\0', "mirrorsonly", NULL)
 arg(nosync_ARG, '\0', "nosync", NULL)
 arg(corelog_ARG, '\0', "corelog", NULL)
+arg(monitor_ARG, '\0', "monitor", yes_no_arg)
+arg(config_ARG, '\0', "config", string_arg)
 
 /* Allow some variations */
 arg(resizable_ARG, '\0', "resizable", yes_no_arg)

tools/commands.h

@@ -63,6 +63,7 @@ xx(lvchange,
    "\t[-f|--force]\n"
    "\t[-h|--help]\n"
    "\t[--ignorelockingfailure]\n"
+   "\t[--monitor {y|n}]\n"
    "\t[-M|--persistent y|n] [--major major] [--minor minor]\n"
    "\t[-P|--partial] " "\n"
    "\t[-p|--permission r|rw]\n"
@@ -74,9 +75,9 @@ xx(lvchange,
    "\tLogicalVolume[Path] [LogicalVolume[Path]...]\n",
 
    alloc_ARG, autobackup_ARG, available_ARG, contiguous_ARG, force_ARG,
-   ignorelockingfailure_ARG, major_ARG, minor_ARG, partial_ARG, permission_ARG,
-   persistent_ARG, readahead_ARG, refresh_ARG, addtag_ARG, deltag_ARG,
-   test_ARG)
+   ignorelockingfailure_ARG, major_ARG, minor_ARG, monitor_ARG,
+   partial_ARG, permission_ARG, persistent_ARG, readahead_ARG,
+   refresh_ARG, addtag_ARG, deltag_ARG, test_ARG)
 
 xx(lvconvert,
    "Change logical volume layout",
@@ -347,7 +348,7 @@ xx(lvs,
    "\t[-v|--verbose]\n"
    "\t[--version]" "\n"
    "\t[LogicalVolume[Path] [LogicalVolume[Path]...]]\n",
-   
+
    aligned_ARG, all_ARG, ignorelockingfailure_ARG, noheadings_ARG,
    nolocking_ARG, nosuffix_ARG, options_ARG, partial_ARG, segments_ARG,
    separator_ARG, sort_ARG, unbuffered_ARG, units_ARG)
@@ -494,7 +495,7 @@ xx(pvmove,
    "\tSourcePhysicalVolume[:PhysicalExtent[-PhysicalExtent]...]}\n"
    "\t[DestinationPhysicalVolume[:PhysicalExtent[-PhysicalExtent]...]...]\n",
 
-   abort_ARG, alloc_ARG, autobackup_ARG, background_ARG, 
+   abort_ARG, alloc_ARG, autobackup_ARG, background_ARG,
    interval_ARG, name_ARG, test_ARG)
 
 xx(pvremove,
@@ -531,7 +532,7 @@ xx(pvs,
    "\t[-v|--verbose]\n"
    "\t[--version]\n"
    "\t[PhysicalVolume [PhysicalVolume...]]\n",
-   
+
    aligned_ARG, all_ARG, ignorelockingfailure_ARG, noheadings_ARG,
    nolocking_ARG, nosuffix_ARG, options_ARG, partial_ARG, segments_ARG,
    separator_ARG, sort_ARG, unbuffered_ARG, units_ARG)
@@ -595,6 +596,7 @@ xx(vgchange,
    "\t[-d|--debug] " "\n"
    "\t[-h|--help] " "\n"
    "\t[--ignorelockingfailure]\n"
+   "\t[--monitor {y|n}]\n"
    "\t[-t|--test]" "\n"
    "\t[-u|--uuid] " "\n"
    "\t[-v|--verbose] " "\n"
@@ -610,8 +612,8 @@ xx(vgchange,
 
    addtag_ARG, alloc_ARG, allocation_ARG, autobackup_ARG, available_ARG,
    clustered_ARG, deltag_ARG, ignorelockingfailure_ARG, logicalvolume_ARG,
-   partial_ARG, physicalextentsize_ARG, resizeable_ARG, resizable_ARG,
-   test_ARG, uuid_ARG)
+   monitor_ARG, partial_ARG, physicalextentsize_ARG, resizeable_ARG,
+   resizable_ARG, test_ARG, uuid_ARG)
 
 xx(vgck,
    "Check the consistency of volume group(s)",
@@ -822,7 +824,7 @@ xx(vgs,
    "\t[-v|--verbose]\n"
    "\t[--version]\n"
    "\t[VolumeGroupName [VolumeGroupName...]]\n",
-   
+
    aligned_ARG, all_ARG, ignorelockingfailure_ARG, noheadings_ARG,
    nolocking_ARG, nosuffix_ARG, options_ARG, partial_ARG, separator_ARG,
    sort_ARG, unbuffered_ARG, units_ARG)
@@ -835,7 +837,7 @@ xx(vgscan,
    "\t[--ignorelockingfailure]\n"
    "\t[--mknodes]\n"
    "\t[-P|--partial] " "\n"
-   "\t[-v|--verbose]\n" 
+   "\t[-v|--verbose]\n"
    "\t[--version]" "\n",
 
    ignorelockingfailure_ARG, mknodes_ARG, partial_ARG)

tools/dmsetup.c

@@ -88,6 +88,7 @@ enum {
 	READ_ONLY = 0,
 	COLS_ARG,
 	EXEC_ARG,
+	FORCE_ARG,
 	GID_ARG,
 	MAJOR_ARG,
 	MINOR_ARG,
@@ -108,6 +109,7 @@ enum {
 
 static int _switches[NUM_SWITCHES];
 static int _values[NUM_SWITCHES];
+static int _num_devices;
 static char *_uuid;
 static char *_fields;
 static char *_target;
@@ -143,7 +145,7 @@ static int _parse_file(struct dm_task *dmt, const char *file)
 		return 0;
 	}
 
-	while (fgets(buffer, buffer_size, fp)) {
+	while (fgets(buffer, (int) buffer_size, fp)) {
 #else
 	while (getline(&buffer, &buffer_size, fp) > 0) {
 #endif
@@ -321,7 +323,7 @@ static int _set_task_device(struct dm_task *dmt, const char *name, int optional)
 	return 1;
 }
 
-static int _load(int argc, char **argv, void *data)
+static int _load(int argc, char **argv, void *data __attribute((unused)))
 {
 	int r = 0;
 	struct dm_task *dmt;
@@ -378,7 +380,7 @@ static int _load(int argc, char **argv, void *data)
 	return r;
 }
 
-static int _create(int argc, char **argv, void *data)
+static int _create(int argc, char **argv, void *data __attribute((unused)))
 {
 	int r = 0;
 	struct dm_task *dmt;
@@ -386,7 +388,7 @@ static int _create(int argc, char **argv, void *data)
 
 	if (argc == 3)
 		file = argv[2];
- 
+
 	if (!(dmt = dm_task_create(DM_DEVICE_CREATE)))
 		return 0;
 
@@ -434,7 +436,7 @@ static int _create(int argc, char **argv, void *data)
 	return r;
 }
 
-static int _rename(int argc, char **argv, void *data)
+static int _rename(int argc, char **argv, void *data __attribute((unused)))
 {
 	int r = 0;
 	struct dm_task *dmt;
@@ -463,7 +465,7 @@ static int _rename(int argc, char **argv, void *data)
 	return r;
 }
 
-static int _message(int argc, char **argv, void *data)
+static int _message(int argc, char **argv, void *data __attribute((unused)))
 {
 	int r = 0, i;
 	size_t sz = 1;
@@ -523,7 +525,7 @@ static int _message(int argc, char **argv, void *data)
 	return r;
 }
 
-static int _setgeometry(int argc, char **argv, void *data)
+static int _setgeometry(int argc, char **argv, void *data __attribute((unused)))
 {
 	int r = 0;
 	struct dm_task *dmt;
@@ -556,7 +558,7 @@ static int _setgeometry(int argc, char **argv, void *data)
 	return r;
 }
 
-static int _version(int argc, char **argv, void *data)
+static int _version(int argc __attribute((unused)), char **argv __attribute((unused)), void *data __attribute((unused)))
 {
 	char version[80];
 
@@ -602,32 +604,22 @@ static int _simple(int task, const char *name, uint32_t event_nr, int display)
 	return r;
 }
 
-static int _remove_all(int argc, char **argv, void *data)
-{
-	return _simple(DM_DEVICE_REMOVE_ALL, "", 0, 0);
-}
-
-static int _remove(int argc, char **argv, void *data)
-{
-	return _simple(DM_DEVICE_REMOVE, argc > 1 ? argv[1] : NULL, 0, 0);
-}
-
-static int _suspend(int argc, char **argv, void *data)
+static int _suspend(int argc, char **argv, void *data __attribute((unused)))
 {
 	return _simple(DM_DEVICE_SUSPEND, argc > 1 ? argv[1] : NULL, 0, 1);
 }
 
-static int _resume(int argc, char **argv, void *data)
+static int _resume(int argc, char **argv, void *data __attribute((unused)))
 {
 	return _simple(DM_DEVICE_RESUME, argc > 1 ? argv[1] : NULL, 0, 1);
 }
 
-static int _clear(int argc, char **argv, void *data)
+static int _clear(int argc, char **argv, void *data __attribute((unused)))
 {
 	return _simple(DM_DEVICE_CLEAR, argc > 1 ? argv[1] : NULL, 0, 1);
 }
 
-static int _wait(int argc, char **argv, void *data)
+static int _wait(int argc, char **argv, void *data __attribute((unused)))
 {
 	const char *name = NULL;
 
@@ -644,7 +636,7 @@ static int _wait(int argc, char **argv, void *data)
 		       (argc > 1) ? (uint32_t) atoi(argv[argc - 1]) : 0, 1);
 }
 
-static int _process_all(int argc, char **argv,
+static int _process_all(int argc, char **argv, int silent,
 			int (*fn) (int argc, char **argv, void *data))
 {
 	int r = 1;
@@ -667,7 +659,8 @@ static int _process_all(int argc, char **argv,
 	}
 
 	if (!names->dev) {
-		printf("No devices found\n");
+		if (!silent)
+			printf("No devices found\n");
 		goto out;
 	}
 
@@ -683,6 +676,132 @@ static int _process_all(int argc, char **argv,
 	return r;
 }
 
+static uint64_t _get_device_size(const char *name)
+{
+	uint64_t start, length, size = UINT64_C(0);
+	struct dm_info info;
+	char *target_type, *params;
+	struct dm_task *dmt;
+	void *next = NULL;
+
+	if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
+		return 0;
+
+	if (!_set_task_device(dmt, name, 0))
+		goto out;
+
+	if (_switches[NOOPENCOUNT_ARG] && !dm_task_no_open_count(dmt))
+		goto out;
+
+	if (!dm_task_run(dmt))
+		goto out;
+
+	if (!dm_task_get_info(dmt, &info) || !info.exists)
+		goto out;
+
+	do {
+		next = dm_get_next_target(dmt, next, &start, &length,
+					  &target_type, &params);
+		size += length;
+	} while (next);
+
+      out:
+	dm_task_destroy(dmt);
+	return size;
+}
+
+static int _error_device(int argc __attribute((unused)), char **argv __attribute((unused)), void *data)
+{
+	struct dm_names *names = (struct dm_names *) data;
+	struct dm_task *dmt;
+	const char *name;
+	uint64_t size;
+	int r = 0;
+
+	if (data)
+		name = names->name;
+	else
+		name = argv[1];
+
+	size = _get_device_size(name);
+
+        if (!(dmt = dm_task_create(DM_DEVICE_RELOAD)))
+                return 0;
+
+	if (!_set_task_device(dmt, name, 0))
+		goto err;
+
+        if (!dm_task_add_target(dmt, 0, size, "error", ""))
+		goto err;
+
+        if (_switches[READ_ONLY] && !dm_task_set_ro(dmt))
+                goto err;
+
+        if (_switches[NOOPENCOUNT_ARG] && !dm_task_no_open_count(dmt))
+                goto err;
+
+        if (!dm_task_run(dmt))
+                goto err;
+
+	if (!_simple(DM_DEVICE_RESUME, name, 0, 0)) {
+		_simple(DM_DEVICE_CLEAR, name, 0, 0);
+		goto err;
+	}
+
+	r = 1;
+
+err:
+	dm_task_destroy(dmt);
+	return r;
+}
+
+static int _remove(int argc, char **argv, void *data __attribute((unused)))
+{
+	int r;
+
+	if (_switches[FORCE_ARG] && argc > 1)
+		r = _error_device(argc, argv, NULL);
+
+	return _simple(DM_DEVICE_REMOVE, argc > 1 ? argv[1] : NULL, 0, 0);
+}
+
+static int _count_devices(int argc __attribute((unused)), char **argv __attribute((unused)), void *data __attribute((unused)))
+{
+	_num_devices++;
+
+	return 1;
+}
+
+static int _remove_all(int argc __attribute((unused)), char **argv __attribute((unused)), void *data __attribute((unused)))
+{
+	int r;
+
+	/* Remove all closed devices */
+	r =  _simple(DM_DEVICE_REMOVE_ALL, "", 0, 0) | dm_mknodes(NULL);
+
+	if (!_switches[FORCE_ARG])
+		return r;
+
+	_num_devices = 0;
+	r |= _process_all(argc, argv, 1, _count_devices);
+
+	/* No devices left? */
+	if (!_num_devices)
+		return r;
+
+	r |= _process_all(argc, argv, 1, _error_device);
+	r |= _simple(DM_DEVICE_REMOVE_ALL, "", 0, 0) | dm_mknodes(NULL);
+
+	_num_devices = 0;
+	r |= _process_all(argc, argv, 1, _count_devices);
+	if (!_num_devices)
+		return r;
+
+	fprintf(stderr, "Unable to remove %d device(s).\n", _num_devices);
+
+	return r;
+}
+
 static void _display_dev(struct dm_task *dmt, const char *name)
 {
 	struct dm_info info;
@@ -691,7 +810,7 @@ static void _display_dev(struct dm_task *dmt, const char *name)
 		printf("%s\t(%u, %u)\n", name, info.major, info.minor);
 }
 
-static int _mknodes(int argc, char **argv, void *data)
+static int _mknodes(int argc, char **argv, void *data __attribute((unused)))
 {
 	return dm_mknodes(argc > 1 ? argv[1] : NULL);
 }
@@ -774,7 +893,7 @@ static int _status(int argc, char **argv, void *data)
 		name = names->name;
 	else {
 		if (argc == 1 && !_switches[UUID_ARG] && !_switches[MAJOR_ARG])
-			return _process_all(argc, argv, _status);
+			return _process_all(argc, argv, 0, _status);
 		if (argc == 2)
 			name = argv[1];
 	}
@@ -847,7 +966,7 @@ static int _status(int argc, char **argv, void *data)
 }
 
 /* Show target names and their version numbers */
-static int _targets(int argc, char **argv, void *data)
+static int _targets(int argc __attribute((unused)), char **argv __attribute((unused)), void *data __attribute((unused)))
 {
 	int r = 0;
 	struct dm_task *dmt;
@@ -877,7 +996,6 @@ static int _targets(int argc, char **argv, void *data)
       out:
 	dm_task_destroy(dmt);
 	return r;
-
 }
 
 static int _info(int argc, char **argv, void *data)
@@ -892,7 +1010,7 @@ static int _info(int argc, char **argv, void *data)
 		name = names->name;
 	else {
 		if (argc == 1 && !_switches[UUID_ARG] && !_switches[MAJOR_ARG])
-			return _process_all(argc, argv, _info);
+			return _process_all(argc, argv, 0, _info);
 		if (argc == 2)
 			name = argv[1];
 	}
@@ -930,7 +1048,7 @@ static int _deps(int argc, char **argv, void *data)
 		name = names->name;
 	else {
 		if (argc == 1 && !_switches[UUID_ARG] && !_switches[MAJOR_ARG])
-			return _process_all(argc, argv, _deps);
+			return _process_all(argc, argv, 0, _deps);
 		if (argc == 2)
 			name = argv[1];
 	}
@@ -982,7 +1100,7 @@ static int _deps(int argc, char **argv, void *data)
 	return r;
 }
 
-static int _display_name(int argc, char **argv, void *data)
+static int _display_name(int argc __attribute((unused)), char **argv __attribute((unused)), void *data)
 {
 	struct dm_names *names = (struct dm_names *) data;
 
@@ -1088,19 +1206,19 @@ static int _termwidth = 80;	/* Maximum output width */
 static int _cur_x = 1;		/* Current horizontal output position */
 static char _last_char = 0;
 
-static void _out_char(char c)
+static void _out_char(const unsigned c)
 {
 	/* Only first UTF-8 char counts */
 	_cur_x += ((c & 0xc0) != 0x80);
 
 	if (!_tree_switches[TR_TRUNCATE]) {
-		putchar(c);
+		putchar((int) c);
 		return;
 	}
 
 	/* Truncation? */
 	if (_cur_x <= _termwidth)
-		putchar(c);
+		putchar((int) c);
 
 	if (_cur_x == _termwidth + 1 && ((c & 0xc0) != 0x80)) {
 		if (_last_char || (c & 0x80)) {
@@ -1114,7 +1232,7 @@ static void _out_char(char c)
 	}
 }
 
-static void _out_string(const char *str)
+static void _out_string(const unsigned char *str)
 {
 	while (*str)
 		_out_char(*str++);
@@ -1150,9 +1268,9 @@ static void _out_newline(void)
 	_cur_x = 1;
 }
 
-static void _out_prefix(int depth)
+static void _out_prefix(unsigned depth)
 {
-	int x, d;
+	unsigned x, d;
 
 	for (d = 0; d < depth; d++) {
 		for (x = _tree_width[d] + 1; x > 0; x--)
@@ -1192,7 +1310,7 @@ static void _display_tree_attributes(struct dm_tree_node *node)
 
 	if (_tree_switches[TR_OPENCOUNT]) {
 		_out_string(attr++ ? ", " : " [");
-		(void) _out_int(info->open_count);
+		(void) _out_int((unsigned) info->open_count);
 	}
 
 	if (_tree_switches[TR_UUID]) {
@@ -1205,8 +1323,8 @@ static void _display_tree_attributes(struct dm_tree_node *node)
 }
 
 static void _display_tree_node(struct dm_tree_node *node, unsigned depth,
-			       unsigned first_child, unsigned last_child,
-			       unsigned has_children)
+			       unsigned first_child __attribute((unused)),
+			       unsigned last_child, unsigned has_children)
 {
 	int offset;
 	const char *name;
@@ -1287,7 +1405,7 @@ static void _tree_walk_children(struct dm_tree_node *node, unsigned depth)
 		    dm_tree_node_num_children(child, inverted) ? 1 : 0;
 
 		_display_tree_node(child, depth, first_child,
-				   next_child ? 0 : 1, has_children);
+				   next_child ? 0U : 1U, has_children);
 
 		if (has_children)
 			_tree_walk_children(child, depth + 1);
@@ -1296,11 +1414,11 @@ static void _tree_walk_children(struct dm_tree_node *node, unsigned depth)
 	}
 }
 
-static int _add_dep(int argc, char **argv, void *data)
+static int _add_dep(int argc __attribute((unused)), char **argv __attribute((unused)), void *data)
 {
 	struct dm_names *names = (struct dm_names *) data;
 
-	if (!dm_tree_add_dev(_dtree, MAJOR(names->dev), MINOR(names->dev)))
+	if (!dm_tree_add_dev(_dtree, (unsigned) MAJOR(names->dev), (unsigned) MINOR(names->dev)))
 		return 0;
 
 	return 1;
@@ -1309,12 +1427,12 @@ static int _add_dep(int argc, char **argv, void *data)
 /*
  * Create and walk dependency tree
  */
-static int _tree(int argc, char **argv, void *data)
+static int _tree(int argc, char **argv, void *data __attribute((unused)))
 {
 	if (!(_dtree = dm_tree_create()))
 		return 0;
 
-	if (!_process_all(argc, argv, _add_dep))
+	if (!_process_all(argc, argv, 0, _add_dep))
 		return 0;
 
 	_tree_walk_children(dm_tree_find_node(_dtree, 0, 0), 0);
@@ -1335,7 +1453,7 @@ static int _ls(int argc, char **argv, void *data)
 	else if ((_switches[TREE_ARG]))
 		return _tree(argc, argv, data);
 	else
-		return _process_all(argc, argv, _display_name);
+		return _process_all(argc, argv, 0, _display_name);
 }
 
 /*
@@ -1356,8 +1474,8 @@ static struct command _commands[] = {
 	  "\t                  [-U|--uid <uid>] [-G|--gid <gid>] [-M|--mode <octal_mode>]\n"
 	  "\t                  [-u|uuid <uuid>] [--notable] [<table_file>]",
 	 1, 2, _create},
-	{"remove", "<device>", 0, 1, _remove},
-	{"remove_all", "", 0, 0, _remove_all},
+	{"remove", "[-f|--force] <device>", 0, 1, _remove},
+	{"remove_all", "[-f|--force]", 0, 0, _remove_all},
 	{"suspend", "<device>", 0, 1, _suspend},
 	{"resume", "<device>", 0, 1, _resume},
 	{"load", "<device> [<table_file>]", 0, 2, _load},
@@ -1483,6 +1601,7 @@ static int _process_switches(int *argc, char ***argv)
 		{"readonly", 0, &ind, READ_ONLY},
 		{"columns", 0, &ind, COLS_ARG},
 		{"exec", 1, &ind, EXEC_ARG},
+		{"force", 0, &ind, FORCE_ARG},
 		{"gid", 1, &ind, GID_ARG},
 		{"major", 1, &ind, MAJOR_ARG},
 		{"minor", 1, &ind, MINOR_ARG},
@@ -1527,7 +1646,7 @@ static int _process_switches(int *argc, char ***argv)
 			_values[MINOR_ARG] = atoi((*argv)[2]);
 			*argc -= 2;
 			*argv += 2;
-		} else if ((*argc == 2) && 
+		} else if ((*argc == 2) &&
 			   (2 == sscanf((*argv)[1], "%i:%i",
 					&_values[MAJOR_ARG],
 					&_values[MINOR_ARG]))) {
@@ -1546,10 +1665,12 @@ static int _process_switches(int *argc, char ***argv)
 
 	optarg = 0;
 	optind = OPTIND_INIT;
-	while ((ind = -1, c = GETOPTLONG_FN(*argc, *argv, "cCGj:m:Mno:ru:Uv",
+	while ((ind = -1, c = GETOPTLONG_FN(*argc, *argv, "cCfGj:m:Mno:ru:Uv",
 					    long_options, NULL)) != -1) {
 		if (c == 'c' || c == 'C' || ind == COLS_ARG)
 			_switches[COLS_ARG]++;
+		if (c == 'f' || ind == FORCE_ARG)
+			_switches[FORCE_ARG]++;
 		if (c == 'r' || ind == READ_ONLY)
 			_switches[READ_ONLY]++;
 		if (c == 'j' || ind == MAJOR_ARG) {

tools/lvchange.c

@@ -72,6 +72,38 @@ static int lvchange_permission(struct cmd_context *cmd,
 	return 1;
 }
 
+static int lvchange_registration(struct cmd_context *cmd,
+				 struct logical_volume *lv)
+{
+	int r;
+	struct lvinfo info;
+
+	if (!lv_info(cmd, lv, &info, 0) || !info.exists) {
+		log_error("Logical volume, %s, is not active", lv->name);
+		return 0;
+	}
+
+	/* do not register pvmove lv's */
+	if (lv->status & PVMOVE)
+		return 1;
+
+	log_verbose("%smonitoring logical volume \"%s\"",
+		    (dmeventd_register_mode()) ? "" : "Not ", lv->name);
+	r = register_dev_for_events(cmd, lv, dmeventd_register_mode());
+
+	if (r < 0) {
+		log_error("Unable to %smonitor logical volume, %s",
+			  (dmeventd_register_mode()) ? "" : "un", lv->name);
+		r = 0;
+	} else if (!r) {
+		log_verbose("Logical volume %s needs no monitoring.",
+			    lv->name);
+		r = 1;
+	}
+
+	return r;
+}
+
 static int lvchange_availability(struct cmd_context *cmd,
 				 struct logical_volume *lv)
 {
@@ -283,14 +315,7 @@ static int lvchange_persistent(struct cmd_context *cmd,
 		lv->major = arg_int_value(cmd, major_ARG, lv->major);
 		log_verbose("Setting persistent device number to (%d, %d) "
 			    "for \"%s\"", lv->major, lv->minor, lv->name);
-		if (active) {
-			log_verbose("Re-activating logical volume \"%s\"",
-				    lv->name);
-			if (!activate_lv(cmd, lv)) {
-				log_error("%s: reactivation failed", lv->name);
-				return 0;
-			}
-		}
+
 	}
 
 	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
@@ -301,21 +326,17 @@ static int lvchange_persistent(struct cmd_context *cmd,
 
 	backup(lv->vg);
 
-	if (!suspend_lv(cmd, lv)) {
-		log_error("Failed to lock %s", lv->name);
-		vg_revert(lv->vg);
-		return 0;
-	}
-
 	if (!vg_commit(lv->vg)) {
-		resume_lv(cmd, lv);
+		stack;
 		return 0;
 	}
 
-	log_very_verbose("Updating permissions for \"%s\" in kernel", lv->name);
-	if (!resume_lv(cmd, lv)) {
-		log_error("Problem reactivating %s", lv->name);
-		return 0;
+	if (active) {
+		log_verbose("Re-activating logical volume \"%s\"", lv->name);
+		if (!activate_lv(cmd, lv)) {
+			log_error("%s: reactivation failed", lv->name);
+			return 0;
+		}
 	}
 
 	return 1;
@@ -422,6 +443,8 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
 		return ECMD_FAILED;
 	}
 
+	init_dmeventd_register(arg_int_value(cmd, monitor_ARG, DEFAULT_DMEVENTD_MONITOR));
+
 	/* access permission change */
 	if (arg_count(cmd, permission_ARG)) {
 		if (!archive(lv->vg))
@@ -474,14 +497,22 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
 		log_print("Logical volume \"%s\" changed", lv->name);
 
 	/* availability change */
-	if (arg_count(cmd, available_ARG))
+	if (arg_count(cmd, available_ARG)) {
 		if (!lvchange_availability(cmd, lv))
 			return ECMD_FAILED;
+	}
 
 	if (arg_count(cmd, refresh_ARG))
 		if (!lvchange_refresh(cmd, lv))
 			return ECMD_FAILED;
 
+	if (!arg_count(cmd, available_ARG) &&
+	    !arg_count(cmd, refresh_ARG) &&
+	    arg_count(cmd, monitor_ARG)) {
+		if (!lvchange_registration(cmd, lv))
+			return ECMD_FAILED;
+	}
+
 	return ECMD_PROCESSED;
 }
 
@@ -492,9 +523,10 @@ int lvchange(struct cmd_context *cmd, int argc, char **argv)
 	    && !arg_count(cmd, minor_ARG) && !arg_count(cmd, major_ARG)
 	    && !arg_count(cmd, persistent_ARG) && !arg_count(cmd, addtag_ARG)
 	    && !arg_count(cmd, deltag_ARG) && !arg_count(cmd, refresh_ARG)
-	    && !arg_count(cmd, alloc_ARG)) {
-		log_error("One or more of -a, -C, -j, -m, -M, -p, -r, "
-			  "--refresh, --alloc, --addtag or --deltag required");
+	    && !arg_count(cmd, alloc_ARG) && !arg_count(cmd, monitor_ARG)) {
+		log_error("Need 1 or more of -a, -C, -j, -m, -M, -p, -r, "
+			  "--refresh, --alloc, --addtag, --deltag "
+			  "or --monitor");
 		return EINVALID_CMD_LINE;
 	}
 

tools/lvconvert.c

@@ -177,7 +177,7 @@ static int _read_params(struct lvconvert_params *lp, struct cmd_context *cmd,
 			lp->region_size = 2 * arg_uint_value(cmd,
 							     regionsize_ARG, 0);
 		} else {
-			region_size = 2 * find_config_int(cmd->cft->root,
+			region_size = 2 * find_config_tree_int(cmd,
 						"activation/mirror_region_size",
 						DEFAULT_MIRROR_REGION_SIZE);
 			if (region_size < 0) {

tools/lvcreate.c

@@ -213,7 +213,7 @@ static int _read_stripe_params(struct lvcreate_params *lp,
 	}
 
 	if (lp->stripes > 1 && !lp->stripe_size) {
-		lp->stripe_size = find_config_int(cmd->cft->root,
+		lp->stripe_size = find_config_tree_int(cmd,
 						  "metadata/stripesize",
 						  DEFAULT_STRIPESIZE) * 2;
 		log_print("Using default stripesize %s",
@@ -264,7 +264,7 @@ static int _read_mirror_params(struct lvcreate_params *lp,
 		}
 		lp->region_size = 2 * arg_uint_value(cmd, regionsize_ARG, 0);
 	} else {
-		region_size = 2 * find_config_int(cmd->cft->root,
+		region_size = 2 * find_config_tree_int(cmd,
 					"activation/mirror_region_size",
 					DEFAULT_MIRROR_REGION_SIZE);
 		if (region_size < 0) {
@@ -595,6 +595,13 @@ static int _lvcreate(struct cmd_context *cmd, struct lvcreate_params *lp)
 				  "supported yet");
 			return 0;
 		}
+		if (org->status & MIRROR_IMAGE ||
+		    org->status & MIRROR_LOG ||
+		    org->status & MIRRORED) {
+			log_error("Snapshots and mirrors may not yet be mixed.");
+			return 0;
+		}
+ 
 		/* Must zero cow */
 		status |= LVM_WRITE;
 	}
@@ -668,7 +675,8 @@ static int _lvcreate(struct cmd_context *cmd, struct lvcreate_params *lp)
 			status |= MIRROR_NOTSYNCED;
 		}
 
-		if (!(log_lv = create_mirror_log(cmd, vg, ah, lp->alloc,
+		if (!lp->corelog &&
+		    !(log_lv = create_mirror_log(cmd, vg, ah, lp->alloc,
 						 lv_name, lp->nosync))) {
 			log_error("Failed to create mirror log.");
 			return 0;

tools/lvmcmdline.c

@@ -449,7 +449,7 @@ static void _register_commands()
 					driverloaded_ARG, \
 					debug_ARG, help_ARG, help2_ARG, \
 					version_ARG, verbose_ARG, \
-					quiet_ARG, -1);
+					quiet_ARG, config_ARG, -1);
 #include "commands.h"
 #undef xx
 }
@@ -713,8 +713,6 @@ static int _get_settings(struct cmd_context *cmd)
 	    !_merge_synonym(cmd, allocation_ARG, resizeable_ARG))
 		return EINVALID_CMD_LINE;
 
-	init_mirror_in_sync(0);
-
 	/* Zero indicates success */
 	return 0;
 }
@@ -762,12 +760,23 @@ int help(struct cmd_context *cmd __attribute((unused)), int argc, char **argv)
 	return 0;
 }
 
+static int _override_settings(struct cmd_context *cmd)
+{
+	if (!(cmd->cft_override = create_config_tree_from_string(cmd, arg_str_value(cmd, config_ARG, "")))) {
+		log_error("Failed to set overridden configuration entries.");
+		return EINVALID_CMD_LINE;
+	}
+
+	return 0;
+}
+
 static void _apply_settings(struct cmd_context *cmd)
 {
 	init_debug(cmd->current_settings.debug);
 	init_verbose(cmd->current_settings.verbose + VERBOSE_BASE_LEVEL);
 	init_test(cmd->current_settings.test);
 	init_full_scan_done(0);
+	init_mirror_in_sync(0);
 
 	init_msg_prefix(cmd->default_settings.msg_prefix);
 	init_cmd_name(cmd->default_settings.cmd_name);
@@ -783,7 +792,7 @@ static void _apply_settings(struct cmd_context *cmd)
 
 static char *_copy_command_line(struct cmd_context *cmd, int argc, char **argv)
 {
-	int i;
+	int i, space;
 
 	/*
 	 * Build up the complete command line, used as a
@@ -793,9 +802,17 @@ static char *_copy_command_line(struct cmd_context *cmd, int argc, char **argv)
 		goto bad;
 
 	for (i = 0; i < argc; i++) {
+		space = strchr(argv[i], ' ') ? 1 : 0;
+
+		if (space && !dm_pool_grow_object(cmd->mem, "'", 1))
+			goto bad;
+
 		if (!dm_pool_grow_object(cmd->mem, argv[i], strlen(argv[i])))
 			goto bad;
 
+		if (space && !dm_pool_grow_object(cmd->mem, "'", 1))
+			goto bad;
+
 		if (i < (argc - 1))
 			if (!dm_pool_grow_object(cmd->mem, " ", 1))
 				goto bad;
@@ -835,7 +852,11 @@ static int _run_command(struct cmd_context *cmd, int argc, char **argv)
 
 	set_cmd_name(cmd->command->name);
 
-	if (!cmd->config_valid || config_files_changed(cmd)) {
+	if (arg_count(cmd, config_ARG))
+		if ((ret = _override_settings(cmd)))
+			goto_out;
+
+	if (arg_count(cmd, config_ARG) || !cmd->config_valid || config_files_changed(cmd)) {
 		/* Reinitialise various settings inc. logging, filters */
 		if (!refresh_toolcontext(cmd)) {
 			log_error("Updated config file invalid. Aborting.");
@@ -844,7 +865,7 @@ static int _run_command(struct cmd_context *cmd, int argc, char **argv)
 	}
 
 	if ((ret = _get_settings(cmd)))
-		goto out;
+		goto_out;
 	_apply_settings(cmd);
 
 	log_debug("Processing: %s", cmd->cmd_line);
@@ -854,15 +875,15 @@ static int _run_command(struct cmd_context *cmd, int argc, char **argv)
 #endif
 
 	if ((ret = _process_common_commands(cmd)))
-		goto out;
+		goto_out;
 
 	if (arg_count(cmd, nolocking_ARG))
 		locking_type = 0;
 	else
-		locking_type = find_config_int(cmd->cft->root,
+		locking_type = find_config_tree_int(cmd,
 					       "global/locking_type", 1);
 
-	if (!init_locking(locking_type, cmd->cft)) {
+	if (!init_locking(locking_type, cmd)) {
 		log_error("Locking type %d initialisation failed.",
 			  locking_type);
 		ret = ECMD_FAILED;
@@ -879,6 +900,15 @@ static int _run_command(struct cmd_context *cmd, int argc, char **argv)
 		lvmcache_destroy();
 	}
 
+	if (cmd->cft_override) {
+		destroy_config_tree(cmd->cft_override);
+		cmd->cft_override = NULL;
+		/* Move this? */
+		if (!refresh_toolcontext(cmd))
+			stack;
+	}
+ 
+	/* FIXME Move this? */
 	cmd->current_settings = cmd->default_settings;
 	_apply_settings(cmd);
 
@@ -890,6 +920,8 @@ static int _run_command(struct cmd_context *cmd, int argc, char **argv)
 	if (ret == EINVALID_CMD_LINE && !_interactive)
 		_usage(cmd->command->name);
 
+	log_debug("Completed: %s", cmd->cmd_line);
+
 	return ret;
 }
 
@@ -1163,7 +1195,7 @@ static void _read_history(struct cmd_context *cmd)
 	if (read_history(hist_file))
 		log_very_verbose("Couldn't read history from %s.", hist_file);
 
-	stifle_history(find_config_int(cmd->cft->root, "shell/history_size",
+	stifle_history(find_config_tree_int(cmd, "shell/history_size",
 				       DEFAULT_MAX_HISTORY));
 
 }
@@ -1335,7 +1367,7 @@ static int _lvm1_fallback(struct cmd_context *cmd)
 	char vsn[80];
 	int dm_present;
 
-	if (!find_config_int(cmd->cft->root, "global/fallback_to_lvm1",
+	if (!find_config_tree_int(cmd, "global/fallback_to_lvm1",
 			     DEFAULT_FALLBACK_TO_LVM1) ||
 	    strncmp(cmd->kernel_vsn, "2.4.", 4))
 		return 0;

tools/lvresize.c

@@ -301,7 +301,7 @@ static int _lvresize(struct cmd_context *cmd, struct lvresize_params *lp)
 				lp->stripe_size = seg_stripesize;
 			} else {
 				lp->stripe_size =
-					find_config_int(cmd->cft->root,
+					find_config_tree_int(cmd,
 							"metadata/stripesize",
 							DEFAULT_STRIPESIZE) * 2;
 				log_print("Using default stripesize %s",

tools/pvcreate.c

@@ -185,13 +185,13 @@ static int pvcreate_single(struct cmd_context *cmd, const char *pv_name,
 	pvmetadatasize = arg_uint64_value(cmd, metadatasize_ARG, UINT64_C(0))
 	    * 2;
 	if (!pvmetadatasize)
-		pvmetadatasize = find_config_int(cmd->cft->root,
+		pvmetadatasize = find_config_tree_int(cmd,
 						 "metadata/pvmetadatasize",
 						 DEFAULT_PVMETADATASIZE);
 
 	pvmetadatacopies = arg_int_value(cmd, metadatacopies_ARG, -1);
 	if (pvmetadatacopies < 0)
-		pvmetadatacopies = find_config_int(cmd->cft->root,
+		pvmetadatacopies = find_config_tree_int(cmd,
 						   "metadata/pvmetadatacopies",
 						   DEFAULT_PVMETADATACOPIES);
 

tools/reporter.c

@@ -134,73 +134,73 @@ static int _report(struct cmd_context *cmd, int argc, char **argv,
 
 	int aligned, buffered, headings;
 
-	aligned = find_config_int(cmd->cft->root, "report/aligned",
+	aligned = find_config_tree_int(cmd, "report/aligned",
 				  DEFAULT_REP_ALIGNED);
-	buffered = find_config_int(cmd->cft->root, "report/buffered",
+	buffered = find_config_tree_int(cmd, "report/buffered",
 				   DEFAULT_REP_BUFFERED);
-	headings = find_config_int(cmd->cft->root, "report/headings",
+	headings = find_config_tree_int(cmd, "report/headings",
 				   DEFAULT_REP_HEADINGS);
-	separator = find_config_str(cmd->cft->root, "report/separator",
+	separator = find_config_tree_str(cmd, "report/separator",
 				    DEFAULT_REP_SEPARATOR);
 
 	switch (report_type) {
 	case LVS:
-		keys = find_config_str(cmd->cft->root, "report/lvs_sort",
+		keys = find_config_tree_str(cmd, "report/lvs_sort",
 				       DEFAULT_LVS_SORT);
 		if (!arg_count(cmd, verbose_ARG))
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/lvs_cols",
 						  DEFAULT_LVS_COLS);
 		else
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/lvs_cols_verbose",
 						  DEFAULT_LVS_COLS_VERB);
 		break;
 	case VGS:
-		keys = find_config_str(cmd->cft->root, "report/vgs_sort",
+		keys = find_config_tree_str(cmd, "report/vgs_sort",
 				       DEFAULT_VGS_SORT);
 		if (!arg_count(cmd, verbose_ARG))
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/vgs_cols",
 						  DEFAULT_VGS_COLS);
 		else
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/vgs_cols_verbose",
 						  DEFAULT_VGS_COLS_VERB);
 		break;
 	case PVS:
-		keys = find_config_str(cmd->cft->root, "report/pvs_sort",
+		keys = find_config_tree_str(cmd, "report/pvs_sort",
 				       DEFAULT_PVS_SORT);
 		if (!arg_count(cmd, verbose_ARG))
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/pvs_cols",
 						  DEFAULT_PVS_COLS);
 		else
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/pvs_cols_verbose",
 						  DEFAULT_PVS_COLS_VERB);
 		break;
 	case SEGS:
-		keys = find_config_str(cmd->cft->root, "report/segs_sort",
+		keys = find_config_tree_str(cmd, "report/segs_sort",
 				       DEFAULT_SEGS_SORT);
 		if (!arg_count(cmd, verbose_ARG))
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/segs_cols",
 						  DEFAULT_SEGS_COLS);
 		else
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/segs_cols_verbose",
 						  DEFAULT_SEGS_COLS_VERB);
 		break;
 	case PVSEGS:
-		keys = find_config_str(cmd->cft->root, "report/pvsegs_sort",
+		keys = find_config_tree_str(cmd, "report/pvsegs_sort",
 				       DEFAULT_PVSEGS_SORT);
 		if (!arg_count(cmd, verbose_ARG))
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/pvsegs_cols",
 						  DEFAULT_PVSEGS_COLS);
 		else
-			options = find_config_str(cmd->cft->root,
+			options = find_config_tree_str(cmd,
 						  "report/pvsegs_cols_verbose",
 						  DEFAULT_PVSEGS_COLS_VERB);
 		break;

tools/toollib.c

@@ -413,7 +413,7 @@ static int _process_one_vg(struct cmd_context *cmd, const char *vg_name,
 	if (!(vg = vg_read(cmd, vg_name, vgid, &consistent))) {
 		log_error("Volume group \"%s\" not found", vg_name);
 		unlock_vg(cmd, vg_name);
-		return ret_max;
+		return ECMD_FAILED;
 	}
 
 	if (!list_empty(tags)) {

tools/vgchange.c

@@ -15,6 +15,51 @@
 
 #include "tools.h"
 
+static int _register_lvs_in_vg(struct cmd_context *cmd,
+			       struct volume_group *vg, int reg)
+{
+	struct lv_list *lvl;
+	struct logical_volume *lv;
+	struct lvinfo info;
+	int lv_active;
+	int count = 0;
+	int r;
+
+	list_iterate_items(lvl, &vg->lvs) {
+		lv = lvl->lv;
+
+		if (!lv_info(cmd, lv, &info, 0))
+			lv_active = 0;
+		else
+			lv_active = info.exists;
+
+		/*
+		 * FIXME: Need to consider all cases... PVMOVE, etc
+		 */
+		if ((lv->status & PVMOVE) || !lv_active)
+			continue;
+
+		r = register_dev_for_events(cmd, lv, reg);
+
+		if (r < 0) {
+			log_error("Failed to %s logical volume, %s",
+				  (reg) ? "register" : "unregister",
+				  lv->name);
+			continue;
+		}
+
+		if (r)
+			count++;
+	}
+
+	/*
+	 * returns the number of monitored devices, not the number
+	 * of _new_ monitored devices
+	 */
+
+	return count;
+}
+
 static int _activate_lvs_in_vg(struct cmd_context *cmd,
 			       struct volume_group *vg, int activate)
 {
@@ -65,9 +110,23 @@ static int _activate_lvs_in_vg(struct cmd_context *cmd,
 	return count;
 }
 
+static int _vgchange_monitoring(struct cmd_context *cmd, struct volume_group *vg)
+{
+	int active, monitored;
+
+	if ((active = lvs_in_vg_activated(vg))) {
+		monitored = _register_lvs_in_vg(cmd, vg, dmeventd_register_mode());
+		log_print("%d logical volume(s) in volume group "
+			    "\"%s\" now %smonitored",
+			    monitored, vg->name, (dmeventd_register_mode()) ? "" : "un");
+	}
+
+	return ECMD_PROCESSED;
+}
+
 static int _vgchange_available(struct cmd_context *cmd, struct volume_group *vg)
 {
-	int lv_open, active;
+	int lv_open, active, monitored;
 	int available;
 	int activate = 1;
 
@@ -93,9 +152,15 @@ static int _vgchange_available(struct cmd_context *cmd, struct volume_group *vg)
 	if (activate && !lockingfailed())
 		check_current_backup(vg);
 
-	if (activate && (active = lvs_in_vg_activated(vg)))
+	if (activate && (active = lvs_in_vg_activated(vg))) {
 		log_verbose("%d logical volume(s) in volume group \"%s\" "
 			    "already active", active, vg->name);
+		monitored = _register_lvs_in_vg(cmd, vg, dmeventd_register_mode());
+		log_verbose("%d existing logical volume(s) in volume "
+			    "group \"%s\" now %smonitored",
+			    monitored, vg->name,
+			    dmeventd_register_mode() ? "" : "un");
+	}
 
 	if (activate && _activate_lvs_in_vg(cmd, vg, available))
 		log_verbose("Activated logical volumes in "
@@ -429,9 +494,14 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name,
 		return ECMD_FAILED;
 	}
 
+	init_dmeventd_register(arg_int_value(cmd, monitor_ARG, DEFAULT_DMEVENTD_MONITOR));
+
 	if (arg_count(cmd, available_ARG))
 		r = _vgchange_available(cmd, vg);
 
+	else if (arg_count(cmd, monitor_ARG))
+		r = _vgchange_monitoring(cmd, vg);
+
 	else if (arg_count(cmd, resizeable_ARG))
 		r = _vgchange_resizeable(cmd, vg);
 
@@ -466,7 +536,8 @@ int vgchange(struct cmd_context *cmd, int argc, char **argv)
 	     arg_count(cmd, resizeable_ARG) + arg_count(cmd, deltag_ARG) +
 	     arg_count(cmd, addtag_ARG) + arg_count(cmd, uuid_ARG) +
 	     arg_count(cmd, physicalextentsize_ARG) +
-	     arg_count(cmd, clustered_ARG) + arg_count(cmd, alloc_ARG))) {
+	     arg_count(cmd, clustered_ARG) + arg_count(cmd, alloc_ARG) +
+	     arg_count(cmd, monitor_ARG))) {
 		log_error("One of -a, -c, -l, -s, -x, --uuid, --alloc, --addtag or "
 			  "--deltag required");
 		return EINVALID_CMD_LINE;

tools/vgconvert.c

@@ -71,14 +71,14 @@ static int vgconvert_single(struct cmd_context *cmd, const char *vg_name,
 						  UINT64_C(0)) * 2;
 		if (!pvmetadatasize)
 			pvmetadatasize =
-			    find_config_int(cmd->cft->root,
+			    find_config_tree_int(cmd,
 					    "metadata/pvmetadatasize",
 					    DEFAULT_PVMETADATASIZE);
 
 		pvmetadatacopies = arg_int_value(cmd, metadatacopies_ARG, -1);
 		if (pvmetadatacopies < 0)
 			pvmetadatacopies =
-			    find_config_int(cmd->cft->root,
+			    find_config_tree_int(cmd,
 					    "metadata/pvmetadatacopies",
 					     DEFAULT_PVMETADATACOPIES);
 	}

tools/vgreduce.c

@@ -111,7 +111,13 @@ static int _remove_lv(struct cmd_context *cmd, struct logical_volume *lv,
 	 * and add to list of LVs to be removed later.
 	 * Doesn't apply to snapshots/origins yet - they're already deactivated.
 	 */
-	if (lv_info(cmd, lv, &info, 0) && info.exists) {
+	/*
+	 * If the LV is a part of mirror segment,
+	 * the mirrored LV also should be cleaned up.
+	 * Clean-up is currently done by caller (_make_vg_consistent()).
+	 */
+	if ((lv_info(cmd, lv, &info, 0) && info.exists)
+	    || first_seg(lv)->mirror_seg) {
 		extents = lv->le_count;
 		mirror_seg = first_seg(lv)->mirror_seg;
 		if (!lv_empty(lv)) {
@@ -280,13 +286,18 @@ static int _make_vg_consistent(struct cmd_context *cmd, struct volume_group *vg)
 				list_iterate_items(seg, &mirrored_seg->log_lv->segments) {
 					/* FIXME: The second test shouldn't be required */
 					if ((seg->segtype ==
-					     get_segtype_from_string(vg->cmd, "error")) ||
-					    (!strcmp(seg->segtype->name, "error"))) {
+					     get_segtype_from_string(vg->cmd, "error"))) {
 						log_print("The log device for %s/%s has failed.",
 							  vg->name, mirrored_seg->lv->name);
 						remove_log = 1;
 						break;
 					}
+					if (!strcmp(seg->segtype->name, "error")) {
+						log_print("Log device for %s/%s has failed.",
+							  vg->name, mirrored_seg->lv->name);
+						remove_log = 1;
+						break;
+					}
 				}
 			}
 
@@ -470,7 +481,7 @@ int vgreduce(struct cmd_context *cmd, int argc, char **argv)
 			log_error("Volume group \"%s\" is already consistent",
 				  vg_name);
 			unlock_vg(cmd, vg_name);
-			return ECMD_FAILED;
+			return ECMD_PROCESSED;
 		}
 
 		init_partial(1);