pre-release

Fix exit statuses of reporting tools (2.02.19).

VERSION

@@ -1 +1 @@
-2.02.20-cvs (2007-01-17)
+2.02.20-cvs (2007-01-25)

WHATS_NEW

@@ -1,8 +1,22 @@
-Version 2.02.20 -
+Version 2.02.20 - 25th January 2007
 ===================================
+  dmeventd mirror sets ignore_suspended_devices and avoids scanning mirrors.
+  Add devices/ignore_suspended_devices to ignore suspended dm devices.
+  Add some missing close() and fclose() return code checks.
+  Fix exit statuses of reporting tools (2.02.19).
+  Add init script for dmeventd monitoring.
+  lvm.static no longer interacts with dmeventd unless explicitly asked to.
+  Add field definitions to report help text.
+  Remove unnecessary cmd arg from target_*monitor_events().
+  Add private variable to dmeventd shared library interface.
+  Long-lived processes write out persistent dev cache in refresh_toolcontext().
+  Fix refresh_toolcontext() always to wipe persistent device filter cache.
+  Add is_long_lived to toolcontext.
+  Add --clustered to man pages.
+  Streamline dm_report_field_* interface.
   Change remaining dmeventd terminology 'register' to 'monitor'.
   Update reporting man pages.
-  No longer necessary to specify alignment for report fields.
+  No longer necessary to specify alignment type for report fields.
 
 Version 2.02.19 - 17th January 2007
 ===================================

WHATS_NEW_DM

@@ -1,5 +1,9 @@
-Version 1.02.16 -
+Version 1.02.16 - 25th January 2007
 ===================================
+  Add some missing close() and fclose() return value checks.
+  Migrate dmsetup column-based output over to new libdevmapper report framework.
+  Add descriptions to reporting field definitions.
+  Add a dso-private variable to dmeventd dso interface.
   Add dm_event_handler_[gs]et_timeout functions.
   Streamline dm_report_field_* interface.
   Add cmdline debug & version options to dmeventd.

daemons/clvmd/lvm-functions.c

@@ -473,7 +473,8 @@ static void drop_vg_locks()
 		sync_unlock(vg, LCK_EXCL);
 
 	}
-	fclose(vgs);
+	if (fclose(vgs))
+		DEBUGLOG("vgs fclose failed: %s\n", strerror(errno));
 }
 
 /*
@@ -523,7 +524,8 @@ static void *get_initial_state()
 			}
 		}
 	}
-	fclose(lvs);
+	if (fclose(lvs))
+		DEBUGLOG("lvs fclose failed: %s\n", strerror(errno));
 	return NULL;
 }
 
@@ -575,7 +577,7 @@ void init_lvhash()
 /* Called to initialise the LVM context of the daemon */
 int init_lvm(int using_gulm)
 {
-	if (!(cmd = create_toolcontext(NULL, 0))) {
+	if (!(cmd = create_toolcontext(NULL, 0, 1))) {
 		log_error("Failed to allocate command context");
 		return 0;
 	}

daemons/dmeventd/dmeventd.c

@@ -77,6 +77,19 @@ static int _debug = 0;
 */
 static pthread_mutex_t _global_mutex;
 
+/*
+  There are three states a thread can attain (see struct
+  thread_status, field int status):
+
+  - DM_THREAD_RUNNING: thread has started up and is either working or
+  waiting for events... transitions to either SHUTDOWN or DONE
+  - DM_THREAD_SHUTDOWN: thread is still doing something, but it is
+  supposed to terminate (and transition to DONE) as soon as it
+  finishes whatever it was doing at the point of flipping state to
+  SHUTDOWN... the thread is still on the thread list
+  - DM_THREAD_DONE: thread has terminated and has been moved over to
+  unused thread list, cleanup pending
+ */
 #define DM_THREAD_RUNNING  0
 #define DM_THREAD_SHUTDOWN 1
 #define DM_THREAD_DONE     2
@@ -106,7 +119,7 @@ struct dso_data {
 	 * DM_DEVICE_STATUS). It should not destroy it.
 	 * The caller must dispose of the task.
 	 */
-	void (*process_event)(struct dm_task *dmt, enum dm_event_mask event);
+	void (*process_event)(struct dm_task *dmt, enum dm_event_mask event, void **user);
 
 	/*
 	 * Device registration.
@@ -117,7 +130,7 @@ struct dso_data {
 	 * and activate a mapping).
 	 */
 	int (*register_device)(const char *device, const char *uuid, int major,
-			       int minor);
+			       int minor, void **user);
 
 	/*
 	 * Device unregistration.
@@ -127,7 +140,7 @@ struct dso_data {
 	 * steps (eg, deactivate mapping, metadata update).
 	 */
 	int (*unregister_device)(const char *device, const char *uuid,
-				 int major, int minor);
+				 int major, int minor, void **user);
 };
 static LIST_INIT(_dso_registry);
 
@@ -166,13 +179,16 @@ struct thread_status {
 	} device;
 	uint32_t event_nr;	/* event number */
 	int processing;		/* Set when event is being processed */
-	int status;		/* running/shutdown/done */
+
+	int status;		/* see DM_THREAD_{RUNNING,SHUTDOWN,DONE}
+				   constants above */
 	enum dm_event_mask events;	/* bitfield for event filter. */
 	enum dm_event_mask current_events;	/* bitfield for occured events. */
 	struct dm_task *current_task;
 	time_t next_time;
 	uint32_t timeout;
 	struct list timeout_list;
+	void *dso_private; /* dso per-thread status variable */
 };
 static LIST_INIT(_thread_registry);
 static LIST_INIT(_thread_registry_unused);
@@ -630,7 +646,8 @@ static int _do_register_device(struct thread_status *thread)
 	return thread->dso_data->register_device(thread->device.name,
 						 thread->device.uuid,
 						 thread->device.major,
-						 thread->device.minor);
+						 thread->device.minor,
+						 &(thread->dso_private));
 }
 
 /* Unregister a device with the DSO. */
@@ -639,13 +656,14 @@ static int _do_unregister_device(struct thread_status *thread)
 	return thread->dso_data->unregister_device(thread->device.name,
 						   thread->device.uuid,
 						   thread->device.major,
-						   thread->device.minor);
+						   thread->device.minor,
+						   &(thread->dso_private));
 }
 
 /* Process an event in the DSO. */
 static void _do_process_event(struct thread_status *thread, struct dm_task *task)
 {
-	thread->dso_data->process_event(task, thread->current_events);
+	thread->dso_data->process_event(task, thread->current_events, &(thread->dso_private));
 }
 
 /* Thread cleanup handler to unregister device. */
@@ -1107,22 +1125,25 @@ static int _get_registered_dev(struct message_data *message_data, int next)
 	if (!hit)
 		goto out;
 
-	goto out; /* FIXME the next == 1 thing is currently horridly
-		     broken, do something about it... */
+	thread = hit;
 
-	do {
+	while (1) {
 		if (list_end(&_thread_registry, &thread->list))
 			goto out;
 
 		thread = list_item(thread->list.n, struct thread_status);
-	} while (!_want_registered_device(message_data->dso_name, NULL, thread));
+		if (_want_registered_device(message_data->dso_name, NULL, thread)) {
+			hit = thread;
+			break;
+		}
+	}
 
 	_unlock_mutex();
-	return _registered_device(message_data, thread);
+	return _registered_device(message_data, hit);
 
       out:
 	_unlock_mutex();
-
+	
 	return -ENOENT;
 }
 
@@ -1545,7 +1566,8 @@ static int _set_oom_adj(int val)
 	}
 
 	fprintf(fp, "%i", val);
-	fclose(fp);
+	if (fclose(fp))
+		perror(OOM_ADJ_FILE ": fclose failed");
 
 	return 1;
 }
@@ -1562,7 +1584,7 @@ static void _daemonize(void)
 
 	sigemptyset(&my_sigset);
 	if (sigprocmask(SIG_SETMASK, &my_sigset, NULL) < 0) {
-		fprintf(stderr, "Unable to restore signals.");
+		fprintf(stderr, "Unable to restore signals.\n");
 		exit(EXIT_FAILURE);
 	}
 	signal(SIGTERM, &_exit_handler);

daemons/dmeventd/libdevmapper-event.h

@@ -98,9 +98,9 @@ int dm_event_unregister_handler(const struct dm_event_handler *dmevh);
 
 /* Prototypes for DSO interface, see dmeventd.c, struct dso_data for
    detailed descriptions. */
-void process_event(struct dm_task *dmt, enum dm_event_mask evmask);
-int register_device(const char *device_name, const char *uuid, int major, int minor);
+void process_event(struct dm_task *dmt, enum dm_event_mask evmask, void **user);
+int register_device(const char *device_name, const char *uuid, int major, int minor, void **user);
 int unregister_device(const char *device_name, const char *uuid, int major,
-		      int minor);
+		      int minor, void **user);
 
 #endif

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -151,7 +151,7 @@ static int _remove_failed_devices(const char *device)
 	}
 
 	/* FIXME Is any sanity-checking required on %s? */
-	if (CMD_SIZE <= snprintf(cmd_str, CMD_SIZE, "vgreduce --removemissing %s", vg)) {
+	if (CMD_SIZE <= snprintf(cmd_str, CMD_SIZE, "vgreduce --config devices{ignore_suspended_devices=1} --removemissing %s", vg)) {
 		/* this error should be caught above, but doesn't hurt to check again */
 		syslog(LOG_ERR, "Unable to form LVM command: Device name too long");
 		dm_pool_empty(_mem_pool);  /* FIXME: not safe with multiple threads */
@@ -164,7 +164,8 @@ static int _remove_failed_devices(const char *device)
 	return (r == 1) ? 0 : -1;
 }
 
-void process_event(struct dm_task *dmt, enum dm_event_mask event)
+void process_event(struct dm_task *dmt, enum dm_event_mask event,
+		   void **unused __attribute((unused)))
 {
 	void *next = NULL;
 	uint64_t start, length;
@@ -221,7 +222,8 @@ void process_event(struct dm_task *dmt, enum dm_event_mask event)
 	pthread_mutex_unlock(&_event_mutex);
 }
 
-int register_device(const char *device, const char *uuid, int major, int minor)
+int register_device(const char *device, const char *uuid, int major, int minor,
+		   void **unused __attribute((unused)))
 {
 	int r = 0;
 
@@ -257,7 +259,8 @@ out:
 	return r;
 }
 
-int unregister_device(const char *device, const char *uuid, int major, int minor)
+int unregister_device(const char *device, const char *uuid, int major, int minor,
+		   void **unused __attribute((unused)))
 {
 	pthread_mutex_lock(&_register_mutex);
 

dmeventd/mirror/dmeventd_mirror.c

@@ -151,7 +151,7 @@ static int _remove_failed_devices(const char *device)
 	}
 
 	/* FIXME Is any sanity-checking required on %s? */
-	if (CMD_SIZE <= snprintf(cmd_str, CMD_SIZE, "vgreduce --removemissing %s", vg)) {
+	if (CMD_SIZE <= snprintf(cmd_str, CMD_SIZE, "vgreduce --config devices{ignore_suspended_devices=1} --removemissing %s", vg)) {
 		/* this error should be caught above, but doesn't hurt to check again */
 		syslog(LOG_ERR, "Unable to form LVM command: Device name too long");
 		dm_pool_empty(_mem_pool);  /* FIXME: not safe with multiple threads */
@@ -164,7 +164,8 @@ static int _remove_failed_devices(const char *device)
 	return (r == 1) ? 0 : -1;
 }
 
-void process_event(struct dm_task *dmt, enum dm_event_mask event)
+void process_event(struct dm_task *dmt, enum dm_event_mask event,
+		   void **unused __attribute((unused)))
 {
 	void *next = NULL;
 	uint64_t start, length;
@@ -221,7 +222,8 @@ void process_event(struct dm_task *dmt, enum dm_event_mask event)
 	pthread_mutex_unlock(&_event_mutex);
 }
 
-int register_device(const char *device, const char *uuid, int major, int minor)
+int register_device(const char *device, const char *uuid, int major, int minor,
+		   void **unused __attribute((unused)))
 {
 	int r = 0;
 
@@ -257,7 +259,8 @@ out:
 	return r;
 }
 
-int unregister_device(const char *device, const char *uuid, int major, int minor)
+int unregister_device(const char *device, const char *uuid, int major, int minor,
+		   void **unused __attribute((unused)))
 {
 	pthread_mutex_lock(&_register_mutex);
 

doc/example.conf

@@ -79,6 +79,12 @@ devices {
     # software RAID (md) devices by looking for md superblocks.
     # 1 enables; 0 disables.
     md_component_detection = 1
+
+    # If, while scanning the system for PVs, LVM2 encounters a device-mapper
+    # device that has its I/O suspended, it waits for it to become accessible.
+    # Set this to 1 to skip such devices.  This should only be needed
+    # in recovery situations.
+    ignore_suspended_devices = 0
 }
 
 # This section that allows you to configure the nature of the

lib/activate/activate.c

@@ -651,7 +651,11 @@ int monitor_dev_for_events(struct cmd_context *cmd,
 	int r = 1;
 	struct list *tmp;
 	struct lv_segment *seg;
-	int (*monitor_fn) (struct cmd_context *c, struct lv_segment *s, int e);
+	int (*monitor_fn) (struct lv_segment *s, int e);
+
+	/* skip dmeventd code altogether */
+	if (dmeventd_monitor_mode() == DMEVENTD_MONITOR_IGNORE)
+		return 1;
 
 	/*
 	 * Nothing to do if dmeventd configured not to be used.
@@ -697,7 +701,7 @@ int monitor_dev_for_events(struct cmd_context *cmd,
 		log_verbose("%sonitoring %s/%s", monitor ? "M" : "Not m", lv->vg->name, lv->name);
 
 		/* FIXME specify events */
-		if (!monitor_fn(cmd, seg, 0)) {
+		if (!monitor_fn(seg, 0)) {
 			log_error("%s/%s: %s segment monitoring function failed.",
 				  lv->vg->name, lv->name, seg->segtype->name);
 			return 0;

lib/activate/activate.h

@@ -95,4 +95,9 @@ int monitor_dev_for_events(struct cmd_context *cmd,
 int pv_uses_vg(struct physical_volume *pv,
 	       struct volume_group *vg);
 
+/*
+ * Returns 1 if mapped device is not suspended.
+ */
+int device_is_usable(dev_t dev);
+
 #endif

lib/activate/dev_manager.c

@@ -25,6 +25,7 @@
 #include "targets.h"
 #include "config.h"
 #include "filter.h"
+#include "activate.h"
 
 #include <limits.h>
 #include <dirent.h>
@@ -154,6 +155,58 @@ static int _info_run(const char *name, const char *dlid, struct dm_info *info,
 	return r;
 }
 
+int device_is_usable(dev_t dev)
+{
+	struct dm_task *dmt;
+	struct dm_info info;
+	const char *name;
+        uint64_t start, length;
+        char *target_type = NULL;
+        char *params;
+	void *next = NULL;
+	int r = 0;
+
+	if (!(dmt = dm_task_create(DM_DEVICE_STATUS))) {
+		log_error("Failed to allocate dm_task struct to check dev status");
+		return 0;
+	}
+
+	if (!dm_task_set_major(dmt, MAJOR(dev)) || !dm_task_set_minor(dmt, MINOR(dev)))
+		goto_out;
+
+	if (!dm_task_run(dmt)) {
+		log_error("Failed to get state of mapped device");
+		goto out;
+	}
+
+	if (!dm_task_get_info(dmt, &info))
+		goto_out;
+
+	if (!info.exists || info.suspended)
+		goto out;
+
+	name = dm_task_get_name(dmt);
+
+	/* FIXME Also check for mirror block_on_error and mpath no paths */
+	/* For now, we exclude all mirrors */
+
+        do {
+                next = dm_get_next_target(dmt, next, &start, &length,
+                                          &target_type, &params);
+                /* Skip if target type doesn't match */
+                if (!strcmp(target_type, "mirror"))
+			goto out;
+        } while (next);
+
+	/* FIXME Also check dependencies? */
+
+	r = 1;
+
+      out:
+	dm_task_destroy(dmt);
+	return r;
+}
+
 static int _info(const char *name, const char *dlid, int mknodes,
 		 int with_open_count, struct dm_info *info,
 		 struct dm_pool *mem, char **uuid_out)

lib/commands/toolcontext.c

@@ -59,8 +59,6 @@
 #  include <malloc.h>
 #endif
 
-static FILE *_log;
-
 static int _get_env_vars(struct cmd_context *cmd)
 {
 	const char *e;
@@ -575,7 +573,7 @@ static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
 	    filters[0] : composite_filter_create(nr_filt, filters);
 }
 
-static int _init_filters(struct cmd_context *cmd)
+static int _init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
 {
 	const char *dev_cache;
 	struct dev_filter *f3, *f4;
@@ -594,6 +592,9 @@ static int _init_filters(struct cmd_context *cmd)
 		return 0;
 	}
 
+	init_ignore_suspended_devices(find_config_tree_int(cmd,
+	    "devices/ignore_suspended_devices", DEFAULT_IGNORE_SUSPENDED_DEVICES));
+
 	dev_cache = find_config_tree_str(cmd, "devices/cache",
 				    cache_file);
 	if (!(f4 = persistent_filter_create(f3, dev_cache))) {
@@ -608,8 +609,13 @@ static int _init_filters(struct cmd_context *cmd)
 	if (!*cmd->sys_dir)
 		cmd->dump_filter = 0;
 
-	if (!stat(dev_cache, &st) &&
-	    (st.st_ctime != config_file_timestamp(cmd->cft)) &&
+	/*
+	 * Only load persistent filter device cache on startup if it is newer
+	 * than the config file and this is not a long-lived process.
+	 */
+	if (load_persistent_cache && !cmd->is_long_lived &&
+	    !stat(dev_cache, &st) &&
+	    (st.st_ctime > config_file_timestamp(cmd->cft)) &&
 	    !persistent_filter_load(f4, NULL))
 		log_verbose("Failed to load existing device cache from %s",
 			    dev_cache);
@@ -881,7 +887,8 @@ static int _init_backup(struct cmd_context *cmd)
 }
 
 /* Entry point */
-struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static)
+struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static,
+				       unsigned is_long_lived)
 {
 	struct cmd_context *cmd;
 
@@ -905,6 +912,7 @@ struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static)
 	memset(cmd, 0, sizeof(*cmd));
 	cmd->args = the_args;
 	cmd->is_static = is_static;
+	cmd->is_long_lived = is_long_lived;
 	cmd->hosttags = 0;
 	list_init(&cmd->formats);
 	list_init(&cmd->segtypes);
@@ -953,7 +961,7 @@ struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static)
 	if (!_init_dev_cache(cmd))
 		goto error;
 
-	if (!_init_filters(cmd))
+	if (!_init_filters(cmd, 1))
 		goto error;
 
 	if (!(cmd->mem = dm_pool_create("command", 4 * 1024))) {
@@ -1022,10 +1030,10 @@ int refresh_toolcontext(struct cmd_context *cmd)
 {
 	log_verbose("Reloading config files");
 
-	if (cmd->config_valid) {
-		if (cmd->dump_filter)
-			persistent_filter_dump(cmd->filter);
-	}
+	/*
+	 * Don't update the persistent filter cache as we will
+	 * perform a full rescan.
+	 */
 
 	activation_release();
 	lvmcache_destroy();
@@ -1064,7 +1072,7 @@ int refresh_toolcontext(struct cmd_context *cmd)
 	if (!_init_dev_cache(cmd))
 		return 0;
 
-	if (!_init_filters(cmd))
+	if (!_init_filters(cmd, 0))
 		return 0;
 
 	if (!_init_formats(cmd))
@@ -1073,6 +1081,13 @@ int refresh_toolcontext(struct cmd_context *cmd)
 	if (!_init_segtypes(cmd))
 		return 0;
 
+	/*
+	 * If we are a long-lived process, write out the updated persistent
+	 * device cache for the benefit of short-lived processes.
+	 */
+	if (cmd->is_long_lived && cmd->dump_filter)
+		persistent_filter_dump(cmd->filter);
+
 	cmd->config_valid = 1;
 	return 1;
 }
@@ -1100,8 +1115,4 @@ void destroy_toolcontext(struct cmd_context *cmd)
 	activation_exit();
 	fin_log();
 	fin_syslog();
-
-	if (_log)
-		fclose(_log);
-
 }

lib/commands/toolcontext.h

@@ -65,6 +65,7 @@ struct cmd_context {
 	struct arg *args;
 	char **argv;
 	unsigned is_static;	/* Static binary? */
+	unsigned is_long_lived;	/* Optimises persistent_filter handling */
 
 	struct dev_filter *filter;
 	int dump_filter;	/* Dump filter when exiting? */
@@ -88,7 +89,7 @@ struct cmd_context {
 	char proc_dir[PATH_MAX];
 };
 
-struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static);
+struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static, unsigned is_long_lived);
 void destroy_toolcontext(struct cmd_context *cmd);
 int refresh_toolcontext(struct cmd_context *cmd);
 int config_files_changed(struct cmd_context *cmd);

lib/config/config.c

@@ -435,13 +435,13 @@ int write_config_file(struct config_tree *cft, const char *file,
 	log_verbose("Dumping configuration to %s", file);
 	if (!argc) {
 		if (!_write_config(cft->root, 0, fp, 0)) {
-			log_error("Failure while writing configuration");
+			log_error("Failure while writing to %s", file);
 			r = 0;
 		}
 	} else while (argc--) {
 		if ((cn = find_config_node(cft->root, *argv))) {
 			if (!_write_config(cn, 1, fp, 0)) {
-				log_error("Failure while writing configuration");
+				log_error("Failure while writing to %s", file);
 				r = 0;
 			}
 		} else {
@@ -451,8 +451,10 @@ int write_config_file(struct config_tree *cft, const char *file,
 		argv++;
 	}
 
-	if (fp != stdout)
-		fclose(fp);
+	if ((fp != stdout) && fclose(fp)) {
+		log_sys_error("fclose", file);
+		r = 0;
+	}
 
 	return r;
 }

lib/config/defaults.h

@@ -30,6 +30,7 @@
 #define DEFAULT_PROC_DIR "/proc"
 #define DEFAULT_SYSFS_SCAN 1
 #define DEFAULT_MD_COMPONENT_DETECTION 1
+#define DEFAULT_IGNORE_SUSPENDED_DEVICES 1
 
 #define DEFAULT_LOCK_DIR "/var/lock/lvm"
 #define DEFAULT_LOCKING_LIB "liblvm2clusterlock.so"

lib/device/dev-io.c

@@ -292,11 +292,14 @@ int dev_get_sectsize(struct device *dev, uint32_t *size)
 
 	if (ioctl(fd, BLKSSZGET, &s) < 0) {
 		log_sys_error("ioctl BLKSSZGET", name);
-		close(fd);
+		if (close(fd))
+			log_sys_error("close", name);
 		return 0;
 	}
 
-	close(fd);
+	if (close(fd))
+		log_sys_error("close", name);
+
 	*size = (uint32_t) s;
 
 	log_very_verbose("%s: sector size is %" PRIu32 " bytes", name, *size);

lib/filters/filter-persistent.c

@@ -239,7 +239,10 @@ int persistent_filter_dump(struct dev_filter *f)
 	/* _write_array(pf, fp, "invalid_devices", PF_BAD_DEVICE); */
 
 	fprintf(fp, "}\n");
-	fclose(fp);
+	if (fclose(fp)) {
+		log_sys_error("fclose", tmp_file);
+		goto out;
+	}
 
 	if (rename(tmp_file, pf->file))
 		log_error("%s: rename to %s failed: %s", tmp_file, pf->file,

lib/filters/filter-sysfs.c

@@ -54,7 +54,9 @@ static int _locate_sysfs_blocks(const char *proc, char *path, size_t len)
 		}
 	}
 
-	fclose(fp);
+	if (fclose(fp))
+		log_sys_error("fclose", proc_mounts);
+
 	return r;
 }
 
@@ -156,7 +158,9 @@ static int _read_dev(const char *file, dev_t *result)
 	}
 
 	r = _parse_dev(file, fp, result);
-	fclose(fp);
+
+	if (fclose(fp))
+		log_sys_error("fclose", file);
 
 	return r;
 }

lib/filters/filter.c

@@ -19,6 +19,7 @@
 #include "lvm-string.h"
 #include "config.h"
 #include "metadata.h"
+#include "activate.h"
 
 #include <dirent.h>
 #include <unistd.h>
@@ -37,6 +38,7 @@ typedef struct {
 } device_info_t;
 
 static int _md_major = -1;
+static int _device_mapper_major = -1;
 
 int md_major(void)
 {
@@ -90,6 +92,13 @@ static int _passes_lvm_type_device_filter(struct dev_filter *f,
 		return 0;
 	}
 
+	/* Skip suspended devices */
+	if (MAJOR(dev->dev) == _device_mapper_major &&
+	    ignore_suspended_devices() && !device_is_usable(dev->dev)) {
+		log_debug("%s: Skipping: Suspended dm device", name);
+		return 0;
+	}
+
 	/* Check it's accessible */
 	if (!dev_open_flags(dev, O_RDONLY, 0, 1)) {
 		log_debug("%s: Skipping: open failed", name);
@@ -182,10 +191,14 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
 		if (!strncmp("md", line + i, 2) && isspace(*(line + i + 2)))
 			_md_major = line_maj;
 
+		/* Look for device-mapper device */
+		/* FIXME Cope with multiple majors */
+		if (!strncmp("device-mapper", line + i, 13) && isspace(*(line + i + 13)))
+			_device_mapper_major = line_maj;
+
 		/* Go through the valid device names and if there is a
 		   match store max number of partitions */
 		for (j = 0; device_info[j].name != NULL; j++) {
-
 			dev_len = strlen(device_info[j].name);
 			if (dev_len <= strlen(line + i) &&
 			    !strncmp(device_info[j].name, line + i, dev_len) &&
@@ -204,7 +217,8 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
 			if (cv->type != CFG_STRING) {
 				log_error("Expecting string in devices/types "
 					  "in config file");
-				fclose(pd);
+				if (fclose(pd))
+					log_sys_error("fclose", proc_devices);
 				return 0;
 			}
 			dev_len = strlen(cv->v.str);
@@ -214,14 +228,16 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
 				log_error("Max partition count missing for %s "
 					  "in devices/types in config file",
 					  name);
-				fclose(pd);
+				if (fclose(pd))
+					log_sys_error("fclose", proc_devices);
 				return 0;
 			}
 			if (!cv->v.i) {
 				log_error("Zero partition count invalid for "
 					  "%s in devices/types in config file",
 					  name);
-				fclose(pd);
+				if (fclose(pd))
+					log_sys_error("fclose", proc_devices);
 				return 0;
 			}
 			if (dev_len <= strlen(line + i) &&
@@ -232,7 +248,10 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
 			}
 		}
 	}
-	fclose(pd);
+
+	if (fclose(pd))
+		log_sys_error("fclose", proc_devices);
+
 	return 1;
 }
 

lib/format_text/archive.c

@@ -249,17 +249,23 @@ int archive_vg(struct volume_group *vg,
 
 	if (!(fp = fdopen(fd, "w"))) {
 		log_err("Couldn't create FILE object for archive.");
-		close(fd);
+		if (close(fd))
+			log_sys_error("close", temp_file);
 		return 0;
 	}
 
 	if (!text_vg_export_file(vg, desc, fp)) {
 		stack;
-		fclose(fp);
+		if (fclose(fp))
+			log_sys_error("fclose", temp_file);
 		return 0;
 	}
 
-	fclose(fp);
+	if (fclose(fp)) {
+		log_sys_error("fclose", temp_file);
+		/* Leave file behind as evidence of failure */
+		return 0;
+	}
 
 	/*
 	 * Now we want to rename this file to <vg>_index.vg.

lib/format_text/format-text.c

@@ -710,7 +710,8 @@ static int _vg_write_file(struct format_instance *fid, struct volume_group *vg,
 
 	if (!(fp = fdopen(fd, "w"))) {
 		log_sys_error("fdopen", temp_file);
-		close(fd);
+		if (close(fd))
+			log_sys_error("fclose", temp_file);
 		return 0;
 	}
 
@@ -718,13 +719,15 @@ static int _vg_write_file(struct format_instance *fid, struct volume_group *vg,
 
 	if (!text_vg_export_file(vg, tc->desc, fp)) {
 		log_error("Failed to write metadata to %s.", temp_file);
-		fclose(fp);
+		if (fclose(fp))
+			log_sys_error("fclose", temp_file);
 		return 0;
 	}
 
 	if (fsync(fd) && (errno != EROFS) && (errno != EINVAL)) {
 		log_sys_error("fsync", tc->path_edit);
-		fclose(fp);
+		if (fclose(fp))
+			log_sys_error("fclose", tc->path_edit);
 		return 0;
 	}
 

lib/locking/file_locking.c

@@ -163,8 +163,8 @@ static int _lock_file(const char *file, int flags)
 	log_very_verbose("Locking %s %c%c", ll->res, state,
 			 flags & LCK_NONBLOCK ? ' ' : 'B');
 	do {
-		if (ll->lf > -1)
-			close(ll->lf);
+		if ((ll->lf > -1) && close(ll->lf))
+			log_sys_error("close", file);
 
 		if ((ll->lf = open(file, O_CREAT | O_APPEND | O_RDWR, 0777))
 		    < 0) {

lib/log/log.c

@@ -49,6 +49,7 @@ static char _msg_prefix[30] = "  ";
 static int _already_logging = 0;
 static int _mirror_in_sync = 0;
 static int _dmeventd_monitor = DEFAULT_DMEVENTD_MONITOR;
+static int _ignore_suspended_devices = 0;
 
 static lvm2_log_fn_t _lvm2_log_fn = NULL;
 
@@ -120,7 +121,8 @@ void fin_log(void)
 	}
 
 	if (_log_to_file) {
-		fclose(_log_file);
+		if (fclose(_log_file))
+			fprintf(stderr, "fclose() on log file failed: %s", strerror(errno));
 		_log_to_file = 0;
 	}
 }
@@ -194,6 +196,11 @@ void init_dmeventd_monitor(int reg)
 	_dmeventd_monitor = reg;
 }
 
+void init_ignore_suspended_devices(int ignore)
+{
+	_ignore_suspended_devices = ignore;
+}
+
 void init_cmd_name(int status)
 {
 	_log_cmd_name = status;
@@ -273,6 +280,11 @@ int dmeventd_monitor_mode(void)
 	return _dmeventd_monitor;
 }
 
+int ignore_suspended_devices(void)
+{
+	return _ignore_suspended_devices;
+}
+
 void init_debug(int level)
 {
 	_debug_level = level;

lib/log/log.h

@@ -76,6 +76,7 @@ void init_lockingfailed(int level);
 void init_security_level(int level);
 void init_mirror_in_sync(int in_sync);
 void init_dmeventd_monitor(int reg);
+void init_ignore_suspended_devices(int ignore);
 
 void set_cmd_name(const char *cmd_name);
 
@@ -90,6 +91,9 @@ int ignorelockingfailure(void);
 int lockingfailed(void);
 int security_level(void);
 int mirror_in_sync(void);
+int ignore_suspended_devices(void);
+
+#define DMEVENTD_MONITOR_IGNORE -1
 int dmeventd_monitor_mode(void);
 
 /* Suppress messages to stdout/stderr (1) or everywhere (2) */

lib/metadata/segtype.h

@@ -84,10 +84,8 @@ struct segtype_handler {
 			       struct list *modules);
 	void (*destroy) (const struct segment_type * segtype);
 	int (*target_monitored) (struct lv_segment *seg, int *pending);
-	int (*target_monitor_events) (struct cmd_context *cmd,
-				       struct lv_segment *seg, int events);
-	int (*target_unmonitor_events) (struct cmd_context *cmd,
-					 struct lv_segment *seg, int events);
+	int (*target_monitor_events) (struct lv_segment *seg, int events);
+	int (*target_unmonitor_events) (struct lv_segment *seg, int events);
 };
 
 struct segment_type *get_segtype_from_string(struct cmd_context *cmd,

lib/mirror/mirrored.c

@@ -449,9 +449,7 @@ static int _target_monitored(struct lv_segment *seg, int *pending)
 }
 
 /* FIXME This gets run while suspended and performs banned operations. */
-static int _target_set_events(struct cmd_context *cmd,
-				   struct lv_segment *seg,
-				   int evmask, int set)
+static int _target_set_events(struct lv_segment *seg, int evmask, int set)
 {
 	char *dso, *name;
 	struct logical_volume *lv;
@@ -462,10 +460,10 @@ static int _target_set_events(struct cmd_context *cmd,
 	lv = seg->lv;
 	vg = lv->vg;
 
-	if (!_get_mirror_dso_path(cmd, &dso))
+	if (!_get_mirror_dso_path(vg->cmd, &dso))
 		return_0;
 
-	if (!(name = build_dm_name(cmd->mem, vg->name, lv->name, NULL)))
+	if (!(name = build_dm_name(vg->cmd->mem, vg->name, lv->name, NULL)))
 		return_0;
 
 	if (!(dmevh = _create_dm_event_handler(name, dso, DM_EVENT_ALL_ERRORS)))
@@ -481,18 +479,14 @@ static int _target_set_events(struct cmd_context *cmd,
 	return 1;
 }
 
-static int _target_monitor_events(struct cmd_context *cmd,
-				     struct lv_segment *seg,
-				     int events)
+static int _target_monitor_events(struct lv_segment *seg, int events)
 {
-	return _target_set_events(cmd, seg, events, 1);
+	return _target_set_events(seg, events, 1);
 }
 
-static int _target_unmonitor_events(struct cmd_context *cmd,
-				     struct lv_segment *seg,
-				     int events)
+static int _target_unmonitor_events(struct lv_segment *seg, int events)
 {
-	return _target_set_events(cmd, seg, events, 0);
+	return _target_set_events(seg, events, 0);
 }
 
 #endif /* DMEVENTD */

lib/misc/lvm-file.c

@@ -66,7 +66,8 @@ int create_temp_name(const char *dir, char *buffer, size_t len, int *fd)
 		if (!fcntl(*fd, F_SETLK, &lock))
 			return 1;
 
-		close(*fd);
+		if (close(*fd))
+			log_sys_error("close", buffer);
 	}
 
 	return 0;
@@ -239,7 +240,8 @@ void sync_dir(const char *file)
 	if (fsync(fd) && (errno != EROFS) && (errno != EINVAL))
 		log_sys_error("fsync", dir);
 
-	close(fd);
+	if (close(fd))
+		log_sys_error("close", dir);
 
       out:
 	dm_free(dir);

lib/report/columns.h

@@ -18,67 +18,67 @@
  * Display Fn, Unique format identifier */
 
 /* *INDENT-OFF* */
-FIELD(LVS, lv, STR, "LV UUID", lvid.id[1], 38, uuid, "lv_uuid")
-FIELD(LVS, lv, STR, "LV", lvid, 4, lvname, "lv_name")
-FIELD(LVS, lv, STR, "Attr", lvid, 4, lvstatus, "lv_attr")
-FIELD(LVS, lv, NUM, "Maj", major, 3, int32, "lv_major")
-FIELD(LVS, lv, NUM, "Min", minor, 3, int32, "lv_minor")
-FIELD(LVS, lv, STR, "KMaj", lvid, 4, lvkmaj, "lv_kernel_major")
-FIELD(LVS, lv, STR, "KMin", lvid, 4, lvkmin, "lv_kernel_minor")
-FIELD(LVS, lv, NUM, "LSize", size, 5, size64, "lv_size")
-FIELD(LVS, lv, NUM, "#Seg", lvid, 4, lvsegcount, "seg_count")
-FIELD(LVS, lv, STR, "Origin", lvid, 6, origin, "origin")
-FIELD(LVS, lv, NUM, "Snap%", lvid, 6, snpercent, "snap_percent")
-FIELD(LVS, lv, NUM, "Copy%", lvid, 6, copypercent, "copy_percent")
-FIELD(LVS, lv, STR, "Move", lvid, 4, movepv, "move_pv")
-FIELD(LVS, lv, STR, "LV Tags", tags, 7, tags, "lv_tags")
-FIELD(LVS, lv, STR, "Log", lvid, 3, loglv, "mirror_log")
-FIELD(LVS, lv, STR, "Modules", lvid, 7, modules, "modules")
+FIELD(LVS, lv, STR, "LV UUID", lvid.id[1], 38, uuid, "lv_uuid", "Unique identifier")
+FIELD(LVS, lv, STR, "LV", lvid, 4, lvname, "lv_name", "Name.  LVs created for internal use are enclosed in brackets.")
+FIELD(LVS, lv, STR, "Attr", lvid, 4, lvstatus, "lv_attr", "Various attributes - see man page.")
+FIELD(LVS, lv, NUM, "Maj", major, 3, int32, "lv_major", "Persistent major number or -1 if not persistent.")
+FIELD(LVS, lv, NUM, "Min", minor, 3, int32, "lv_minor", "Persistent minor number or -1 if not persistent.")
+FIELD(LVS, lv, STR, "KMaj", lvid, 4, lvkmaj, "lv_kernel_major", "Currently assigned major number or -1 if LV is not active.")
+FIELD(LVS, lv, STR, "KMin", lvid, 4, lvkmin, "lv_kernel_minor", "Currently assigned minor number or -1 if LV is not active.")
+FIELD(LVS, lv, NUM, "LSize", size, 5, size64, "lv_size", "Size of LV in current units.")
+FIELD(LVS, lv, NUM, "#Seg", lvid, 4, lvsegcount, "seg_count", "Number of segments in LV.")
+FIELD(LVS, lv, STR, "Origin", lvid, 6, origin, "origin", "For snapshots, the origin device of this LV")
+FIELD(LVS, lv, NUM, "Snap%", lvid, 6, snpercent, "snap_percent", "For snapshots, the percentage full if LV is active.")
+FIELD(LVS, lv, NUM, "Copy%", lvid, 6, copypercent, "copy_percent", "For mirrors and pvmove, current percentage in-sync.")
+FIELD(LVS, lv, STR, "Move", lvid, 4, movepv, "move_pv", "For pvmove, Source PV of temporary LV created by pvmove")
+FIELD(LVS, lv, STR, "LV Tags", tags, 7, tags, "lv_tags", "Tags, if any.")
+FIELD(LVS, lv, STR, "Log", lvid, 3, loglv, "mirror_log", "For mirrors, the LV holding the synchronisation log.")
+FIELD(LVS, lv, STR, "Modules", lvid, 7, modules, "modules", "Kernel device-mapper modules required for this LV.")
 
-FIELD(PVS, pv, STR, "Fmt", id, 3, pvfmt, "pv_fmt")
-FIELD(PVS, pv, STR, "PV UUID", id, 38, uuid, "pv_uuid")
-FIELD(PVS, pv, NUM, "PSize", id, 5, pvsize, "pv_size")
-FIELD(PVS, pv, NUM, "DevSize", dev, 7, devsize, "dev_size")
-FIELD(PVS, pv, NUM, "1st PE", pe_start, 7, size64, "pe_start")
-FIELD(PVS, pv, NUM, "PFree", id, 5, pvfree, "pv_free")
-FIELD(PVS, pv, NUM, "Used", id, 4, pvused, "pv_used")
-FIELD(PVS, pv, STR, "PV", dev, 10, dev_name, "pv_name")
-FIELD(PVS, pv, STR, "Attr", status, 4, pvstatus, "pv_attr")
-FIELD(PVS, pv, NUM, "PE", pe_count, 3, uint32, "pv_pe_count")
-FIELD(PVS, pv, NUM, "Alloc", pe_alloc_count, 5, uint32, "pv_pe_alloc_count")
-FIELD(PVS, pv, STR, "PV Tags", tags, 7, tags, "pv_tags")
+FIELD(PVS, pv, STR, "Fmt", id, 3, pvfmt, "pv_fmt", "Type of metadata.")
+FIELD(PVS, pv, STR, "PV UUID", id, 38, uuid, "pv_uuid", "Unique identifier.")
+FIELD(PVS, pv, NUM, "PSize", id, 5, pvsize, "pv_size", "Size of PV in current units.")
+FIELD(PVS, pv, NUM, "DevSize", dev, 7, devsize, "dev_size", "Size of underlying device in current units.")
+FIELD(PVS, pv, NUM, "1st PE", pe_start, 7, size64, "pe_start", "Offset to the start of data on the underlying device.")
+FIELD(PVS, pv, NUM, "PFree", id, 5, pvfree, "pv_free", "Total amount of unallocated space in current units.")
+FIELD(PVS, pv, NUM, "Used", id, 4, pvused, "pv_used", "Total amount of allocated space in current units.")
+FIELD(PVS, pv, STR, "PV", dev, 10, dev_name, "pv_name", "Name.")
+FIELD(PVS, pv, STR, "Attr", status, 4, pvstatus, "pv_attr", "Various attributes - see man page.")
+FIELD(PVS, pv, NUM, "PE", pe_count, 3, uint32, "pv_pe_count", "Total number of Physical Extents.")
+FIELD(PVS, pv, NUM, "Alloc", pe_alloc_count, 5, uint32, "pv_pe_alloc_count", "Total number of allocated Physical Extents.")
+FIELD(PVS, pv, STR, "PV Tags", tags, 7, tags, "pv_tags", "Tags, if any.")
 
-FIELD(VGS, vg, STR, "Fmt", cmd, 3, vgfmt, "vg_fmt")
-FIELD(VGS, vg, STR, "VG UUID", id, 38, uuid, "vg_uuid")
-FIELD(VGS, vg, STR, "VG", name, 4, string, "vg_name")
-FIELD(VGS, vg, STR, "Attr", cmd, 5, vgstatus, "vg_attr")
-FIELD(VGS, vg, NUM, "VSize", cmd, 5, vgsize, "vg_size")
-FIELD(VGS, vg, NUM, "VFree", cmd, 5, vgfree, "vg_free")
-FIELD(VGS, vg, STR, "SYS ID", system_id, 6, string, "vg_sysid")
-FIELD(VGS, vg, NUM, "Ext", extent_size, 3, size32, "vg_extent_size")
-FIELD(VGS, vg, NUM, "#Ext", extent_count, 4, uint32, "vg_extent_count")
-FIELD(VGS, vg, NUM, "Free", free_count, 4, uint32, "vg_free_count")
-FIELD(VGS, vg, NUM, "MaxLV", max_lv, 5, uint32, "max_lv")
-FIELD(VGS, vg, NUM, "MaxPV", max_pv, 5, uint32, "max_pv")
-FIELD(VGS, vg, NUM, "#PV", pv_count, 3, uint32, "pv_count")
-FIELD(VGS, vg, NUM, "#LV", lv_count, 3, uint32, "lv_count")
-FIELD(VGS, vg, NUM, "#SN", snapshot_count, 3, uint32, "snap_count")
-FIELD(VGS, vg, NUM, "Seq", seqno, 3, uint32, "vg_seqno")
-FIELD(VGS, vg, STR, "VG Tags", tags, 7, tags, "vg_tags")
+FIELD(VGS, vg, STR, "Fmt", cmd, 3, vgfmt, "vg_fmt", "Type of metadata.")
+FIELD(VGS, vg, STR, "VG UUID", id, 38, uuid, "vg_uuid", "Unique identifier.")
+FIELD(VGS, vg, STR, "VG", name, 4, string, "vg_name", "Name.")
+FIELD(VGS, vg, STR, "Attr", cmd, 5, vgstatus, "vg_attr", "Various attributes - see man page.")
+FIELD(VGS, vg, NUM, "VSize", cmd, 5, vgsize, "vg_size", "Total size of VG in current units.")
+FIELD(VGS, vg, NUM, "VFree", cmd, 5, vgfree, "vg_free", "Total amount of free space in current units.")
+FIELD(VGS, vg, STR, "SYS ID", system_id, 6, string, "vg_sysid", "System ID indicating when and where it was created.")
+FIELD(VGS, vg, NUM, "Ext", extent_size, 3, size32, "vg_extent_size", "Size of Physical Extents in current units.")
+FIELD(VGS, vg, NUM, "#Ext", extent_count, 4, uint32, "vg_extent_count", "Total number of Physical Extents.")
+FIELD(VGS, vg, NUM, "Free", free_count, 4, uint32, "vg_free_count", "Total number of unallocated Physical Extents.")
+FIELD(VGS, vg, NUM, "MaxLV", max_lv, 5, uint32, "max_lv", "Maximum number of LVs allowed in VG or 0 if unlimited.")
+FIELD(VGS, vg, NUM, "MaxPV", max_pv, 5, uint32, "max_pv", "Maximum number of PVs allowed in VG or 0 if unlimited.")
+FIELD(VGS, vg, NUM, "#PV", pv_count, 3, uint32, "pv_count", "Number of PVs.")
+FIELD(VGS, vg, NUM, "#LV", lv_count, 3, uint32, "lv_count", "Number of LVs.")
+FIELD(VGS, vg, NUM, "#SN", snapshot_count, 3, uint32, "snap_count", "Number of snapshots.")
+FIELD(VGS, vg, NUM, "Seq", seqno, 3, uint32, "vg_seqno", "Revision number of internal metadata.  Incremented whenever it changes.")
+FIELD(VGS, vg, STR, "VG Tags", tags, 7, tags, "vg_tags", "Tags, if any.")
 
-FIELD(SEGS, seg, STR, "Type", list, 4, segtype, "segtype")
-FIELD(SEGS, seg, NUM, "#Str", area_count, 4, uint32, "stripes")
-FIELD(SEGS, seg, NUM, "Stripe", stripe_size, 6, size32, "stripesize")
-FIELD(SEGS, seg, NUM, "Stripe", stripe_size, 6, size32, "stripe_size")
-FIELD(SEGS, seg, NUM, "Chunk", list, 5, chunksize, "chunksize")
-FIELD(SEGS, seg, NUM, "Chunk", list, 5, chunksize, "chunk_size")
-FIELD(SEGS, seg, NUM, "Region", region_size, 6, size32, "regionsize")
-FIELD(SEGS, seg, NUM, "Region", region_size, 6, size32, "region_size")
-FIELD(SEGS, seg, NUM, "Start", list, 5, segstart, "seg_start")
-FIELD(SEGS, seg, NUM, "SSize", list, 5, segsize, "seg_size")
-FIELD(SEGS, seg, STR, "Seg Tags", tags, 8, tags, "seg_tags")
-FIELD(SEGS, seg, STR, "Devices", list, 5, devices, "devices")
+FIELD(SEGS, seg, STR, "Type", list, 4, segtype, "segtype", "Type of LV segment")
+FIELD(SEGS, seg, NUM, "#Str", area_count, 4, uint32, "stripes", "Number of stripes or mirror legs.")
+FIELD(SEGS, seg, NUM, "Stripe", stripe_size, 6, size32, "stripesize", "For stripes, amount of data placed on one device before switching to the next.")
+FIELD(SEGS, seg, NUM, "Stripe", stripe_size, 6, size32, "stripe_size", "For stripes, amount of data placed on one device before switching to the next.")
+FIELD(SEGS, seg, NUM, "Region", region_size, 6, size32, "regionsize", "For mirrors, the unit of data copied when synchronising devices.")
+FIELD(SEGS, seg, NUM, "Region", region_size, 6, size32, "region_size", "For mirrors, the unit of data copied when synchronising devices.")
+FIELD(SEGS, seg, NUM, "Chunk", list, 5, chunksize, "chunksize", "For snapshots, the unit of data used when tracking changes.")
+FIELD(SEGS, seg, NUM, "Chunk", list, 5, chunksize, "chunk_size", "For snapshots, the unit of data used when tracking changes.")
+FIELD(SEGS, seg, NUM, "Start", list, 5, segstart, "seg_start", "Offset within the LV to the start of the segment in current units.")
+FIELD(SEGS, seg, NUM, "SSize", list, 5, segsize, "seg_size", "Size of segment in current units.")
+FIELD(SEGS, seg, STR, "Seg Tags", tags, 8, tags, "seg_tags", "Tags, if any.")
+FIELD(SEGS, seg, STR, "Devices", list, 5, devices, "devices", "Underlying devices used with starting extent numbers.")
 
-FIELD(PVSEGS, pvseg, NUM, "Start", pe, 5, uint32, "pvseg_start")
-FIELD(PVSEGS, pvseg, NUM, "SSize", len, 5, uint32, "pvseg_size")
+FIELD(PVSEGS, pvseg, NUM, "Start", pe, 5, uint32, "pvseg_start", "Physical Extent number of start of segment.")
+FIELD(PVSEGS, pvseg, NUM, "SSize", len, 5, uint32, "pvseg_size", "Number of extents in segment.")
 /* *INDENT-ON* */

lib/report/report.c

@@ -66,7 +66,7 @@ static int _string_disp(struct dm_report *rh, struct dm_pool *mem,
 			struct dm_report_field *field,
 			const void *data, void *private)
 {
-	return dm_report_field_string(rh, mem, field, data);
+	return dm_report_field_string(rh, field, (const char **) data);
 }
 
 static int _dev_name_disp(struct dm_report *rh, struct dm_pool *mem,
@@ -75,7 +75,7 @@ static int _dev_name_disp(struct dm_report *rh, struct dm_pool *mem,
 {
 	const char *name = dev_name(*(const struct device **) data);
 
-	return dm_report_field_string(rh, mem, field, &name);
+	return dm_report_field_string(rh, field, &name);
 }
 
 static int _devices_disp(struct dm_report *rh, struct dm_pool *mem,
@@ -227,9 +227,9 @@ static int _lvkmaj_disp(struct dm_report *rh, struct dm_pool *mem,
 	uint64_t minusone = UINT64_C(-1);
 
 	if (lv_info(lv->vg->cmd, lv, &info, 0) && info.exists)
-		return dm_report_field_int(rh, mem, field, &info.major);
+		return dm_report_field_int(rh, field, &info.major);
 
-	return dm_report_field_int(rh, mem, field, &minusone);
+	return dm_report_field_uint64(rh, field, &minusone);
 }
 
 static int _lvkmin_disp(struct dm_report *rh, struct dm_pool *mem,
@@ -241,9 +241,9 @@ static int _lvkmin_disp(struct dm_report *rh, struct dm_pool *mem,
 	uint64_t minusone = UINT64_C(-1);
 
 	if (lv_info(lv->vg->cmd, lv, &info, 0) && info.exists)
-		return dm_report_field_int(rh, mem, field, &info.minor);
+		return dm_report_field_int(rh, field, &info.minor);
 
-	return dm_report_field_int(rh, mem, field, &minusone);
+	return dm_report_field_uint64(rh, field, &minusone);
 }
 
 static int _lvstatus_disp(struct dm_report *rh, struct dm_pool *mem,
@@ -423,8 +423,8 @@ static int _origin_disp(struct dm_report *rh, struct dm_pool *mem,
 	const struct logical_volume *lv = (const struct logical_volume *) data;
 
 	if (lv_is_cow(lv))
-		return dm_report_field_string(rh, mem, field,
-					      &origin_from_cow(lv)->name);
+		return dm_report_field_string(rh, field,
+					      (const char **) &origin_from_cow(lv)->name);
 
 	dm_report_field_set_value(field, "", NULL);
 	return 1;
@@ -440,8 +440,8 @@ static int _loglv_disp(struct dm_report *rh, struct dm_pool *mem,
 	list_iterate_items(seg, &lv->segments) {
 		if (!seg_is_mirrored(seg) || !seg->log_lv)
 			continue;
-		return dm_report_field_string(rh, mem, field,
-					      &seg->log_lv->name);
+		return dm_report_field_string(rh, field,
+					      (const char **) &seg->log_lv->name);
 	}
 
 	dm_report_field_set_value(field, "", NULL);
@@ -458,7 +458,7 @@ static int _lvname_disp(struct dm_report *rh, struct dm_pool *mem,
 
 	if (lv_is_visible(lv)) {
 		repstr = lv->name;
-		return dm_report_field_string(rh, mem, field, &repstr);
+		return dm_report_field_string(rh, field, (const char **) &repstr);
 	}
 
 	len = strlen(lv->name) + 3;
@@ -494,7 +494,7 @@ static int _movepv_disp(struct dm_report *rh, struct dm_pool *mem,
 		if (!(seg->status & PVMOVE))
 			continue;
 		name = dev_name(seg_dev(seg, 0));
-		return dm_report_field_string(rh, mem, field, &name);
+		return dm_report_field_string(rh, field, &name);
 	}
 
 	dm_report_field_set_value(field, "", NULL);
@@ -708,14 +708,14 @@ static int _uint32_disp(struct dm_report *rh, struct dm_pool *mem,
 			struct dm_report_field *field,
 			const void *data, void *private)
 {
-	return dm_report_field_uint32(rh, mem, field, data);
+	return dm_report_field_uint32(rh, field, data);
 }
 
 static int _int32_disp(struct dm_report *rh, struct dm_pool *mem,
 		       struct dm_report_field *field,
 		       const void *data, void *private)
 {
-	return dm_report_field_int32(rh, mem, field, data);
+	return dm_report_field_int32(rh, field, data);
 }
 
 static int _lvsegcount_disp(struct dm_report *rh, struct dm_pool *mem,
@@ -868,11 +868,11 @@ static const struct dm_report_object_type _report_types[] = {
 
 #define STR DM_REPORT_FIELD_TYPE_STRING
 #define NUM DM_REPORT_FIELD_TYPE_NUMBER
-#define FIELD(type, strct, sorttype, head, field, width, func, id) {type, id, (off_t)((void *)&_dummy._ ## strct.field - (void *)&_dummy._ ## strct), head, width, sorttype, &_ ## func ## _disp},
+#define FIELD(type, strct, sorttype, head, field, width, func, id, desc) {type, id, (off_t)((void *)&_dummy._ ## strct.field - (void *)&_dummy._ ## strct), head, width, sorttype, &_ ## func ## _disp, desc},
 
 static struct dm_report_field_type _fields[] = {
 #include "columns.h"
-{0, "", 0, "", 0, 0, NULL},
+{0, "", 0, "", 0, 0, NULL, NULL},
 };
 
 #undef STR

libdm/Makefile.in

@@ -90,7 +90,7 @@ install_ioctl_static: ioctl/libdevmapper.a
 .PHONY: distclean_lib distclean
 
 distclean_lib: 
-	$(RM) libdm-common.h libdevmapper.pc
+	$(RM) libdevmapper.pc
 
 distclean: distclean_lib
 

libdm/ioctl/libdm-iface.c

@@ -149,7 +149,8 @@ static int _get_proc_number(const char *file, const char *name,
 			if (!strcmp(name, nm)) {
 				if (number) {
 					*number = num;
-					fclose(fl);
+					if (fclose(fl))
+						log_error("%s: fclose failed: %s", file, strerror(errno));
 					return 1;
 				}
 				dm_bit_set(_dm_bitset, num);
@@ -158,7 +159,8 @@ static int _get_proc_number(const char *file, const char *name,
 			c = fgetc(fl);
 		} while (c != EOF && c != '\n');
 	}
-	fclose(fl);
+	if (fclose(fl))
+		log_error("%s: fclose failed: %s", file, strerror(errno));
 
 	if (number) {
 		log_error("%s: No entry for %s found", file, name);
@@ -1322,7 +1324,7 @@ static int _process_mapper_dir(struct dm_task *dmt)
 
 	dir = dm_dir();
 	if (!(d = opendir(dir))) {
-		fprintf(stderr, "opendir %s: %s", dir, strerror(errno));
+		log_error("opendir %s: %s", dir, strerror(errno));
 		return 0;
 	}
 
@@ -1335,9 +1337,8 @@ static int _process_mapper_dir(struct dm_task *dmt)
 		dm_task_run(dmt);
 	}
 
-	if (closedir(d)) {
-		fprintf(stderr, "closedir %s: %s", dir, strerror(errno));
-	}
+	if (closedir(d))
+		log_error("closedir %s: %s", dir, strerror(errno));
 
 	return r;
 }

libdm/libdevmapper.h

@@ -665,6 +665,7 @@ struct dm_report_field_type {
 	int (*report_fn)(struct dm_report *rh, struct dm_pool *mem,
 			 struct dm_report_field *field, const void *data,
 			 void *private);
+	const char *desc;	/* description of the field */
 };
 
 /*

libdm/libdm-report.c

@@ -248,6 +248,11 @@ static void _display_fields(struct dm_report *rh)
 	uint32_t f;
 	const struct dm_report_object_type *type;
 	const char *desc, *last_desc = "";
+	size_t id_len = 0;
+
+	for (f = 0; rh->fields[f].report_fn; f++)
+		if (strlen(rh->fields[f].id) > id_len)
+			id_len = strlen(rh->fields[f].id);
 
 	for (f = 0; rh->fields[f].report_fn; f++) {
 		if ((type = _find_type(rh, rh->fields[f].type)) && type->desc)
@@ -258,9 +263,14 @@ static void _display_fields(struct dm_report *rh)
 			if (*last_desc)
 				log_print(" ");
 			log_print("%s Fields", desc);
+			log_print("%*.*s", (int) strlen(desc) + 7,
+				  (int) strlen(desc) + 7,
+				  "------------------------------------------");
+				  
 		}
 
-		log_print("- %s", rh->fields[f].id);
+		/* FIXME Add line-wrapping at terminal width (or 80 cols) */
+		log_print("  %-*s - %s", (int) id_len, rh->fields[f].id, rh->fields[f].desc);
 		last_desc = desc;
 	}
 }
@@ -757,8 +767,7 @@ int dm_report_output(struct dm_report *rh)
 	/* Print and clear buffer */
 	list_iterate_safe(rowh, rtmp, &rh->rows) {
 		if (!dm_pool_begin_object(rh->mem, 512)) {
-			log_error("dm_report: "
-				  "dm_pool_begin_object failed for row");
+			log_error("dm_report: Unable to allocate output line");
 			return 0;
 		}
 		row = list_item(rowh, struct row);
@@ -771,35 +780,49 @@ int dm_report_output(struct dm_report *rh)
 			width = field->props->width;
 			if (!(rh->flags & DM_REPORT_OUTPUT_ALIGNED)) {
 				if (!dm_pool_grow_object(rh->mem, repstr,
-						      strlen(repstr)))
-					goto bad_grow;
+						      strlen(repstr))) {
+					log_error("dm_report: Unable to extend output line");
+					goto bad;
+				}
 			} else {
 				if (!(align = field->props->flags & DM_REPORT_FIELD_ALIGN_MASK))
 					align = (field->props->flags & DM_REPORT_FIELD_TYPE_NUMBER) ? 
 						DM_REPORT_FIELD_ALIGN_RIGHT : DM_REPORT_FIELD_ALIGN_LEFT;
 				if (align & DM_REPORT_FIELD_ALIGN_LEFT) {
 					if (dm_snprintf(buf, sizeof(buf), "%-*.*s",
-							 width, width, repstr) < 0)
-						goto bad_snprintf;
-					if (!dm_pool_grow_object(rh->mem, buf, width))
-						goto bad_grow;
+							 width, width, repstr) < 0) {
+						log_error("dm_report: left-aligned snprintf() failed");
+						goto bad;
+					}
+					if (!dm_pool_grow_object(rh->mem, buf, width)) {
+						log_error("dm_report: Unable to extend output line");
+						goto bad;
+					}
 				} else if (align & DM_REPORT_FIELD_ALIGN_RIGHT) {
 					if (dm_snprintf(buf, sizeof(buf), "%*.*s",
-							 width, width, repstr) < 0)
-						goto bad_snprintf;
-					if (!dm_pool_grow_object(rh->mem, buf, width))
-						goto bad_grow;
+							 width, width, repstr) < 0) {
+						log_error("dm_report: right-aligned snprintf() failed");
+						goto bad;
+					}
+					if (!dm_pool_grow_object(rh->mem, buf, width)) {
+						log_error("dm_report: Unable to extend output line");
+						goto bad;
+					}
 				}
 			}
 
 			if (!list_end(&row->fields, fh))
 				if (!dm_pool_grow_object(rh->mem, rh->separator,
-						      strlen(rh->separator)))
-					goto bad_grow;
+						      strlen(rh->separator))) {
+					log_error("dm_report: Unable to extend output line");
+					goto bad;
+				}
 			list_del(&field->list);
 		}
-		if (!dm_pool_grow_object(rh->mem, "\0", 1))
-			goto bad_grow;
+		if (!dm_pool_grow_object(rh->mem, "\0", 1)) {
+			log_error("dm_report: Unable to terminate output line");
+			goto bad;
+		}
 		log_print("%s", (char *) dm_pool_end_object(rh->mem));
 		list_del(&row->list);
 	}
@@ -809,10 +832,7 @@ int dm_report_output(struct dm_report *rh)
 
 	return 1;
 
-      bad_snprintf:
-	log_error("dm_report: snprintf row failed");
-      bad_grow:
-	log_error("dm_report: Failed to generate row for printing");
+      bad:
 	dm_pool_abandon_object(rh->mem);
 	return 0;
 }

man/vgchange.8

@@ -10,6 +10,7 @@ vgchange \- change attributes of a volume group
 .RB [ \-A | \-\-autobackup " {" y | n }]
 .RB [ \-a | \-\-available " [e|l] {" y | n }]
 .RB [ \-\-monitor " {" y | n }]
+.RB [ \-c | \-\-clustered " {" y | n }]
 .RB [ \-d | \-\-debug]
 .RB [ \-\-deltag
 .IR Tag ]
@@ -44,12 +45,12 @@ snapshots should be removed (see
 .SH OPTIONS
 See \fBlvm\fP for common options.
 .TP
-.BR \-A ", " \-\-autobackup { y | n }
+.BR \-A ", " \-\-autobackup " " { y | n }
 Controls automatic backup of metadata after the change.  See
 .B vgcfgbackup (8).
 Default is yes.
 .TP
-.BR \-a ", " \-\-available [e|l] { y | n }
+.BR \-a ", " \-\-available " " [e|l] { y | n }
 Controls the availability of the logical volumes in the volume 
 group for input/output.
 In other words, makes the logical volumes known/unknown to the kernel.
@@ -60,6 +61,14 @@ on the local node.
 Logical volumes with single-host snapshots are always activated
 exclusively because they can only be used on one node at once.
 .TP
+.BR \-c ", " \-\-clustered " " { y | n }
+If clustered locking is enabled, this indicates whether this
+Volume Group is shared with other nodes in the cluster or whether
+it contains only local disks that are not visible on the other nodes.
+If the cluster infrastructure is unavailable on a particular node at a
+particular time, you may still be able to use Volume Groups that
+are not marked as clustered.
+.TP
 .BR \-\-monitor " " { y | n }
 Controls whether or not a mirrored logical volume is monitored by
 dmeventd, if it is installed.
@@ -108,7 +117,7 @@ impact on I/O performance to the logical volume.  The smallest PE is 1KB.
  
 The 2.4 kernel has a limitation of 2TB per block device.
 .TP
-.BR \-x ", " \-\-resizeable { y | n }
+.BR \-x ", " \-\-resizeable " " { y | n }
 Enables or disables the extension/reduction of this volume group
 with/by physical volumes.
 .SH EXAMPLES

man/vgcreate.8

@@ -8,6 +8,7 @@ vgcreate \- create a volume group
 .RB [ \-\-alloc 
 .IR AllocationPolicy ]
 .RB [ \-A | \-\-autobackup " {" y | n }]
+.RB [ \-c | \-\-clustered " {" y | n }]
 .RB [ \-d | \-\-debug ]
 .RB [ \-h | \-\-help ]
 .RB [ \-l | \-\-maxlogicalvolumes
@@ -33,6 +34,14 @@ previously configured for LVM with
 .SH OPTIONS
 See \fBlvm\fP for common options.
 .TP
+.BR \-c ", " \-\-clustered " " { y | n }
+If clustered locking is enabled, this indicates whether this
+Volume Group is shared with other nodes in the cluster or whether
+it contains only local disks that are not visible on the other nodes.
+If the cluster infrastructure is unavailable on a particular node at a
+particular time, you may still be able to use Volume Groups that
+are not marked as clustered.
+.TP
 .BR \-l ", " \-\-maxlogicalvolumes " " \fIMaxLogicalVolumes\fR
 Sets the maximum number of logical volumes allowed in this
 volume group. 

scripts/lvm2_monitoring_init_rhel4

@@ -0,0 +1,98 @@
+#!/bin/bash
+#
+# Copyright (C) 2007 Red Hat, Inc. All rights reserved.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU General Public License v.2.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# This file is part of LVM2.
+# It is required for the proper handling of failures of LVM2 mirror
+# devices that were created using the -m option of lvcreate.
+#
+#
+# chkconfig: 12345 02 99
+# description: Starts and stops dmeventd monitoring for lvm2
+#	       
+### BEGIN INIT INFO
+# Provides: 
+### END INIT INFO
+
+. /etc/init.d/functions
+
+VGCHANGE="/usr/sbin/vgchange"
+
+start()
+{
+    for ret in 0
+    do
+	# TODO do we want to separate out already active groups only?
+	VGS=`vgs --noheadings -o name`
+	for vg in $VGS
+	do
+	    if ! action "Starting monitoring for VG $vg:" $VGCHANGE --monitor y $vg
+	    then
+		ret=$?
+	    fi
+	done
+
+    done
+
+    return $ret
+}
+
+
+stop()
+{
+    for ret in 0
+    do
+	# TODO do we want to separate out already active groups only?
+	VGS=`vgs --noheadings -o name`
+	for vg in $VGS
+	do
+	    if ! action "Starting monitoring for VG $vg:" $VGCHANGE --monitor n $vg
+	    then
+		ret=$?
+	    fi
+	done
+
+    done
+
+}
+
+ret=1
+
+# See how we were called.
+case "$1" in
+  start)
+	start
+	ret=$?
+	;;
+
+  stop)
+	stop
+	ret=$?
+	;;
+
+  restart)
+	if stop
+	then
+		start
+	fi 
+	ret=$?
+	;;
+
+  status)
+	# TODO anyone with an idea how to dump monitored volumes?
+	;;
+
+  *)
+	echo $"Usage: $0 {start|stop|restart|status}"
+	;;
+esac
+
+exit $ret

tools/commands.h

@@ -657,7 +657,7 @@ xx(vgcreate,
    "\t[-A|--autobackup {y|n}] " "\n"
    "\t[--addtag Tag] " "\n"
    "\t[--alloc AllocationPolicy] " "\n"
-   "\t[-c|--clustered] " "\n"
+   "\t[-c|--clustered {y|n}] " "\n"
    "\t[-d|--debug]" "\n"
    "\t[-h|--help]" "\n"
    "\t[-l|--maxlogicalvolumes MaxLogicalVolumes]" "\n"

tools/dmsetup.c

@@ -136,10 +136,22 @@ static char *_table;
 static char *_target;
 static char *_command;
 static struct dm_tree *_dtree;
+static struct dm_report *_report;
 
 /*
  * Commands
  */
+
+typedef int (*command_fn) (int argc, char **argv, void *data);
+
+struct command {
+	const char *name;
+	const char *help;
+	int min_args;
+	int max_args;
+	command_fn fn;
+};
+
 static int _parse_line(struct dm_task *dmt, char *buffer, const char *file,
 		       int line)
 {
@@ -219,71 +231,33 @@ static int _parse_file(struct dm_task *dmt, const char *file)
 #else
 	free(buffer);
 #endif
-	if (file)
-		fclose(fp);
+	if (file && fclose(fp))
+		fprintf(stderr, "%s: fclose failed: %s", file, strerror(errno));
+
 	return r;
 }
 
-static void _display_info_cols_noheadings(struct dm_task *dmt,
-					  struct dm_info *info)
+struct dmsetup_report_obj {
+	struct dm_task *task;
+	struct dm_info *info;
+};
+
+static int _display_info_cols(struct dm_task *dmt, struct dm_info *info)
 {
-	const char *uuid;
-
-	if (!info->exists)
-		return;
-
-	uuid = dm_task_get_uuid(dmt);
-
-	if (_switches[OPTIONS_ARG])
-		printf("%s\n", dm_task_get_name(dmt));
-	else
-		printf("%s:%d:%d:%s%s%s%s:%d:%d:%" PRIu32 ":%s\n",
-		       dm_task_get_name(dmt),
-		       info->major, info->minor,
-		       info->live_table ? "L" : "-",
-		       info->inactive_table ? "I" : "-",
-		       info->suspended ? "s" : "-",
-		       info->read_only ? "r" : "w",
-		       info->open_count, info->target_count, info->event_nr,
-		       uuid && *uuid ? uuid : "");
-}
-
-static void _display_info_cols(struct dm_task *dmt, struct dm_info *info)
-{
-	static int _headings = 0;
-	const char *uuid;
+	struct dmsetup_report_obj obj;
 
 	if (!info->exists) {
-		printf("Device does not exist.\n");
-		return;
+		fprintf(stderr, "Device does not exist.\n");
+		return 0;
 	}
 
-	if (!_headings) {
-		if (_switches[OPTIONS_ARG])
-			printf("Name\n");
-		else
-			printf("Name             Maj Min Stat Open Targ "
-			       "Event  UUID\n");
-		_headings = 1;
-	}
+	obj.task = dmt;
+	obj.info = info;
 
-	if (_switches[OPTIONS_ARG])
-		printf("%s\n", dm_task_get_name(dmt));
-	else {
-		printf("%-16s %3d %3d %s%s%s%s %4d %4d %6" PRIu32 " ",
-		       dm_task_get_name(dmt),
-		       info->major, info->minor,
-		       info->live_table ? "L" : "-",
-		       info->inactive_table ? "I" : "-",
-		       info->suspended ? "s" : "-",
-		       info->read_only ? "r" : "w",
-		       info->open_count, info->target_count, info->event_nr);
+	if (!dm_report_object(_report, &obj))
+		return 0;
 
-		if ((uuid = dm_task_get_uuid(dmt)) && *uuid)
-			printf("%s", uuid);
-
-		printf("\n");
-	}
+	return 1;
 }
 
 static void _display_info_long(struct dm_task *dmt, struct dm_info *info)
@@ -333,9 +307,8 @@ static int _display_info(struct dm_task *dmt)
 
 	if (!_switches[COLS_ARG])
 		_display_info_long(dmt, &info);
-	else if (_switches[NOHEADINGS_ARG])
-		_display_info_cols_noheadings(dmt, &info);
 	else
+		/* FIXME return code */
 		_display_info_cols(dmt, &info);
 
 	return info.exists ? 1 : 0;
@@ -1498,6 +1471,194 @@ static int _tree(int argc, char **argv, void *data __attribute((unused)))
 	return 1;
 }
 
+/*
+ * Report device information
+ */
+
+/* dm specific display functions */
+
+static int _int32_disp(struct dm_report *rh,
+		       struct dm_pool *mem __attribute((unused)),
+		       struct dm_report_field *field, const void *data,
+		       void *private __attribute((unused)))
+{
+	const int32_t value = *(const int32_t *)data;
+
+	return dm_report_field_int32(rh, field, &value);
+}
+
+static int _uint32_disp(struct dm_report *rh,
+			struct dm_pool *mem __attribute((unused)),
+		        struct dm_report_field *field, const void *data,
+		        void *private __attribute((unused)))
+{
+	const uint32_t value = *(const int32_t *)data;
+
+	return dm_report_field_uint32(rh, field, &value);
+}
+
+static int _dm_name_disp(struct dm_report *rh,
+			 struct dm_pool *mem __attribute((unused)),
+			 struct dm_report_field *field, const void *data,
+			 void *private __attribute((unused)))
+{
+	const char *name = dm_task_get_name((struct dm_task *) data);
+
+	return dm_report_field_string(rh, field, &name);
+}
+
+static int _dm_uuid_disp(struct dm_report *rh,
+			 struct dm_pool *mem __attribute((unused)),
+			 struct dm_report_field *field,
+			 const void *data, void *private __attribute((unused)))
+{
+	const char *uuid = dm_task_get_uuid((struct dm_task *) data);
+
+	if (!uuid || !*uuid)
+		uuid = "";
+
+	return dm_report_field_string(rh, field, &uuid);
+}
+
+static int _dm_info_status_disp(struct dm_report *rh,
+				struct dm_pool *mem __attribute((unused)),
+				struct dm_report_field *field, const void *data,
+				void *private __attribute((unused)))
+{
+	char buf[5];
+	const char *s = buf;
+	struct dm_info *info = (struct dm_info *) data;
+
+	buf[0] = info->live_table ? 'L' : '-';
+	buf[1] = info->inactive_table ? 'I' : '-';
+	buf[2] = info->suspended ? 's' : '-';
+	buf[3] = info->read_only ? 'r' : 'w';
+	buf[4] = '\0';
+
+	return dm_report_field_string(rh, field, &s);
+}
+
+/* Report types */
+enum { DR_TASK = 1, DR_INFO = 2 };
+
+static void *_task_get_obj(void *obj)
+{
+	return ((struct dmsetup_report_obj *)obj)->task;
+}
+
+static void *_info_get_obj(void *obj)
+{
+	return ((struct dmsetup_report_obj *)obj)->info;
+}
+
+static const struct dm_report_object_type _report_types[] = {
+	{ DR_TASK, "Mapped Device Name", "", _task_get_obj },
+	{ DR_INFO, "Mapped Device Information", "", _info_get_obj },
+	{ 0, "", "", NULL },
+};
+
+/* Column definitions */
+#define OFFSET_OF(strct, field) ((unsigned int) &((struct strct *)NULL)->field)
+#define STR (DM_REPORT_FIELD_TYPE_STRING)
+#define NUM (DM_REPORT_FIELD_TYPE_NUMBER)
+#define FIELD_O(type, strct, sorttype, head, field, width, func, id, desc) {DR_ ## type, id, OFFSET_OF(strct, field), head, width, sorttype, &_ ## func ## _disp, desc},
+#define FIELD_F(type, sorttype, head, width, func, id, desc) {DR_ ## type, id, 0, head, width, sorttype, &_ ## func ## _disp, desc},
+
+static const struct dm_report_field_type _report_fields[] = {
+/* *INDENT-OFF* */
+FIELD_F(TASK, STR, "Name", 16, dm_name, "name", "Name of mapped device.")
+FIELD_F(TASK, STR, "UUID", 32, dm_uuid, "uuid", "Unique identifier for mapped device (optional).")
+FIELD_F(INFO, STR, "Stat", 4, dm_info_status, "status", "Attributes.")
+FIELD_O(INFO, dm_info, NUM, "Maj", major, 3, int32, "major", "Major number.")
+FIELD_O(INFO, dm_info, NUM, "Min", minor, 3, int32, "minor", "Minor number.")
+FIELD_O(INFO, dm_info, NUM, "Open", open_count, 4, int32, "open_count", "Number of references to open device, if requested.")
+FIELD_O(INFO, dm_info, NUM, "Targ", target_count, 4, int32, "target_count", "Number of segments in live table, if present.")
+FIELD_O(INFO, dm_info, NUM, "Event", event_nr, 6, uint32, "event_nr", "Current event number.")
+{0, "", 0, "", 0, 0, NULL, NULL},
+/* *INDENT-ON* */
+};
+
+#undef STR
+#undef NUM
+#undef FIELD_O
+#undef FIELD_F
+
+static const char *default_report_options = "name,major,minor,status,open_count,target_count,event_nr,uuid";
+
+static int _report_init(struct command *c)
+{
+	char *options = (char *) default_report_options;
+	const char *keys = "";
+	const char *separator = " ";
+	int aligned = 1, headings = 1, buffered = 0;
+	uint32_t report_type = 0;
+	uint32_t flags = 0;
+	size_t len = 0;
+	int r = 0;
+
+	/* emulate old dmsetup behaviour */
+	if (_switches[NOHEADINGS_ARG]) {
+		separator = ":";
+		aligned = 0;
+		headings = 0;
+	}
+
+	if (_switches[OPTIONS_ARG] && _string_args[OPTIONS_ARG]) {
+		if (*_string_args[OPTIONS_ARG] != '+')
+			options = _string_args[OPTIONS_ARG];
+		else {
+			len = strlen(default_report_options) +
+			      strlen(_string_args[OPTIONS_ARG]) + 1;
+			if (!(options = dm_malloc(len))) {
+				err("Failed to allocate option string.");
+				return 0;
+			}
+			if (dm_snprintf(options, len, "%s,%s",
+					default_report_options,
+					&_string_args[OPTIONS_ARG][1]) < 0) {
+				err("snprintf failed");
+				goto out;
+			}
+		}
+	}
+
+	if (_switches[SORT_ARG] && _string_args[SORT_ARG]) {
+		keys = _string_args[SORT_ARG];
+		buffered = 1;
+		if (!strcmp(c->name, "status") || !strcmp(c->name, "table")) {
+			err("--sort is not yet supported with status and table");
+			goto out;
+		}
+	}
+
+	if (_switches[SEPARATOR_ARG] && _string_args[SEPARATOR_ARG]) {
+		separator = _string_args[SEPARATOR_ARG];
+		aligned = 0;
+	}
+
+	if (aligned)
+		flags |= DM_REPORT_OUTPUT_ALIGNED;
+
+	if (buffered)
+		flags |= DM_REPORT_OUTPUT_BUFFERED;
+
+	if (headings)
+		flags |= DM_REPORT_OUTPUT_HEADINGS;
+
+	if (!(_report = dm_report_init(&report_type,
+					_report_types, _report_fields,
+					options, separator, flags, keys, NULL)))
+		goto out;
+
+	r = 1;
+
+out:
+	if (len)
+		dm_free(options);
+
+	return r;
+}
+
 /*
  * List devices
  */
@@ -1513,18 +1674,8 @@ static int _ls(int argc, char **argv, void *data)
 }
 
 /*
- * dispatch table
+ * Dispatch table
  */
-typedef int (*command_fn) (int argc, char **argv, void *data);
-
-struct command {
-	const char *name;
-	const char *help;
-	int min_args;
-	int max_args;
-	command_fn fn;
-};
-
 static struct command _commands[] = {
 	{"create", "<dev_name> [-j|--major <major> -m|--minor <minor>]\n"
 	  "\t                  [-U|--uid <uid>] [-G|--gid <gid>] [-M|--mode <octal_mode>]\n"
@@ -2044,12 +2195,6 @@ static int _process_switches(int *argc, char ***argv)
 		return 0;
 	}
 
-	if (_switches[COLS_ARG] && _switches[OPTIONS_ARG] &&
-	    strcmp(_string_args[OPTIONS_ARG], "name")) {
-		fprintf(stderr, "Only -o name is supported so far.\n");
-		return 0;
-	}
-
 	if (_switches[TREE_ARG] && !_process_tree_options(_string_args[OPTIONS_ARG]))
 		return 0;
 
@@ -2098,6 +2243,9 @@ int main(int argc, char **argv)
 		goto out;
 	}
 
+	if (_switches[COLS_ARG] && !_report_init(c))
+		goto out;
+
       doit:
 	if (!c->fn(argc, argv, NULL)) {
 		fprintf(stderr, "Command failed\n");
@@ -2107,5 +2255,10 @@ int main(int argc, char **argv)
 	r = 0;
 
 out:
+	if (_report) {
+		dm_report_output(_report);
+		dm_report_free(_report);
+	}
+
 	return r;
 }

tools/lvchange.c

@@ -94,7 +94,8 @@ static int lvchange_monitoring(struct cmd_context *cmd,
 	if (lv->status & PVMOVE)
 		return 1;
 
-	if (!monitor_dev_for_events(cmd, lv, dmeventd_monitor_mode()))
+	if ((dmeventd_monitor_mode() != DMEVENTD_MONITOR_IGNORE) &&
+	    !monitor_dev_for_events(cmd, lv, dmeventd_monitor_mode()))
 		stack;
 
 	return 1;
@@ -591,7 +592,9 @@ static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
 		return ECMD_FAILED;
 	}
 
-	init_dmeventd_monitor(arg_int_value(cmd, monitor_ARG, DEFAULT_DMEVENTD_MONITOR));
+	init_dmeventd_monitor(arg_int_value(cmd, monitor_ARG,
+					    cmd->is_static ?
+					    DMEVENTD_MONITOR_IGNORE : DEFAULT_DMEVENTD_MONITOR));
 
 	/* access permission change */
 	if (arg_count(cmd, permission_ARG)) {

tools/lvmcmdline.c

@@ -1030,7 +1030,7 @@ struct cmd_context *init_lvm(unsigned is_static)
 {
 	struct cmd_context *cmd;
 
-	if (!(cmd = create_toolcontext(&the_args[0], is_static))) {
+	if (!(cmd = create_toolcontext(&the_args[0], is_static, 0))) {
 		stack;
 		return NULL;
 	}
@@ -1065,8 +1065,9 @@ static int _run_script(struct cmd_context *cmd, int argc, char **argv)
 	char buffer[CMD_LEN];
 	int ret = 0;
 	int magic_number = 0;
+	char *script_file = argv[0];
 
-	if ((script = fopen(argv[0], "r")) == NULL)
+	if ((script = fopen(script_file, "r")) == NULL)
 		return ENO_SUCH_CMD;
 
 	while (fgets(buffer, sizeof(buffer), script) != NULL) {
@@ -1099,7 +1100,9 @@ static int _run_script(struct cmd_context *cmd, int argc, char **argv)
 		lvm_run_command(cmd, argc, argv);
 	}
 
-	fclose(script);
+	if (fclose(script))
+		log_sys_error("fclose", script_file);
+
 	return ret;
 }
 

tools/reporter.c

@@ -25,7 +25,7 @@ static int _vgs_single(struct cmd_context *cmd __attribute((unused)),
 		return ECMD_FAILED;
 	}
 
-	if (!report_object(handle, vg, NULL, NULL, NULL, NULL));
+	if (!report_object(handle, vg, NULL, NULL, NULL, NULL))
 		return ECMD_FAILED;
 
 	check_current_backup(vg);
@@ -39,7 +39,7 @@ static int _lvs_single(struct cmd_context *cmd, struct logical_volume *lv,
 	if (!arg_count(cmd, all_ARG) && !lv_is_visible(lv))
 		return ECMD_PROCESSED;
 
-	if (!report_object(handle, lv->vg, lv, NULL, NULL, NULL));
+	if (!report_object(handle, lv->vg, lv, NULL, NULL, NULL))
 		return ECMD_FAILED;
 
 	return ECMD_PROCESSED;
@@ -48,7 +48,7 @@ static int _lvs_single(struct cmd_context *cmd, struct logical_volume *lv,
 static int _segs_single(struct cmd_context *cmd __attribute((unused)),
 			struct lv_segment *seg, void *handle)
 {
-	if (!report_object(handle, seg->lv->vg, seg->lv, NULL, seg, NULL));
+	if (!report_object(handle, seg->lv->vg, seg->lv, NULL, seg, NULL))
 		return ECMD_FAILED;
 
 	return ECMD_PROCESSED;
@@ -78,7 +78,7 @@ static int _pvsegs_sub_single(struct cmd_context *cmd, struct volume_group *vg,
 		goto out;
 	}
 
-	if (!report_object(handle, vg, NULL, pv, NULL, pvseg));
+	if (!report_object(handle, vg, NULL, pv, NULL, pvseg))
 		ret = ECMD_FAILED;
 
 out:
@@ -128,7 +128,7 @@ static int _pvs_single(struct cmd_context *cmd, struct volume_group *vg,
 		}
 	}
 
-	if (!report_object(handle, vg, NULL, pv, NULL, NULL));
+	if (!report_object(handle, vg, NULL, pv, NULL, NULL))
 		ret = ECMD_FAILED;
 
 out:

tools/vgchange.c

@@ -105,7 +105,8 @@ static int _vgchange_monitoring(struct cmd_context *cmd, struct volume_group *vg
 {
 	int active, monitored;
 
-	if ((active = lvs_in_vg_activated(vg))) {
+	if ((active = lvs_in_vg_activated(vg)) &&
+	    dmeventd_monitor_mode() != DMEVENTD_MONITOR_IGNORE) {
 		monitored = _monitor_lvs_in_vg(cmd, vg, dmeventd_monitor_mode());
 		log_print("%d logical volume(s) in volume group "
 			    "\"%s\" %smonitored",
@@ -146,11 +147,13 @@ static int _vgchange_available(struct cmd_context *cmd, struct volume_group *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 = _monitor_lvs_in_vg(cmd, vg, dmeventd_monitor_mode());
-		log_verbose("%d existing logical volume(s) in volume "
-			    "group \"%s\" %smonitored",
-			    monitored, vg->name,
-			    dmeventd_monitor_mode() ? "" : "un");
+		if (dmeventd_monitor_mode() != DMEVENTD_MONITOR_IGNORE) {
+			monitored = _monitor_lvs_in_vg(cmd, vg, dmeventd_monitor_mode());
+			log_verbose("%d existing logical volume(s) in volume "
+				    "group \"%s\" %smonitored",
+				    monitored, vg->name,
+				    dmeventd_monitor_mode() ? "" : "un");
+		}
 	}
 
 	if (activate && _activate_lvs_in_vg(cmd, vg, available))
@@ -532,7 +535,9 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name,
 		return ECMD_FAILED;
 	}
 
-	init_dmeventd_monitor(arg_int_value(cmd, monitor_ARG, DEFAULT_DMEVENTD_MONITOR));
+	init_dmeventd_monitor(arg_int_value(cmd, monitor_ARG,
+					    cmd->is_static ?
+					    DMEVENTD_MONITOR_IGNORE : DEFAULT_DMEVENTD_MONITOR));
 
 	if (arg_count(cmd, available_ARG))
 		r = _vgchange_available(cmd, vg);