Merge lp:~xnox/ubuntu/quantal/lvm2/merge95 into lp:ubuntu/quantal/lvm2

[Dimitri John Ledkov]

* Debian accepted some of the event manager packaging
* Debian multiarched libdevmapper libs, but not the libdevmapper-dev
* Ubuntu's "Don't install documentation in udebs" vanished and there are no traces of it
* Ubuntu's "don't ship lvm2 init script" transformed into "don't ship clvm init script" see bug 1037033
* I added libdevmapper-dev multiarching
* It looks like Debian refreshed api patch, which is now different to Ubuntu's. Since the 'new' api was only in quantal so far, I am tempted to switch for Debian's API instead & recompile. See $ bzr log -p debian/*.symbols

The rest stayed the same.

[Steve Langasek (vorlon)]

> - debian/{clvmd.ra,clvm.init}:
> - create /var/run/lvm if it doesn't exist.

debian/rules now points at /run/lvm; this should be updated to match.

--- debian/libdevmapper-dev.install 2010-12-07 08:08:45 +0000
+++ debian/libdevmapper-dev.install 2012-08-18 04:00:45 +0000
@@ -1,5 +1,2 @@
-usr/include/libdevmapper.h
-usr/include/libdevmapper-event.h
-usr/lib/libdevmapper.so
-usr/lib/pkgconfig/devmapper.pc
-usr/lib/pkgconfig/devmapper-event.pc
+usr/include/libdevmapper*
+usr/lib/*/pkgconfig/devmapper*

Hmm, good catch. I think you should call this out as a separate change in the changelog, since this isn't just a "remaining change" but a fix to multiarch support for the runtime lib package.

--- debian/lvm2.postinst 2009-10-08 18:17:43 +0000
+++ debian/lvm2.postinst 2012-08-15 17:05:32 +0000
@@ -5,7 +5,9 @@
 case "$1" in
     configure)
         vgcfgbackup >/dev/null 2>&1 || :
- invoke-rc.d lvm2 start || :
+ if [ -x /etc/init.d/lvm2 ]; then
+ invoke-rc.d lvm2 start || :
+ fi
         if [ -x /usr/sbin/update-initramfs ]; then
             update-initramfs -u
         fi

Since the lvm2.init is being dropped, this probably shouldn't be conditional - it should probably be removed entirely. In fact, when this regression was introduced during the lucid merge, the previous postinst was doing this:

    if test -f /etc/init.d/lvm2; then
        update-rc.d -f lvm2 remove >/dev/null 2>&1 || true
       rm -f /etc/init.d/lvm2
    fi

We probably want to be doing that again, possibly with better handling of modified conffiles.

BTW, perhaps it's worth checking with Kees to see if there was a reason he thought this init script should be restored when merging.

--- debian/libdevmapper-event1.02.1.symbols 2012-04-14 03:19:00 +0000
+++ debian/libdevmapper-event1.02.1.symbols 2012-08-18 04:00:45 +0000
@@ -1,11 +1,13 @@
 libdevmapper-event.so.1.02.1 libdevmapper-event1.02.1 #MINVER#
  Base@Base 2:1.02.20
- daemon_talk@Base 2:1.02.67
+ dm_event_daemon_fini_fifos@Base 2:1.02.74
+ dm_event_daemon_init_fifos@Base 2:1.02.74
+ dm_event_daemon_talk@Base 2:1.02.74

This is unfortunate, but it happens... In this case, it appears that dmeventd used the old symbol, so we want to have a Breaks against the old version of dmeventd. No other packages in Ubuntu that depend on libdevmapper-event1.02.1 appear to use that symbol, so this Breaks is the only fix needed.

- dm_event_get_version@Base 2:1.02.67
+ dm_event_get_version@Base 2:1.02.74
  dm_event_handler_create@Base 2:1.02.20
  dm_event_handler_destroy@Base 2:1.02.20
- dm_event_handler_get_dev_name@Base 2:1.02.67
+ dm_event_handler_get_dev_name@Base 2:1.02.74

Those version bumps are unnecessary in Ubuntu, but mostly harmless.

@@ -22,5 +24,3 @@
  dm_event_handler_set_uuid@Base 2:1.02.20
  dm_event_register_handler@Base 2:1.02.20
  dm_event_unregister_handler@Base 2:1.02.20
- fini_fifos@Base 2:1.02.67
- init_fifos@Base 2:1.02.67

These symbols are also only used by dmeventd. (This makes sense, as all three symbols appear to be due to a Debian-specific patch for dmeventd.)

The rest looks good to me.

review: Needs Fixing

[lp:~xnox/ubuntu/quantal/lvm2/merge95]

79. By Dimitri John Ledkov on 2012-08-21

Note additional multi-arch changes only once.

80. By Dimitri John Ledkov on 2012-08-21

(omit leading /var/): create /run/lvm if it doesn't exist.

81. By Dimitri John Ledkov on 2012-08-21

 * debian/lvm2.{preinst,postinst,postrm}:
  - Implement removal of obsolete /etc/init.d/lvm2 conffile, which
    should not have been re-introduced in Quantal.

82. By Dimitri John Ledkov on 2012-08-21

minimise diff

83. By Dimitri John Ledkov on 2012-08-21

 * libdevmapper-event1.02.1:
  - Add Breaks: dmeventd (<< 2.02.95-4ubuntu1) due to debian symbol rename

[Dimitri John Ledkov (xnox)]

Address all comments.
/etc/init.d/lvm2 was only reintroduced in quantal, added rm_conffile snippets for it which can be removed in R.

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2012-08-21 10:18:22 +0000
@@ -0,0 +1,8 @@
+install.patch
+libs-cleanup.patch
+dirs.patch
+force-modprobe.patch
+implicit-pointer.patch
+avoid-dev-block.patch
+dm-event-api.patch
+monitoring-default-off.patch

=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2012-04-14 02:57:53 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-install.patch
-libs-cleanup.patch
-dirs.patch
-force-modprobe.patch
-implicit-pointer.patch
-avoid-dev-block.patch
-monitoring-default-off.patch

=== added directory '.pc/avoid-dev-block.patch'
=== removed directory '.pc/avoid-dev-block.patch'
=== added directory '.pc/avoid-dev-block.patch/lib'
=== removed directory '.pc/avoid-dev-block.patch/lib'
=== added directory '.pc/avoid-dev-block.patch/lib/device'
=== removed directory '.pc/avoid-dev-block.patch/lib/device'
=== added file '.pc/avoid-dev-block.patch/lib/device/dev-cache.c'
--- .pc/avoid-dev-block.patch/lib/device/dev-cache.c	1970-01-01 00:00:00 +0000
+++ .pc/avoid-dev-block.patch/lib/device/dev-cache.c	2012-08-21 10:18:22 +0000
@@ -0,0 +1,1018 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "dev-cache.h"
+#include "lvm-types.h"
+#include "btree.h"
+#include "filter.h"
+#include "filter-persistent.h"
+#include "toolcontext.h"
+
+#include <unistd.h>
+#include <sys/param.h>
+#include <dirent.h>
+
+struct dev_iter {
+	struct btree_iter *current;
+	struct dev_filter *filter;
+};
+
+struct dir_list {
+	struct dm_list list;
+	char dir[0];
+};
+
+static struct {
+	struct dm_pool *mem;
+	struct dm_hash_table *names;
+	struct btree *devices;
+	struct dm_regex *preferred_names_matcher;
+	const char *dev_dir;
+
+	int has_scanned;
+	struct dm_list dirs;
+	struct dm_list files;
+
+} _cache;
+
+#define _zalloc(x) dm_pool_zalloc(_cache.mem, (x))
+#define _free(x) dm_pool_free(_cache.mem, (x))
+#define _strdup(x) dm_pool_strdup(_cache.mem, (x))
+
+static int _insert(const char *path, int rec, int check_with_udev_db);
+
+/* Setup non-zero members of passed zeroed 'struct device' */
+static void _dev_init(struct device *dev, int max_error_count)
+{
+	dev->block_size = -1;
+	dev->fd = -1;
+	dev->read_ahead = -1;
+	dev->max_error_count = max_error_count;
+
+	dm_list_init(&dev->aliases);
+	dm_list_init(&dev->open_list);
+}
+
+struct device *dev_create_file(const char *filename, struct device *dev,
+			       struct str_list *alias, int use_malloc)
+{
+	int allocate = !dev;
+
+	if (allocate) {
+		if (use_malloc) {
+			if (!(dev = dm_zalloc(sizeof(*dev)))) {
+				log_error("struct device allocation failed");
+				return NULL;
+			}
+			if (!(alias = dm_zalloc(sizeof(*alias)))) {
+				log_error("struct str_list allocation failed");
+				dm_free(dev);
+				return NULL;
+			}
+			if (!(alias->str = dm_strdup(filename))) {
+				log_error("filename strdup failed");
+				dm_free(dev);
+				dm_free(alias);
+				return NULL;
+			}
+		} else {
+			if (!(dev = _zalloc(sizeof(*dev)))) {
+				log_error("struct device allocation failed");
+				return NULL;
+			}
+			if (!(alias = _zalloc(sizeof(*alias)))) {
+				log_error("struct str_list allocation failed");
+				_free(dev);
+				return NULL;
+			}
+			if (!(alias->str = _strdup(filename))) {
+				log_error("filename strdup failed");
+				return NULL;
+			}
+		}
+	} else if (!(alias->str = dm_strdup(filename))) {
+		log_error("filename strdup failed");
+		return NULL;
+	}
+
+	_dev_init(dev, NO_DEV_ERROR_COUNT_LIMIT);
+	dev->flags = DEV_REGULAR | ((use_malloc) ? DEV_ALLOCED : 0);
+	dm_list_add(&dev->aliases, &alias->list);
+
+	return dev;
+}
+
+static struct device *_dev_create(dev_t d)
+{
+	struct device *dev;
+
+	if (!(dev = _zalloc(sizeof(*dev)))) {
+		log_error("struct device allocation failed");
+		return NULL;
+	}
+
+	_dev_init(dev, dev_disable_after_error_count());
+	dev->dev = d;
+
+	return dev;
+}
+
+void dev_set_preferred_name(struct str_list *sl, struct device *dev)
+{
+	/*
+	 * Don't interfere with ordering specified in config file.
+	 */
+	if (_cache.preferred_names_matcher)
+		return;
+
+	log_debug("%s: New preferred name", sl->str);
+	dm_list_del(&sl->list);
+	dm_list_add_h(&dev->aliases, &sl->list);
+}
+
+/*
+ * Check whether path0 or path1 contains the subpath. The path that
+ * *does not* contain the subpath wins (return 0 or 1). If both paths
+ * contain the subpath, return -1. If none of them contains the subpath,
+ * return -2.
+ */
+static int _builtin_preference(const char *path0, const char *path1,
+			       size_t skip_prefix_count, const char *subpath)
+{
+	size_t subpath_len;
+	int r0, r1;
+
+	subpath_len = strlen(subpath);
+
+	r0 = !strncmp(path0 + skip_prefix_count, subpath, subpath_len);
+	r1 = !strncmp(path1 + skip_prefix_count, subpath, subpath_len);
+
+	if (!r0 && r1)
+		/* path0 does not have the subpath - it wins */
+		return 0;
+	else if (r0 && !r1)
+		/* path1 does not have the subpath - it wins */
+		return 1;
+	else if (r0 && r1)
+		/* both of them have the subpath */
+		return -1;
+
+	/* no path has the subpath */
+	return -2;
+}
+
+static int _apply_builtin_path_preference_rules(const char *path0, const char *path1)
+{
+	size_t devdir_len;
+	int r;
+
+	devdir_len = strlen(_cache.dev_dir);
+
+	if (!strncmp(path0, _cache.dev_dir, devdir_len) &&
+	    !strncmp(path1, _cache.dev_dir, devdir_len)) {
+		/*
+		 * We're trying to achieve the ordering:
+		 *	/dev/block/ < /dev/dm-* < /dev/disk/ < /dev/mapper/ < anything else
+		 */
+
+		/* Prefer any other path over /dev/block/ path. */
+		if ((r = _builtin_preference(path0, path1, devdir_len, "block/")) >= -1)
+			return r;
+
+		/* Prefer any other path over /dev/dm-* path. */
+		if ((r = _builtin_preference(path0, path1, devdir_len, "dm-")) >= -1)
+			return r;
+
+		/* Prefer any other path over /dev/disk/ path. */
+		if ((r = _builtin_preference(path0, path1, devdir_len, "disk/")) >= -1)
+			return r;
+
+		/* Prefer any other path over /dev/mapper/ path. */
+		if ((r = _builtin_preference(path0, path1, 0, dm_dir())) >= -1)
+			return r;
+	}
+
+	return -1;
+}
+
+/* Return 1 if we prefer path1 else return 0 */
+static int _compare_paths(const char *path0, const char *path1)
+{
+	int slash0 = 0, slash1 = 0;
+	int m0, m1;
+	const char *p;
+	char p0[PATH_MAX], p1[PATH_MAX];
+	char *s0, *s1;
+	struct stat stat0, stat1;
+	int r;
+
+	/*
+	 * FIXME Better to compare patterns one-at-a-time against all names.
+	 */
+	if (_cache.preferred_names_matcher) {
+		m0 = dm_regex_match(_cache.preferred_names_matcher, path0);
+		m1 = dm_regex_match(_cache.preferred_names_matcher, path1);
+
+		if (m0 != m1) {
+			if (m0 < 0)
+				return 1;
+			if (m1 < 0)
+				return 0;
+			if (m0 < m1)
+				return 1;
+			if (m1 < m0)
+				return 0;
+		}
+	}
+
+	/* Apply built-in preference rules first. */
+	if ((r = _apply_builtin_path_preference_rules(path0, path1)) >= 0)
+		return r;
+
+	/* Return the path with fewer slashes */
+	for (p = path0; p++; p = (const char *) strchr(p, '/'))
+		slash0++;
+
+	for (p = path1; p++; p = (const char *) strchr(p, '/'))
+		slash1++;
+
+	if (slash0 < slash1)
+		return 0;
+	if (slash1 < slash0)
+		return 1;
+
+	strncpy(p0, path0, sizeof(p0) - 1);
+	p0[sizeof(p0) - 1] = '\0';
+	strncpy(p1, path1, sizeof(p1) - 1);
+	p1[sizeof(p1) - 1] = '\0';
+	s0 = p0 + 1;
+	s1 = p1 + 1;
+
+	/*
+	 * If we reach here, both paths are the same length.
+	 * Now skip past identical path components.
+	 */
+	while (*s0 && *s0 == *s1)
+		s0++, s1++;
+
+	/* We prefer symlinks - they exist for a reason!
+	 * So we prefer a shorter path before the first symlink in the name.
+	 * FIXME Configuration option to invert this? */
+	while (s0) {
+		s0 = strchr(s0, '/');
+		s1 = strchr(s1, '/');
+		if (s0) {
+			*s0 = '\0';
+			*s1 = '\0';
+		}
+		if (lstat(p0, &stat0)) {
+			log_sys_very_verbose("lstat", p0);
+			return 1;
+		}
+		if (lstat(p1, &stat1)) {
+			log_sys_very_verbose("lstat", p1);
+			return 0;
+		}
+		if (S_ISLNK(stat0.st_mode) && !S_ISLNK(stat1.st_mode))
+			return 0;
+		if (!S_ISLNK(stat0.st_mode) && S_ISLNK(stat1.st_mode))
+			return 1;
+		if (s0) {
+			*s0++ = '/';
+			*s1++ = '/';
+		}
+	}
+
+	/* ASCII comparison */
+	if (strcmp(path0, path1) < 0)
+		return 0;
+	else
+		return 1;
+}
+
+static int _add_alias(struct device *dev, const char *path)
+{
+	struct str_list *sl = _zalloc(sizeof(*sl));
+	struct str_list *strl;
+	const char *oldpath;
+	int prefer_old = 1;
+
+	if (!sl)
+		return_0;
+
+	/* Is name already there? */
+	dm_list_iterate_items(strl, &dev->aliases) {
+		if (!strcmp(strl->str, path)) {
+			log_debug("%s: Already in device cache", path);
+			return 1;
+		}
+	}
+
+	sl->str = path;
+
+	if (!dm_list_empty(&dev->aliases)) {
+		oldpath = dm_list_item(dev->aliases.n, struct str_list)->str;
+		prefer_old = _compare_paths(path, oldpath);
+		log_debug("%s: Aliased to %s in device cache%s",
+			  path, oldpath, prefer_old ? "" : " (preferred name)");
+
+	} else
+		log_debug("%s: Added to device cache", path);
+
+	if (prefer_old)
+		dm_list_add(&dev->aliases, &sl->list);
+	else
+		dm_list_add_h(&dev->aliases, &sl->list);
+
+	return 1;
+}
+
+/*
+ * Either creates a new dev, or adds an alias to
+ * an existing dev.
+ */
+static int _insert_dev(const char *path, dev_t d)
+{
+	struct device *dev;
+	static dev_t loopfile_count = 0;
+	int loopfile = 0;
+	char *path_copy;
+
+	/* Generate pretend device numbers for loopfiles */
+	if (!d) {
+		if (dm_hash_lookup(_cache.names, path))
+			return 1;
+		d = ++loopfile_count;
+		loopfile = 1;
+	}
+
+	/* is this device already registered ? */
+	if (!(dev = (struct device *) btree_lookup(_cache.devices,
+						   (uint32_t) d))) {
+		/* create new device */
+		if (loopfile) {
+			if (!(dev = dev_create_file(path, NULL, NULL, 0)))
+				return_0;
+		} else if (!(dev = _dev_create(d)))
+			return_0;
+
+		if (!(btree_insert(_cache.devices, (uint32_t) d, dev))) {
+			log_error("Couldn't insert device into binary tree.");
+			_free(dev);
+			return 0;
+		}
+	}
+
+	if (!(path_copy = dm_pool_strdup(_cache.mem, path))) {
+		log_error("Failed to duplicate path string.");
+		return 0;
+	}
+
+	if (!loopfile && !_add_alias(dev, path_copy)) {
+		log_error("Couldn't add alias to dev cache.");
+		return 0;
+	}
+
+	if (!dm_hash_insert(_cache.names, path_copy, dev)) {
+		log_error("Couldn't add name to hash in dev cache.");
+		return 0;
+	}
+
+	return 1;
+}
+
+static char *_join(const char *dir, const char *name)
+{
+	size_t len = strlen(dir) + strlen(name) + 2;
+	char *r = dm_malloc(len);
+	if (r)
+		snprintf(r, len, "%s/%s", dir, name);
+
+	return r;
+}
+
+/*
+ * Get rid of extra slashes in the path string.
+ */
+static void _collapse_slashes(char *str)
+{
+	char *ptr;
+	int was_slash = 0;
+
+	for (ptr = str; *ptr; ptr++) {
+		if (*ptr == '/') {
+			if (was_slash)
+				continue;
+
+			was_slash = 1;
+		} else
+			was_slash = 0;
+		*str++ = *ptr;
+	}
+
+	*str = *ptr;
+}
+
+static int _insert_dir(const char *dir)
+{
+	int n, dirent_count, r = 1;
+	struct dirent **dirent;
+	char *path;
+
+	dirent_count = scandir(dir, &dirent, NULL, alphasort);
+	if (dirent_count > 0) {
+		for (n = 0; n < dirent_count; n++) {
+			if (dirent[n]->d_name[0] == '.') {
+				free(dirent[n]);
+				continue;
+			}
+
+			if (!(path = _join(dir, dirent[n]->d_name)))
+				return_0;
+
+			_collapse_slashes(path);
+			r &= _insert(path, 1, 0);
+			dm_free(path);
+
+			free(dirent[n]);
+		}
+		free(dirent);
+	}
+
+	return r;
+}
+
+static int _insert_file(const char *path)
+{
+	struct stat info;
+
+	if (stat(path, &info) < 0) {
+		log_sys_very_verbose("stat", path);
+		return 0;
+	}
+
+	if (!S_ISREG(info.st_mode)) {
+		log_debug("%s: Not a regular file", path);
+		return 0;
+	}
+
+	if (!_insert_dev(path, 0))
+		return_0;
+
+	return 1;
+}
+
+#ifdef UDEV_SYNC_SUPPORT
+
+static int _device_in_udev_db(const dev_t d)
+{
+	struct udev *udev;
+	struct udev_device *udev_device;
+
+	if (!(udev = udev_get_library_context()))
+		return_0;
+
+	if ((udev_device = udev_device_new_from_devnum(udev, 'b', d))) {
+		udev_device_unref(udev_device);
+		return 1;
+	}
+
+	return 0;
+}
+
+static int _insert_udev_dir(struct udev *udev, const char *dir)
+{
+	struct udev_enumerate *udev_enum = NULL;
+	struct udev_list_entry *device_entry, *symlink_entry;
+	const char *node_name, *symlink_name;
+	struct udev_device *device;
+	int r = 1;
+
+	if (!(udev_enum = udev_enumerate_new(udev)))
+		goto bad;
+
+	if (udev_enumerate_add_match_subsystem(udev_enum, "block") ||
+	    udev_enumerate_scan_devices(udev_enum))
+		goto bad;
+
+	udev_list_entry_foreach(device_entry, udev_enumerate_get_list_entry(udev_enum)) {
+		if (!(device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(device_entry)))) {
+			log_warn("WARNING: udev failed to return a device entry.");
+			continue;
+		}
+
+		if (!(node_name = udev_device_get_devnode(device)))
+			log_warn("WARNING: udev failed to return a device node.");
+		else
+			r &= _insert(node_name, 0, 0);
+
+		udev_list_entry_foreach(symlink_entry, udev_device_get_devlinks_list_entry(device)) {
+			if (!(symlink_name = udev_list_entry_get_name(symlink_entry)))
+				log_warn("WARNING: udev failed to return a symlink name.");
+			else
+				r &= _insert(symlink_name, 0, 0);
+		}
+
+		udev_device_unref(device);
+	}
+
+	udev_enumerate_unref(udev_enum);
+	return r;
+
+bad:
+	log_error("Failed to enumerate udev device list.");
+	udev_enumerate_unref(udev_enum);
+	return 0;
+}
+
+static void _insert_dirs(struct dm_list *dirs)
+{
+	struct dir_list *dl;
+	struct udev *udev;
+	int with_udev;
+
+	with_udev = obtain_device_list_from_udev() &&
+		    (udev = udev_get_library_context());
+
+	dm_list_iterate_items(dl, &_cache.dirs) {
+		if (with_udev) {
+			if (!_insert_udev_dir(udev, dl->dir))
+				log_debug("%s: Failed to insert devices from "
+					  "udev-managed directory to device "
+					  "cache fully", dl->dir);
+		}
+		else if (!_insert_dir(dl->dir))
+			log_debug("%s: Failed to insert devices to "
+				  "device cache fully", dl->dir);
+	}
+}
+
+#else	/* UDEV_SYNC_SUPPORT */
+
+static int _device_in_udev_db(const dev_t d)
+{
+	return 0;
+}
+
+static void _insert_dirs(struct dm_list *dirs)
+{
+	struct dir_list *dl;
+
+	dm_list_iterate_items(dl, &_cache.dirs)
+		_insert_dir(dl->dir);
+}
+
+#endif	/* UDEV_SYNC_SUPPORT */
+
+static int _insert(const char *path, int rec, int check_with_udev_db)
+{
+	struct stat info;
+	int r = 0;
+
+	if (stat(path, &info) < 0) {
+		log_sys_very_verbose("stat", path);
+		return 0;
+	}
+
+	if (check_with_udev_db && !_device_in_udev_db(info.st_rdev)) {
+		log_very_verbose("%s: Not in udev db", path);
+		return 0;
+	}
+
+	if (S_ISDIR(info.st_mode)) {	/* add a directory */
+		/* check it's not a symbolic link */
+		if (lstat(path, &info) < 0) {
+			log_sys_very_verbose("lstat", path);
+			return 0;
+		}
+
+		if (S_ISLNK(info.st_mode)) {
+			log_debug("%s: Symbolic link to directory", path);
+			return 0;
+		}
+
+		if (rec)
+			r = _insert_dir(path);
+
+	} else {		/* add a device */
+		if (!S_ISBLK(info.st_mode)) {
+			log_debug("%s: Not a block device", path);
+			return 0;
+		}
+
+		if (!_insert_dev(path, info.st_rdev))
+			return_0;
+
+		r = 1;
+	}
+
+	return r;
+}
+
+static void _full_scan(int dev_scan)
+{
+	struct dir_list *dl;
+
+	if (_cache.has_scanned && !dev_scan)
+		return;
+
+	_insert_dirs(&_cache.dirs);
+
+	dm_list_iterate_items(dl, &_cache.files)
+		_insert_file(dl->dir);
+
+	_cache.has_scanned = 1;
+	init_full_scan_done(1);
+}
+
+int dev_cache_has_scanned(void)
+{
+	return _cache.has_scanned;
+}
+
+void dev_cache_scan(int do_scan)
+{
+	if (!do_scan)
+		_cache.has_scanned = 1;
+	else
+		_full_scan(1);
+}
+
+static int _init_preferred_names(struct cmd_context *cmd)
+{
+	const struct dm_config_node *cn;
+	const struct dm_config_value *v;
+	struct dm_pool *scratch = NULL;
+	const char **regex;
+	unsigned count = 0;
+	int i, r = 0;
+
+	_cache.preferred_names_matcher = NULL;
+
+	if (!(cn = find_config_tree_node(cmd, "devices/preferred_names")) ||
+	    cn->v->type == DM_CFG_EMPTY_ARRAY) {
+		log_very_verbose("devices/preferred_names not found in config file: "
+				 "using built-in preferences");
+		return 1;
+	}
+
+	for (v = cn->v; v; v = v->next) {
+		if (v->type != DM_CFG_STRING) {
+			log_error("preferred_names patterns must be enclosed in quotes");
+			return 0;
+		}
+
+		count++;
+	}
+
+	if (!(scratch = dm_pool_create("preferred device name matcher", 1024)))
+		return_0;
+
+	if (!(regex = dm_pool_alloc(scratch, sizeof(*regex) * count))) {
+		log_error("Failed to allocate preferred device name "
+			  "pattern list.");
+		goto out;
+	}
+
+	for (v = cn->v, i = count - 1; v; v = v->next, i--) {
+		if (!(regex[i] = dm_pool_strdup(scratch, v->v.str))) {
+			log_error("Failed to allocate a preferred device name "
+				  "pattern.");
+			goto out;
+		}
+	}
+
+	if (!(_cache.preferred_names_matcher =
+		dm_regex_create(_cache.mem, regex, count))) {
+		log_error("Preferred device name pattern matcher creation failed.");
+		goto out;
+	}
+
+	r = 1;
+
+out:
+	dm_pool_destroy(scratch);
+
+	return r;
+}
+
+int dev_cache_init(struct cmd_context *cmd)
+{
+	_cache.names = NULL;
+	_cache.has_scanned = 0;
+
+	if (!(_cache.mem = dm_pool_create("dev_cache", 10 * 1024)))
+		return_0;
+
+	if (!(_cache.names = dm_hash_create(128))) {
+		dm_pool_destroy(_cache.mem);
+		_cache.mem = 0;
+		return_0;
+	}
+
+	if (!(_cache.devices = btree_create(_cache.mem))) {
+		log_error("Couldn't create binary tree for dev-cache.");
+		goto bad;
+	}
+
+	if (!(_cache.dev_dir = _strdup(cmd->dev_dir))) {
+		log_error("strdup dev_dir failed.");
+		goto bad;
+	}
+
+	dm_list_init(&_cache.dirs);
+	dm_list_init(&_cache.files);
+
+	if (!_init_preferred_names(cmd))
+		goto_bad;
+
+	return 1;
+
+      bad:
+	dev_cache_exit();
+	return 0;
+}
+
+static void _check_closed(struct device *dev)
+{
+	if (dev->fd >= 0)
+		log_error("Device '%s' has been left open.", dev_name(dev));
+}
+
+static void _check_for_open_devices(void)
+{
+	dm_hash_iter(_cache.names, (dm_hash_iterate_fn) _check_closed);
+}
+
+void dev_cache_exit(void)
+{
+	if (_cache.names)
+		_check_for_open_devices();
+
+	if (_cache.preferred_names_matcher)
+		_cache.preferred_names_matcher = NULL;
+
+	if (_cache.mem) {
+		dm_pool_destroy(_cache.mem);
+		_cache.mem = NULL;
+	}
+
+	if (_cache.names) {
+		dm_hash_destroy(_cache.names);
+		_cache.names = NULL;
+	}
+
+	_cache.devices = NULL;
+	_cache.has_scanned = 0;
+	dm_list_init(&_cache.dirs);
+	dm_list_init(&_cache.files);
+}
+
+int dev_cache_add_dir(const char *path)
+{
+	struct dir_list *dl;
+	struct stat st;
+
+	if (stat(path, &st)) {
+		log_error("Ignoring %s: %s", path, strerror(errno));
+		/* But don't fail */
+		return 1;
+	}
+
+	if (!S_ISDIR(st.st_mode)) {
+		log_error("Ignoring %s: Not a directory", path);
+		return 1;
+	}
+
+	if (!(dl = _zalloc(sizeof(*dl) + strlen(path) + 1))) {
+		log_error("dir_list allocation failed");
+		return 0;
+	}
+
+	strcpy(dl->dir, path);
+	dm_list_add(&_cache.dirs, &dl->list);
+	return 1;
+}
+
+int dev_cache_add_loopfile(const char *path)
+{
+	struct dir_list *dl;
+	struct stat st;
+
+	if (stat(path, &st)) {
+		log_error("Ignoring %s: %s", path, strerror(errno));
+		/* But don't fail */
+		return 1;
+	}
+
+	if (!S_ISREG(st.st_mode)) {
+		log_error("Ignoring %s: Not a regular file", path);
+		return 1;
+	}
+
+	if (!(dl = _zalloc(sizeof(*dl) + strlen(path) + 1))) {
+		log_error("dir_list allocation failed for file");
+		return 0;
+	}
+
+	strcpy(dl->dir, path);
+	dm_list_add(&_cache.files, &dl->list);
+	return 1;
+}
+
+/* Check cached device name is still valid before returning it */
+/* This should be a rare occurrence */
+/* set quiet if the cache is expected to be out-of-date */
+/* FIXME Make rest of code pass/cache struct device instead of dev_name */
+const char *dev_name_confirmed(struct device *dev, int quiet)
+{
+	struct stat buf;
+	const char *name;
+	int r;
+
+	if ((dev->flags & DEV_REGULAR))
+		return dev_name(dev);
+
+	while ((r = stat(name = dm_list_item(dev->aliases.n,
+					  struct str_list)->str, &buf)) ||
+	       (buf.st_rdev != dev->dev)) {
+		if (r < 0) {
+			if (quiet)
+				log_sys_debug("stat", name);
+			else
+				log_sys_error("stat", name);
+		}
+		if (quiet)
+			log_debug("Path %s no longer valid for device(%d,%d)",
+				  name, (int) MAJOR(dev->dev),
+				  (int) MINOR(dev->dev));
+		else
+			log_error("Path %s no longer valid for device(%d,%d)",
+				  name, (int) MAJOR(dev->dev),
+				  (int) MINOR(dev->dev));
+
+		/* Remove the incorrect hash entry */
+		dm_hash_remove(_cache.names, name);
+
+		/* Leave list alone if there isn't an alternative name */
+		/* so dev_name will always find something to return. */
+		/* Otherwise add the name to the correct device. */
+		if (dm_list_size(&dev->aliases) > 1) {
+			dm_list_del(dev->aliases.n);
+			if (!r)
+				_insert(name, 0, obtain_device_list_from_udev());
+			continue;
+		}
+
+		/* Scanning issues this inappropriately sometimes. */
+		log_debug("Aborting - please provide new pathname for what "
+			  "used to be %s", name);
+		return NULL;
+	}
+
+	return dev_name(dev);
+}
+
+struct device *dev_cache_get(const char *name, struct dev_filter *f)
+{
+	struct stat buf;
+	struct device *d = (struct device *) dm_hash_lookup(_cache.names, name);
+
+	if (d && (d->flags & DEV_REGULAR))
+		return d;
+
+	/* If the entry's wrong, remove it */
+	if (d && (stat(name, &buf) || (buf.st_rdev != d->dev))) {
+		dm_hash_remove(_cache.names, name);
+		d = NULL;
+	}
+
+	if (!d) {
+		_insert(name, 0, obtain_device_list_from_udev());
+		d = (struct device *) dm_hash_lookup(_cache.names, name);
+		if (!d) {
+			_full_scan(0);
+			d = (struct device *) dm_hash_lookup(_cache.names, name);
+		}
+	}
+
+	return (d && (!f || (d->flags & DEV_REGULAR) ||
+		      f->passes_filter(f, d))) ? d : NULL;
+}
+
+static struct device *_dev_cache_seek_devt(dev_t dev)
+{
+	struct device *d = NULL;
+	struct dm_hash_node *n = dm_hash_get_first(_cache.names);
+	while (n) {
+		d = dm_hash_get_data(_cache.names, n);
+		if (d->dev == dev)
+			return d;
+		n = dm_hash_get_next(_cache.names, n);
+	}
+	return NULL;
+}
+
+/*
+ * TODO This is very inefficient. We probably want a hash table indexed by
+ * major:minor for keys to speed up these lookups.
+ */
+struct device *dev_cache_get_by_devt(dev_t dev, struct dev_filter *f)
+{
+	struct device *d = _dev_cache_seek_devt(dev);
+
+	if (d && (d->flags & DEV_REGULAR))
+		return d;
+
+	if (!d) {
+		_full_scan(0);
+		d = _dev_cache_seek_devt(dev);
+	}
+
+	return (d && (!f || (d->flags & DEV_REGULAR) ||
+		      f->passes_filter(f, d))) ? d : NULL;
+}
+
+struct dev_iter *dev_iter_create(struct dev_filter *f, int dev_scan)
+{
+	struct dev_iter *di = dm_malloc(sizeof(*di));
+
+	if (!di) {
+		log_error("dev_iter allocation failed");
+		return NULL;
+	}
+
+	if (dev_scan && !trust_cache()) {
+		/* Flag gets reset between each command */
+		if (!full_scan_done())
+			persistent_filter_wipe(f); /* Calls _full_scan(1) */
+	} else
+		_full_scan(0);
+
+	di->current = btree_first(_cache.devices);
+	di->filter = f;
+	di->filter->use_count++;
+
+	return di;
+}
+
+void dev_iter_destroy(struct dev_iter *iter)
+{
+	iter->filter->use_count--;
+	dm_free(iter);
+}
+
+static struct device *_iter_next(struct dev_iter *iter)
+{
+	struct device *d = btree_get_data(iter->current);
+	iter->current = btree_next(iter->current);
+	return d;
+}
+
+struct device *dev_iter_get(struct dev_iter *iter)
+{
+	while (iter->current) {
+		struct device *d = _iter_next(iter);
+		if (!iter->filter || (d->flags & DEV_REGULAR) ||
+		    iter->filter->passes_filter(iter->filter, d))
+			return d;
+	}
+
+	return NULL;
+}
+
+void dev_reset_error_count(struct cmd_context *cmd)
+{
+	struct dev_iter iter;
+
+	if (!_cache.devices)
+		return;
+
+	iter.current = btree_first(_cache.devices);
+	while (iter.current)
+		_iter_next(&iter)->error_count = 0;
+}
+
+int dev_fd(struct device *dev)
+{
+	return dev->fd;
+}
+
+const char *dev_name(const struct device *dev)
+{
+	return (dev) ? dm_list_item(dev->aliases.n, struct str_list)->str :
+	    "unknown device";
+}

=== removed file '.pc/avoid-dev-block.patch/lib/device/dev-cache.c'
--- .pc/avoid-dev-block.patch/lib/device/dev-cache.c	2012-04-14 02:57:53 +0000
+++ .pc/avoid-dev-block.patch/lib/device/dev-cache.c	1970-01-01 00:00:00 +0000
@@ -1,976 +0,0 @@
-/*
- * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
- *
- * This file is part of LVM2.
- *
- * This copyrighted material is made available to anyone wishing to use,
- * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU Lesser General Public License v.2.1.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include "lib.h"
-#include "dev-cache.h"
-#include "lvm-types.h"
-#include "btree.h"
-#include "filter.h"
-#include "filter-persistent.h"
-#include "toolcontext.h"
-
-#include <unistd.h>
-#include <sys/param.h>
-#include <dirent.h>
-
-struct dev_iter {
-	struct btree_iter *current;
-	struct dev_filter *filter;
-};
-
-struct dir_list {
-	struct dm_list list;
-	char dir[0];
-};
-
-static struct {
-	struct dm_pool *mem;
-	struct dm_hash_table *names;
-	struct btree *devices;
-	struct dm_regex *preferred_names_matcher;
-	const char *dev_dir;
-
-	int has_scanned;
-	struct dm_list dirs;
-	struct dm_list files;
-
-} _cache;
-
-#define _alloc(x) dm_pool_zalloc(_cache.mem, (x))
-#define _free(x) dm_pool_free(_cache.mem, (x))
-#define _strdup(x) dm_pool_strdup(_cache.mem, (x))
-
-static int _insert(const char *path, int rec, int check_with_udev_db);
-
-struct device *dev_create_file(const char *filename, struct device *dev,
-			       struct str_list *alias, int use_malloc)
-{
-	int allocate = !dev;
-
-	if (allocate) {
-		if (use_malloc) {
-			if (!(dev = dm_malloc(sizeof(*dev)))) {
-				log_error("struct device allocation failed");
-				return NULL;
-			}
-			if (!(alias = dm_malloc(sizeof(*alias)))) {
-				log_error("struct str_list allocation failed");
-				dm_free(dev);
-				return NULL;
-			}
-			if (!(alias->str = dm_strdup(filename))) {
-				log_error("filename strdup failed");
-				dm_free(dev);
-				dm_free(alias);
-				return NULL;
-			}
-			dev->flags = DEV_ALLOCED;
-		} else {
-			if (!(dev = _alloc(sizeof(*dev)))) {
-				log_error("struct device allocation failed");
-				return NULL;
-			}
-			if (!(alias = _alloc(sizeof(*alias)))) {
-				log_error("struct str_list allocation failed");
-				_free(dev);
-				return NULL;
-			}
-			if (!(alias->str = _strdup(filename))) {
-				log_error("filename strdup failed");
-				return NULL;
-			}
-		}
-	} else if (!(alias->str = dm_strdup(filename))) {
-		log_error("filename strdup failed");
-		return NULL;
-	}
-
-	dev->flags |= DEV_REGULAR;
-	dm_list_init(&dev->aliases);
-	dm_list_add(&dev->aliases, &alias->list);
-	dev->end = UINT64_C(0);
-	dev->dev = 0;
-	dev->fd = -1;
-	dev->open_count = 0;
-	dev->error_count = 0;
-	dev->max_error_count = NO_DEV_ERROR_COUNT_LIMIT;
-	dev->block_size = -1;
-	dev->read_ahead = -1;
-	memset(dev->pvid, 0, sizeof(dev->pvid));
-	dm_list_init(&dev->open_list);
-
-	return dev;
-}
-
-static struct device *_dev_create(dev_t d)
-{
-	struct device *dev;
-
-	if (!(dev = _alloc(sizeof(*dev)))) {
-		log_error("struct device allocation failed");
-		return NULL;
-	}
-	dev->flags = 0;
-	dm_list_init(&dev->aliases);
-	dev->dev = d;
-	dev->fd = -1;
-	dev->open_count = 0;
-	dev->max_error_count = dev_disable_after_error_count();
-	dev->block_size = -1;
-	dev->read_ahead = -1;
-	dev->end = UINT64_C(0);
-	memset(dev->pvid, 0, sizeof(dev->pvid));
-	dm_list_init(&dev->open_list);
-
-	return dev;
-}
-
-void dev_set_preferred_name(struct str_list *sl, struct device *dev)
-{
-	/*
-	 * Don't interfere with ordering specified in config file.
-	 */
-	if (_cache.preferred_names_matcher)
-		return;
-
-	log_debug("%s: New preferred name", sl->str);
-	dm_list_del(&sl->list);
-	dm_list_add_h(&dev->aliases, &sl->list);
-}
-
-/*
- * Check whether path0 or path1 contains the subpath. The path that
- * *does not* contain the subpath wins (return 0 or 1). If both paths
- * contain the subpath, return -1. If none of them contains the subpath,
- * return -2.
- */
-static int _builtin_preference(const char *path0, const char *path1,
-			       size_t skip_prefix_count, const char *subpath)
-{
-	size_t subpath_len;
-	int r0, r1;
-
-	subpath_len = strlen(subpath);
-
-	r0 = !strncmp(path0 + skip_prefix_count, subpath, subpath_len);
-	r1 = !strncmp(path1 + skip_prefix_count, subpath, subpath_len);
-
-	if (!r0 && r1)
-		/* path0 does not have the subpath - it wins */
-		return 0;
-	else if (r0 && !r1)
-		/* path1 does not have the subpath - it wins */
-		return 1;
-	else if (r0 && r1)
-		/* both of them have the subpath */
-		return -1;
-
-	/* no path has the subpath */
-	return -2;
-}
-
-static int _apply_builtin_path_preference_rules(const char *path0, const char *path1)
-{
-	size_t devdir_len;
-	int r;
-
-	devdir_len = strlen(_cache.dev_dir);
-
-	if (!strncmp(path0, _cache.dev_dir, devdir_len) &&
-	    !strncmp(path1, _cache.dev_dir, devdir_len)) {
-		/*
-		 * We're trying to achieve the ordering:
-		 *	/dev/block/ < /dev/dm-* < /dev/disk/ < /dev/mapper/ < anything else
-		 */
-
-		/* Prefer any other path over /dev/block/ path. */
-		if ((r = _builtin_preference(path0, path1, devdir_len, "block/")) >= -1)
-			return r;
-
-		/* Prefer any other path over /dev/dm-* path. */
-		if ((r = _builtin_preference(path0, path1, devdir_len, "dm-")) >= -1)
-			return r;
-
-		/* Prefer any other path over /dev/disk/ path. */
-		if ((r = _builtin_preference(path0, path1, devdir_len, "disk/")) >= -1)
-			return r;
-
-		/* Prefer any other path over /dev/mapper/ path. */
-		if ((r = _builtin_preference(path0, path1, 0, dm_dir())) >= -1)
-			return r;
-	}
-
-	return -1;
-}
-
-/* Return 1 if we prefer path1 else return 0 */
-static int _compare_paths(const char *path0, const char *path1)
-{
-	int slash0 = 0, slash1 = 0;
-	int m0, m1;
-	const char *p;
-	char p0[PATH_MAX], p1[PATH_MAX];
-	char *s0, *s1;
-	struct stat stat0, stat1;
-	int r;
-
-	/*
-	 * FIXME Better to compare patterns one-at-a-time against all names.
-	 */
-	if (_cache.preferred_names_matcher) {
-		m0 = dm_regex_match(_cache.preferred_names_matcher, path0);
-		m1 = dm_regex_match(_cache.preferred_names_matcher, path1);
-
-		if (m0 != m1) {
-			if (m0 < 0)
-				return 1;
-			if (m1 < 0)
-				return 0;
-			if (m0 < m1)
-				return 1;
-			if (m1 < m0)
-				return 0;
-		}
-	}
-
-	/* Apply built-in preference rules first. */
-	if ((r = _apply_builtin_path_preference_rules(path0, path1)) >= 0)
-		return r;
-
-	/* Return the path with fewer slashes */
-	for (p = path0; p++; p = (const char *) strchr(p, '/'))
-		slash0++;
-
-	for (p = path1; p++; p = (const char *) strchr(p, '/'))
-		slash1++;
-
-	if (slash0 < slash1)
-		return 0;
-	if (slash1 < slash0)
-		return 1;
-
-	strncpy(p0, path0, PATH_MAX);
-	strncpy(p1, path1, PATH_MAX);
-	s0 = &p0[0] + 1;
-	s1 = &p1[0] + 1;
-
-	/* We prefer symlinks - they exist for a reason!
-	 * So we prefer a shorter path before the first symlink in the name.
-	 * FIXME Configuration option to invert this? */
-	while (s0) {
-		s0 = strchr(s0, '/');
-		s1 = strchr(s1, '/');
-		if (s0) {
-			*s0 = '\0';
-			*s1 = '\0';
-		}
-		if (lstat(p0, &stat0)) {
-			log_sys_very_verbose("lstat", p0);
-			return 1;
-		}
-		if (lstat(p1, &stat1)) {
-			log_sys_very_verbose("lstat", p1);
-			return 0;
-		}
-		if (S_ISLNK(stat0.st_mode) && !S_ISLNK(stat1.st_mode))
-			return 0;
-		if (!S_ISLNK(stat0.st_mode) && S_ISLNK(stat1.st_mode))
-			return 1;
-		if (s0) {
-			*s0++ = '/';
-			*s1++ = '/';
-		}
-	}
-
-	/* ASCII comparison */
-	if (strcmp(path0, path1) < 0)
-		return 0;
-	else
-		return 1;
-}
-
-static int _add_alias(struct device *dev, const char *path)
-{
-	struct str_list *sl = _alloc(sizeof(*sl));
-	struct str_list *strl;
-	const char *oldpath;
-	int prefer_old = 1;
-
-	if (!sl)
-		return_0;
-
-	/* Is name already there? */
-	dm_list_iterate_items(strl, &dev->aliases) {
-		if (!strcmp(strl->str, path)) {
-			log_debug("%s: Already in device cache", path);
-			return 1;
-		}
-	}
-
-	sl->str = path;
-
-	if (!dm_list_empty(&dev->aliases)) {
-		oldpath = dm_list_item(dev->aliases.n, struct str_list)->str;
-		prefer_old = _compare_paths(path, oldpath);
-		log_debug("%s: Aliased to %s in device cache%s",
-			  path, oldpath, prefer_old ? "" : " (preferred name)");
-
-	} else
-		log_debug("%s: Added to device cache", path);
-
-	if (prefer_old)
-		dm_list_add(&dev->aliases, &sl->list);
-	else
-		dm_list_add_h(&dev->aliases, &sl->list);
-
-	return 1;
-}
-
-/*
- * Either creates a new dev, or adds an alias to
- * an existing dev.
- */
-static int _insert_dev(const char *path, dev_t d)
-{
-	struct device *dev;
-	static dev_t loopfile_count = 0;
-	int loopfile = 0;
-	char *path_copy;
-
-	/* Generate pretend device numbers for loopfiles */
-	if (!d) {
-		if (dm_hash_lookup(_cache.names, path))
-			return 1;
-		d = ++loopfile_count;
-		loopfile = 1;
-	}
-
-	/* is this device already registered ? */
-	if (!(dev = (struct device *) btree_lookup(_cache.devices,
-						   (uint32_t) d))) {
-		/* create new device */
-		if (loopfile) {
-			if (!(dev = dev_create_file(path, NULL, NULL, 0)))
-				return_0;
-		} else if (!(dev = _dev_create(d)))
-			return_0;
-
-		if (!(btree_insert(_cache.devices, (uint32_t) d, dev))) {
-			log_error("Couldn't insert device into binary tree.");
-			_free(dev);
-			return 0;
-		}
-	}
-
-	if (!(path_copy = dm_pool_strdup(_cache.mem, path))) {
-		log_error("Failed to duplicate path string.");
-		return 0;
-	}
-
-	if (!loopfile && !_add_alias(dev, path_copy)) {
-		log_error("Couldn't add alias to dev cache.");
-		return 0;
-	}
-
-	if (!dm_hash_insert(_cache.names, path_copy, dev)) {
-		log_error("Couldn't add name to hash in dev cache.");
-		return 0;
-	}
-
-	return 1;
-}
-
-static char *_join(const char *dir, const char *name)
-{
-	size_t len = strlen(dir) + strlen(name) + 2;
-	char *r = dm_malloc(len);
-	if (r)
-		snprintf(r, len, "%s/%s", dir, name);
-
-	return r;
-}
-
-/*
- * Get rid of extra slashes in the path string.
- */
-static void _collapse_slashes(char *str)
-{
-	char *ptr;
-	int was_slash = 0;
-
-	for (ptr = str; *ptr; ptr++) {
-		if (*ptr == '/') {
-			if (was_slash)
-				continue;
-
-			was_slash = 1;
-		} else
-			was_slash = 0;
-		*str++ = *ptr;
-	}
-
-	*str = *ptr;
-}
-
-static int _insert_dir(const char *dir)
-{
-	int n, dirent_count, r = 1;
-	struct dirent **dirent;
-	char *path;
-
-	dirent_count = scandir(dir, &dirent, NULL, alphasort);
-	if (dirent_count > 0) {
-		for (n = 0; n < dirent_count; n++) {
-			if (dirent[n]->d_name[0] == '.') {
-				free(dirent[n]);
-				continue;
-			}
-
-			if (!(path = _join(dir, dirent[n]->d_name)))
-				return_0;
-
-			_collapse_slashes(path);
-			r &= _insert(path, 1, 0);
-			dm_free(path);
-
-			free(dirent[n]);
-		}
-		free(dirent);
-	}
-
-	return r;
-}
-
-static int _insert_file(const char *path)
-{
-	struct stat info;
-
-	if (stat(path, &info) < 0) {
-		log_sys_very_verbose("stat", path);
-		return 0;
-	}
-
-	if (!S_ISREG(info.st_mode)) {
-		log_debug("%s: Not a regular file", path);
-		return 0;
-	}
-
-	if (!_insert_dev(path, 0))
-		return_0;
-
-	return 1;
-}
-
-#ifdef UDEV_SYNC_SUPPORT
-
-static int _device_in_udev_db(const dev_t d)
-{
-	struct udev *udev;
-	struct udev_device *udev_device;
-
-	if (!(udev = udev_get_library_context()))
-		return_0;
-
-	if ((udev_device = udev_device_new_from_devnum(udev, 'b', d))) {
-		udev_device_unref(udev_device);
-		return 1;
-	}
-
-	return 0;
-}
-
-static int _insert_udev_dir(struct udev *udev, const char *dir)
-{
-	struct udev_enumerate *udev_enum = NULL;
-	struct udev_list_entry *device_entry, *symlink_entry;
-	const char *node_name, *symlink_name;
-	struct udev_device *device;
-	int r = 1;
-
-	if (!(udev_enum = udev_enumerate_new(udev)))
-		goto bad;
-
-	if (udev_enumerate_add_match_subsystem(udev_enum, "block") ||
-	    udev_enumerate_scan_devices(udev_enum))
-		goto bad;
-
-	udev_list_entry_foreach(device_entry, udev_enumerate_get_list_entry(udev_enum)) {
-		device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(device_entry));
-
-		node_name = udev_device_get_devnode(device);
-		r &= _insert(node_name, 0, 0);
-
-		udev_list_entry_foreach(symlink_entry, udev_device_get_devlinks_list_entry(device)) {
-			symlink_name = udev_list_entry_get_name(symlink_entry);
-			r &= _insert(symlink_name, 0, 0);
-		}
-
-		udev_device_unref(device);
-	}
-
-	udev_enumerate_unref(udev_enum);
-	return r;
-
-bad:
-	log_error("Failed to enumerate udev device list.");
-	udev_enumerate_unref(udev_enum);
-	return 0;
-}
-
-static void _insert_dirs(struct dm_list *dirs)
-{
-	struct dir_list *dl;
-	struct udev *udev;
-	int with_udev;
-
-	with_udev = obtain_device_list_from_udev() &&
-		    (udev = udev_get_library_context());
-
-	dm_list_iterate_items(dl, &_cache.dirs) {
-		if (with_udev) {
-			if (!_insert_udev_dir(udev, dl->dir))
-				log_debug("%s: Failed to insert devices from "
-					  "udev-managed directory to device "
-					  "cache fully", dl->dir);
-		}
-		else if (!_insert_dir(dl->dir))
-			log_debug("%s: Failed to insert devices to "
-				  "device cache fully", dl->dir);
-	}
-}
-
-#else	/* UDEV_SYNC_SUPPORT */
-
-static int _device_in_udev_db(const dev_t d)
-{
-	return 0;
-}
-
-static void _insert_dirs(struct dm_list *dirs)
-{
-	struct dir_list *dl;
-
-	dm_list_iterate_items(dl, &_cache.dirs)
-		_insert_dir(dl->dir);
-}
-
-#endif	/* UDEV_SYNC_SUPPORT */
-
-static int _insert(const char *path, int rec, int check_with_udev_db)
-{
-	struct stat info;
-	int r = 0;
-
-	if (stat(path, &info) < 0) {
-		log_sys_very_verbose("stat", path);
-		return 0;
-	}
-
-	if (check_with_udev_db && !_device_in_udev_db(info.st_rdev)) {
-		log_very_verbose("%s: Not in udev db", path);
-		return 0;
-	}
-
-	if (S_ISDIR(info.st_mode)) {	/* add a directory */
-		/* check it's not a symbolic link */
-		if (lstat(path, &info) < 0) {
-			log_sys_very_verbose("lstat", path);
-			return 0;
-		}
-
-		if (S_ISLNK(info.st_mode)) {
-			log_debug("%s: Symbolic link to directory", path);
-			return 0;
-		}
-
-		if (rec)
-			r = _insert_dir(path);
-
-	} else {		/* add a device */
-		if (!S_ISBLK(info.st_mode)) {
-			log_debug("%s: Not a block device", path);
-			return 0;
-		}
-
-		if (!_insert_dev(path, info.st_rdev))
-			return_0;
-
-		r = 1;
-	}
-
-	return r;
-}
-
-static void _full_scan(int dev_scan)
-{
-	struct dir_list *dl;
-
-	if (_cache.has_scanned && !dev_scan)
-		return;
-
-	_insert_dirs(&_cache.dirs);
-
-	dm_list_iterate_items(dl, &_cache.files)
-		_insert_file(dl->dir);
-
-	_cache.has_scanned = 1;
-	init_full_scan_done(1);
-}
-
-int dev_cache_has_scanned(void)
-{
-	return _cache.has_scanned;
-}
-
-void dev_cache_scan(int do_scan)
-{
-	if (!do_scan)
-		_cache.has_scanned = 1;
-	else
-		_full_scan(1);
-}
-
-static int _init_preferred_names(struct cmd_context *cmd)
-{
-	const struct config_node *cn;
-	const struct config_value *v;
-	struct dm_pool *scratch = NULL;
-	const char **regex;
-	unsigned count = 0;
-	int i, r = 0;
-
-	_cache.preferred_names_matcher = NULL;
-
-	if (!(cn = find_config_tree_node(cmd, "devices/preferred_names")) ||
-	    cn->v->type == CFG_EMPTY_ARRAY) {
-		log_very_verbose("devices/preferred_names not found in config file: "
-				 "using built-in preferences");
-		return 1;
-	}
-
-	for (v = cn->v; v; v = v->next) {
-		if (v->type != CFG_STRING) {
-			log_error("preferred_names patterns must be enclosed in quotes");
-			return 0;
-		}
-
-		count++;
-	}
-
-	if (!(scratch = dm_pool_create("preferred device name matcher", 1024)))
-		return_0;
-
-	if (!(regex = dm_pool_alloc(scratch, sizeof(*regex) * count))) {
-		log_error("Failed to allocate preferred device name "
-			  "pattern list.");
-		goto out;
-	}
-
-	for (v = cn->v, i = count - 1; v; v = v->next, i--) {
-		if (!(regex[i] = dm_pool_strdup(scratch, v->v.str))) {
-			log_error("Failed to allocate a preferred device name "
-				  "pattern.");
-			goto out;
-		}
-	}
-
-	if (!(_cache.preferred_names_matcher =
-		dm_regex_create(_cache.mem, regex, count))) {
-		log_error("Preferred device name pattern matcher creation failed.");
-		goto out;
-	}
-
-	r = 1;
-
-out:
-	dm_pool_destroy(scratch);
-
-	return r;
-}
-
-int dev_cache_init(struct cmd_context *cmd)
-{
-	_cache.names = NULL;
-	_cache.has_scanned = 0;
-
-	if (!(_cache.mem = dm_pool_create("dev_cache", 10 * 1024)))
-		return_0;
-
-	if (!(_cache.names = dm_hash_create(128))) {
-		dm_pool_destroy(_cache.mem);
-		_cache.mem = 0;
-		return_0;
-	}
-
-	if (!(_cache.devices = btree_create(_cache.mem))) {
-		log_error("Couldn't create binary tree for dev-cache.");
-		goto bad;
-	}
-
-	if (!(_cache.dev_dir = _strdup(cmd->dev_dir))) {
-		log_error("strdup dev_dir failed.");
-		goto bad;
-	}
-
-	dm_list_init(&_cache.dirs);
-	dm_list_init(&_cache.files);
-
-	if (!_init_preferred_names(cmd))
-		goto_bad;
-
-	return 1;
-
-      bad:
-	dev_cache_exit();
-	return 0;
-}
-
-static void _check_closed(struct device *dev)
-{
-	if (dev->fd >= 0)
-		log_error("Device '%s' has been left open.", dev_name(dev));
-}
-
-static void _check_for_open_devices(void)
-{
-	dm_hash_iter(_cache.names, (dm_hash_iterate_fn) _check_closed);
-}
-
-void dev_cache_exit(void)
-{
-	if (_cache.names)
-		_check_for_open_devices();
-
-	if (_cache.preferred_names_matcher)
-		_cache.preferred_names_matcher = NULL;
-
-	if (_cache.mem) {
-		dm_pool_destroy(_cache.mem);
-		_cache.mem = NULL;
-	}
-
-	if (_cache.names) {
-		dm_hash_destroy(_cache.names);
-		_cache.names = NULL;
-	}
-
-	_cache.devices = NULL;
-	_cache.has_scanned = 0;
-	dm_list_init(&_cache.dirs);
-	dm_list_init(&_cache.files);
-}
-
-int dev_cache_add_dir(const char *path)
-{
-	struct dir_list *dl;
-	struct stat st;
-
-	if (stat(path, &st)) {
-		log_error("Ignoring %s: %s", path, strerror(errno));
-		/* But don't fail */
-		return 1;
-	}
-
-	if (!S_ISDIR(st.st_mode)) {
-		log_error("Ignoring %s: Not a directory", path);
-		return 1;
-	}
-
-	if (!(dl = _alloc(sizeof(*dl) + strlen(path) + 1))) {
-		log_error("dir_list allocation failed");
-		return 0;
-	}
-
-	strcpy(dl->dir, path);
-	dm_list_add(&_cache.dirs, &dl->list);
-	return 1;
-}
-
-int dev_cache_add_loopfile(const char *path)
-{
-	struct dir_list *dl;
-	struct stat st;
-
-	if (stat(path, &st)) {
-		log_error("Ignoring %s: %s", path, strerror(errno));
-		/* But don't fail */
-		return 1;
-	}
-
-	if (!S_ISREG(st.st_mode)) {
-		log_error("Ignoring %s: Not a regular file", path);
-		return 1;
-	}
-
-	if (!(dl = _alloc(sizeof(*dl) + strlen(path) + 1))) {
-		log_error("dir_list allocation failed for file");
-		return 0;
-	}
-
-	strcpy(dl->dir, path);
-	dm_list_add(&_cache.files, &dl->list);
-	return 1;
-}
-
-/* Check cached device name is still valid before returning it */
-/* This should be a rare occurrence */
-/* set quiet if the cache is expected to be out-of-date */
-/* FIXME Make rest of code pass/cache struct device instead of dev_name */
-const char *dev_name_confirmed(struct device *dev, int quiet)
-{
-	struct stat buf;
-	const char *name;
-	int r;
-
-	if ((dev->flags & DEV_REGULAR))
-		return dev_name(dev);
-
-	while ((r = stat(name = dm_list_item(dev->aliases.n,
-					  struct str_list)->str, &buf)) ||
-	       (buf.st_rdev != dev->dev)) {
-		if (r < 0) {
-			if (quiet)
-				log_sys_debug("stat", name);
-			else
-				log_sys_error("stat", name);
-		}
-		if (quiet)
-			log_debug("Path %s no longer valid for device(%d,%d)",
-				  name, (int) MAJOR(dev->dev),
-				  (int) MINOR(dev->dev));
-		else
-			log_error("Path %s no longer valid for device(%d,%d)",
-				  name, (int) MAJOR(dev->dev),
-				  (int) MINOR(dev->dev));
-
-		/* Remove the incorrect hash entry */
-		dm_hash_remove(_cache.names, name);
-
-		/* Leave list alone if there isn't an alternative name */
-		/* so dev_name will always find something to return. */
-		/* Otherwise add the name to the correct device. */
-		if (dm_list_size(&dev->aliases) > 1) {
-			dm_list_del(dev->aliases.n);
-			if (!r)
-				_insert(name, 0, obtain_device_list_from_udev());
-			continue;
-		}
-
-		/* Scanning issues this inappropriately sometimes. */
-		log_debug("Aborting - please provide new pathname for what "
-			  "used to be %s", name);
-		return NULL;
-	}
-
-	return dev_name(dev);
-}
-
-struct device *dev_cache_get(const char *name, struct dev_filter *f)
-{
-	struct stat buf;
-	struct device *d = (struct device *) dm_hash_lookup(_cache.names, name);
-
-	if (d && (d->flags & DEV_REGULAR))
-		return d;
-
-	/* If the entry's wrong, remove it */
-	if (d && (stat(name, &buf) || (buf.st_rdev != d->dev))) {
-		dm_hash_remove(_cache.names, name);
-		d = NULL;
-	}
-
-	if (!d) {
-		_insert(name, 0, obtain_device_list_from_udev());
-		d = (struct device *) dm_hash_lookup(_cache.names, name);
-		if (!d) {
-			_full_scan(0);
-			d = (struct device *) dm_hash_lookup(_cache.names, name);
-		}
-	}
-
-	return (d && (!f || (d->flags & DEV_REGULAR) ||
-		      f->passes_filter(f, d))) ? d : NULL;
-}
-
-struct dev_iter *dev_iter_create(struct dev_filter *f, int dev_scan)
-{
-	struct dev_iter *di = dm_malloc(sizeof(*di));
-
-	if (!di) {
-		log_error("dev_iter allocation failed");
-		return NULL;
-	}
-
-	if (dev_scan && !trust_cache()) {
-		/* Flag gets reset between each command */
-		if (!full_scan_done())
-			persistent_filter_wipe(f); /* Calls _full_scan(1) */
-	} else
-		_full_scan(0);
-
-	di->current = btree_first(_cache.devices);
-	di->filter = f;
-	di->filter->use_count++;
-
-	return di;
-}
-
-void dev_iter_destroy(struct dev_iter *iter)
-{
-	iter->filter->use_count--;
-	dm_free(iter);
-}
-
-static struct device *_iter_next(struct dev_iter *iter)
-{
-	struct device *d = btree_get_data(iter->current);
-	iter->current = btree_next(iter->current);
-	return d;
-}
-
-struct device *dev_iter_get(struct dev_iter *iter)
-{
-	while (iter->current) {
-		struct device *d = _iter_next(iter);
-		if (!iter->filter || (d->flags & DEV_REGULAR) ||
-		    iter->filter->passes_filter(iter->filter, d))
-			return d;
-	}
-
-	return NULL;
-}
-
-void dev_reset_error_count(struct cmd_context *cmd)
-{
-	struct dev_iter iter;
-
-	if (!_cache.devices)
-		return;
-
-	iter.current = btree_first(_cache.devices);
-	while (iter.current)
-		_iter_next(&iter)->error_count = 0;
-}
-
-int dev_fd(struct device *dev)
-{
-	return dev->fd;
-}
-
-const char *dev_name(const struct device *dev)
-{
-	return (dev) ? dm_list_item(dev->aliases.n, struct str_list)->str :
-	    "unknown device";
-}

=== added directory '.pc/dirs.patch'
=== removed directory '.pc/dirs.patch'
=== added directory '.pc/dirs.patch/daemons'
=== added directory '.pc/dirs.patch/daemons/dmeventd'
=== added file '.pc/dirs.patch/daemons/dmeventd/Makefile.in'
--- .pc/dirs.patch/daemons/dmeventd/Makefile.in	1970-01-01 00:00:00 +0000
+++ .pc/dirs.patch/daemons/dmeventd/Makefile.in	2012-08-21 10:18:22 +0000
@@ -0,0 +1,108 @@
+#
+# Copyright (C) 2005-2011 Red Hat, Inc. All rights reserved.
+#
+# This file is part of the device-mapper userspace tools.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU Lesser General Public License v.2.1.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+top_builddir = @top_builddir@
+
+SOURCES = libdevmapper-event.c
+SOURCES2 = dmeventd.c
+
+TARGETS = dmeventd
+
+.PHONY: install_lib_dynamic install_lib_static install_include \
+	install_pkgconfig install_dmeventd_dynamic install_dmeventd_static \
+	install_lib install_dmeventd
+
+INSTALL_DMEVENTD_TARGETS = install_dmeventd_dynamic
+INSTALL_LIB_TARGETS = install_lib_dynamic
+
+LIB_NAME = libdevmapper-event
+ifeq ("@STATIC_LINK@", "yes")
+  LIB_STATIC = $(LIB_NAME).a
+  TARGETS += $(LIB_STATIC) dmeventd.static
+  INSTALL_DMEVENTD_TARGETS += install_dmeventd_static
+  INSTALL_LIB_TARGETS += install_lib_static
+endif
+
+LIB_VERSION = $(LIB_VERSION_DM)
+LIB_SHARED = $(LIB_NAME).$(LIB_SUFFIX)
+
+CLEAN_TARGETS = dmeventd.static $(LIB_NAME).a
+
+ifneq ($(MAKECMDGOALS),device-mapper)
+  SUBDIRS+=plugins
+endif
+
+CFLOW_LIST = $(SOURCES)
+CFLOW_LIST_TARGET = $(LIB_NAME).cflow
+CFLOW_TARGET = dmeventd
+
+EXPORTED_HEADER = $(srcdir)/libdevmapper-event.h
+EXPORTED_FN_PREFIX = dm_event
+
+include $(top_builddir)/make.tmpl
+
+all: device-mapper
+device-mapper: $(TARGETS)
+
+LIBS += -ldevmapper
+LVMLIBS += -ldevmapper-event $(PTHREAD_LIBS)
+
+dmeventd: $(LIB_SHARED) dmeventd.o
+	$(CC) $(CFLAGS) $(LDFLAGS) $(ELDFLAGS) -L. -o $@ dmeventd.o \
+	$(DL_LIBS) $(LVMLIBS) $(LIBS) -rdynamic
+
+dmeventd.static: $(LIB_STATIC) dmeventd.o $(interfacebuilddir)/libdevmapper.a
+	$(CC) $(CFLAGS) $(LDFLAGS) $(ELDFLAGS) -static -L. -L$(interfacebuilddir) -o $@ \
+	dmeventd.o $(DL_LIBS) $(LVMLIBS) $(LIBS) $(STATIC_LIBS)
+
+ifeq ("@PKGCONFIG@", "yes")
+  INSTALL_LIB_TARGETS += install_pkgconfig
+endif
+
+ifneq ("$(CFLOW_CMD)", "")
+CFLOW_SOURCES = $(addprefix $(srcdir)/, $(SOURCES))
+-include $(top_builddir)/libdm/libdevmapper.cflow
+-include $(top_builddir)/lib/liblvm-internal.cflow
+-include $(top_builddir)/lib/liblvm2cmd.cflow
+-include $(top_builddir)/daemons/dmeventd/$(LIB_NAME).cflow
+-include $(top_builddir)/daemons/dmeventd/plugins/mirror/$(LIB_NAME)-lvm2mirror.cflow
+endif
+
+install_include: $(srcdir)/libdevmapper-event.h
+	$(INSTALL_DATA) -D $< $(includedir)/$(<F)
+
+install_pkgconfig: libdevmapper-event.pc
+	$(INSTALL_DATA) -D $< $(pkgconfigdir)/devmapper-event.pc
+
+install_lib_dynamic: install_lib_shared
+
+install_lib_static: $(LIB_STATIC)
+	$(INSTALL_DATA) -D $< $(usrlibdir)/$(<F)
+
+install_lib: $(INSTALL_LIB_TARGETS)
+
+install_dmeventd_dynamic: dmeventd
+	$(INSTALL_PROGRAM) -D $< $(sbindir)/$(<F)
+
+install_dmeventd_static: dmeventd.static
+	$(INSTALL_PROGRAM) -D $< $(staticdir)/$(<F)
+
+install_dmeventd: $(INSTALL_DMEVENTD_TARGETS)
+
+install: install_include install_lib install_dmeventd
+
+install_device-mapper: install_include install_lib install_dmeventd
+
+DISTCLEAN_TARGETS += libdevmapper-event.pc

=== added file '.pc/dirs.patch/daemons/dmeventd/dmeventd.c'
--- .pc/dirs.patch/daemons/dmeventd/dmeventd.c	1970-01-01 00:00:00 +0000
+++ .pc/dirs.patch/daemons/dmeventd/dmeventd.c	2012-08-21 10:18:22 +0000
@@ -0,0 +1,2009 @@
+/*
+ * Copyright (C) 2005-2007 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/*
+ * dmeventd - dm event daemon to monitor active mapped devices
+ */
+
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include "configure.h"
+#include "libdevmapper.h"
+#include "libdevmapper-event.h"
+#include "dmeventd.h"
+//#include "libmultilog.h"
+#include "dm-logging.h"
+
+#include <dlfcn.h>
+#include <errno.h>
+#include <pthread.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <unistd.h>
+#include <signal.h>
+#include <arpa/inet.h>		/* for htonl, ntohl */
+
+#ifdef linux
+#  include <malloc.h>
+
+/*
+ * Kernel version 2.6.36 and higher has
+ * new OOM killer adjustment interface.
+ */
+#  define OOM_ADJ_FILE_OLD "/proc/self/oom_adj"
+#  define OOM_ADJ_FILE "/proc/self/oom_score_adj"
+
+/* From linux/oom.h */
+/* Old interface */
+#  define OOM_DISABLE (-17)
+#  define OOM_ADJUST_MIN (-16)
+/* New interface */
+#  define OOM_SCORE_ADJ_MIN (-1000)
+
+/* Systemd on-demand activation support */
+#  define SD_LISTEN_PID_ENV_VAR_NAME "LISTEN_PID"
+#  define SD_LISTEN_FDS_ENV_VAR_NAME "LISTEN_FDS"
+#  define SD_LISTEN_FDS_START 3
+#  define SD_FD_FIFO_SERVER SD_LISTEN_FDS_START
+#  define SD_FD_FIFO_CLIENT (SD_LISTEN_FDS_START + 1)
+
+#endif
+
+/* FIXME We use syslog for now, because multilog is not yet implemented */
+#include <syslog.h>
+
+static volatile sig_atomic_t _exit_now = 0;	/* set to '1' when signal is given to exit */
+static volatile sig_atomic_t _thread_registries_empty = 1;	/* registries are empty initially */
+
+/* List (un)link macros. */
+#define	LINK(x, head)		dm_list_add(head, &(x)->list)
+#define	LINK_DSO(dso)		LINK(dso, &_dso_registry)
+#define	LINK_THREAD(thread)	LINK(thread, &_thread_registry)
+
+#define	UNLINK(x)		dm_list_del(&(x)->list)
+#define	UNLINK_DSO(x)		UNLINK(x)
+#define	UNLINK_THREAD(x)	UNLINK(x)
+
+#define DAEMON_NAME "dmeventd"
+
+/*
+  Global mutex for thread list access. Has to be held when:
+  - iterating thread list
+  - adding or removing elements from thread list
+  - changing or reading thread_status's fields:
+    processing, status, events
+  Use _lock_mutex() and _unlock_mutex() to hold/release it
+*/
+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
+
+#define THREAD_STACK_SIZE (300*1024)
+
+int dmeventd_debug = 0;
+static int _systemd_activation = 0;
+static int _foreground = 0;
+static int _restart = 0;
+static char **_initial_registrations = 0;
+
+/* Data kept about a DSO. */
+struct dso_data {
+	struct dm_list list;
+
+	char *dso_name;		/* DSO name (eg, "evms", "dmraid", "lvm2"). */
+
+	void *dso_handle;	/* Opaque handle as returned from dlopen(). */
+	unsigned int ref_count;	/* Library reference count. */
+
+	/*
+	 * Event processing.
+	 *
+	 * The DSO can do whatever appropriate steps if an event
+	 * happens such as changing the mapping in case a mirror
+	 * fails, update the application metadata etc.
+	 *
+	 * This function gets a dm_task that is a result of
+	 * DM_DEVICE_WAITEVENT ioctl (results equivalent to
+	 * 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 **user);
+
+	/*
+	 * Device registration.
+	 *
+	 * When an application registers a device for an event, the DSO
+	 * can carry out appropriate steps so that a later call to
+	 * the process_event() function is sane (eg, read metadata
+	 * and activate a mapping).
+	 */
+	int (*register_device)(const char *device, const char *uuid, int major,
+			       int minor, void **user);
+
+	/*
+	 * Device unregistration.
+	 *
+	 * In case all devices of a mapping (eg, RAID10) are unregistered
+	 * for events, the DSO can recognize this and carry out appropriate
+	 * steps (eg, deactivate mapping, metadata update).
+	 */
+	int (*unregister_device)(const char *device, const char *uuid,
+				 int major, int minor, void **user);
+};
+static DM_LIST_INIT(_dso_registry);
+
+/* Structure to keep parsed register variables from client message. */
+struct message_data {
+	char *id;
+	char *dso_name;		/* Name of DSO. */
+	char *device_uuid;	/* Mapped device path. */
+	union {
+		char *str;	/* Events string as fetched from message. */
+		enum dm_event_mask field;	/* Events bitfield. */
+	} events;
+	union {
+		char *str;
+		uint32_t secs;
+	} timeout;
+	struct dm_event_daemon_message *msg;	/* Pointer to message buffer. */
+};
+
+/*
+ * Housekeeping of thread+device states.
+ *
+ * One thread per mapped device which can block on it until an event
+ * occurs and the event processing function of the DSO gets called.
+ */
+struct thread_status {
+	struct dm_list list;
+
+	pthread_t thread;
+
+	struct dso_data *dso_data;	/* DSO this thread accesses. */
+
+	struct {
+		char *uuid;
+		char *name;
+		int major, minor;
+	} device;
+	uint32_t event_nr;	/* event number */
+	int processing;		/* Set when event is being processed */
+
+	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 dm_list timeout_list;
+	void *dso_private; /* dso per-thread status variable */
+};
+static DM_LIST_INIT(_thread_registry);
+static DM_LIST_INIT(_thread_registry_unused);
+
+static int _timeout_running;
+static DM_LIST_INIT(_timeout_registry);
+static pthread_mutex_t _timeout_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t _timeout_cond = PTHREAD_COND_INITIALIZER;
+
+/* Allocate/free the status structure for a monitoring thread. */
+static struct thread_status *_alloc_thread_status(struct message_data *data,
+						  struct dso_data *dso_data)
+{
+	struct thread_status *ret = (typeof(ret)) dm_zalloc(sizeof(*ret));
+
+	if (!ret)
+		return NULL;
+
+	if (!(ret->device.uuid = dm_strdup(data->device_uuid))) {
+		dm_free(ret);
+		return NULL;
+	}
+
+	ret->current_task = NULL;
+	ret->device.name = NULL;
+	ret->device.major = ret->device.minor = 0;
+	ret->dso_data = dso_data;
+	ret->events = data->events.field;
+	ret->timeout = data->timeout.secs;
+	dm_list_init(&ret->timeout_list);
+
+	return ret;
+}
+
+static void _lib_put(struct dso_data *data);
+static void _free_thread_status(struct thread_status *thread)
+{
+	_lib_put(thread->dso_data);
+	if (thread->current_task)
+		dm_task_destroy(thread->current_task);
+	dm_free(thread->device.uuid);
+	dm_free(thread->device.name);
+	dm_free(thread);
+}
+
+/* Allocate/free DSO data. */
+static struct dso_data *_alloc_dso_data(struct message_data *data)
+{
+	struct dso_data *ret = (typeof(ret)) dm_zalloc(sizeof(*ret));
+
+	if (!ret)
+		return NULL;
+
+	if (!(ret->dso_name = dm_strdup(data->dso_name))) {
+		dm_free(ret);
+		return NULL;
+	}
+
+	return ret;
+}
+
+/* Create a device monitoring thread. */
+static int _pthread_create_smallstack(pthread_t *t, void *(*fun)(void *), void *arg)
+{
+	pthread_attr_t attr;
+	pthread_attr_init(&attr);
+	/*
+	 * We use a smaller stack since it gets preallocated in its entirety
+	 */
+	pthread_attr_setstacksize(&attr, THREAD_STACK_SIZE);
+	return pthread_create(t, &attr, fun, arg);
+}
+
+static void _free_dso_data(struct dso_data *data)
+{
+	dm_free(data->dso_name);
+	dm_free(data);
+}
+
+/*
+ * Fetch a string off src and duplicate it into *ptr.
+ * Pay attention to zero-length strings.
+ */
+/* FIXME? move to libdevmapper to share with the client lib (need to
+   make delimiter a parameter then) */
+static int _fetch_string(char **ptr, char **src, const int delimiter)
+{
+	int ret = 0;
+	char *p;
+	size_t len;
+
+	if ((p = strchr(*src, delimiter)))
+		*p = 0;
+
+	if ((*ptr = dm_strdup(*src))) {
+		if ((len = strlen(*ptr)))
+			*src += len;
+		else {
+			dm_free(*ptr);
+			*ptr = NULL;
+		}
+
+		(*src)++;
+		ret = 1;
+	}
+
+	if (p)
+		*p = delimiter;
+
+	return ret;
+}
+
+/* Free message memory. */
+static void _free_message(struct message_data *message_data)
+{
+	dm_free(message_data->id);
+	dm_free(message_data->dso_name);
+
+	dm_free(message_data->device_uuid);
+
+}
+
+/* Parse a register message from the client. */
+static int _parse_message(struct message_data *message_data)
+{
+	int ret = 0;
+	char *p = message_data->msg->data;
+	struct dm_event_daemon_message *msg = message_data->msg;
+
+	if (!msg->data)
+		return 0;
+
+	/*
+	 * Retrieve application identifier, mapped device
+	 * path and events # string from message.
+	 */
+	if (_fetch_string(&message_data->id, &p, ' ') &&
+	    _fetch_string(&message_data->dso_name, &p, ' ') &&
+	    _fetch_string(&message_data->device_uuid, &p, ' ') &&
+	    _fetch_string(&message_data->events.str, &p, ' ') &&
+	    _fetch_string(&message_data->timeout.str, &p, ' ')) {
+		if (message_data->events.str) {
+			enum dm_event_mask i = atoi(message_data->events.str);
+
+			/*
+			 * Free string representaion of events.
+			 * Not needed an more.
+			 */
+			dm_free(message_data->events.str);
+			message_data->events.field = i;
+		}
+		if (message_data->timeout.str) {
+			uint32_t secs = atoi(message_data->timeout.str);
+			dm_free(message_data->timeout.str);
+			message_data->timeout.secs = secs ? secs :
+			    DM_EVENT_DEFAULT_TIMEOUT;
+		}
+
+		ret = 1;
+	}
+
+	dm_free(msg->data);
+	msg->data = NULL;
+	msg->size = 0;
+	return ret;
+};
+
+/* Global mutex to lock access to lists et al. See _global_mutex
+   above. */
+static int _lock_mutex(void)
+{
+	return pthread_mutex_lock(&_global_mutex);
+}
+
+static int _unlock_mutex(void)
+{
+	return pthread_mutex_unlock(&_global_mutex);
+}
+
+/* Check, if a device exists. */
+static int _fill_device_data(struct thread_status *ts)
+{
+	struct dm_task *dmt;
+	struct dm_info dmi;
+
+	if (!ts->device.uuid)
+		return 0;
+
+	ts->device.name = NULL;
+	ts->device.major = ts->device.minor = 0;
+
+	dmt = dm_task_create(DM_DEVICE_INFO);
+	if (!dmt)
+		return 0;
+
+	if (!dm_task_set_uuid(dmt, ts->device.uuid))
+		goto fail;
+
+	if (!dm_task_run(dmt))
+		goto fail;
+
+	ts->device.name = dm_strdup(dm_task_get_name(dmt));
+	if (!ts->device.name)
+		goto fail;
+
+	if (!dm_task_get_info(dmt, &dmi))
+		goto fail;
+
+	ts->device.major = dmi.major;
+	ts->device.minor = dmi.minor;
+
+	dm_task_destroy(dmt);
+	return 1;
+
+      fail:
+	dm_task_destroy(dmt);
+	dm_free(ts->device.name);
+	return 0;
+}
+
+/*
+ * Find an existing thread for a device.
+ *
+ * Mutex must be held when calling this.
+ */
+static struct thread_status *_lookup_thread_status(struct message_data *data)
+{
+	struct thread_status *thread;
+
+	dm_list_iterate_items(thread, &_thread_registry)
+	    if (!strcmp(data->device_uuid, thread->device.uuid))
+		return thread;
+
+	return NULL;
+}
+
+static int _get_status(struct message_data *message_data)
+{
+	struct dm_event_daemon_message *msg = message_data->msg;
+	struct thread_status *thread;
+	int i, j;
+	int ret = -1;
+	int count = dm_list_size(&_thread_registry);
+	int size = 0, current = 0;
+	char *buffers[count];
+	char *message;
+
+	dm_free(msg->data);
+
+	for (i = 0; i < count; ++i)
+		buffers[i] = NULL;
+
+	i = 0;
+	_lock_mutex();
+	dm_list_iterate_items(thread, &_thread_registry) {
+		if ((current = dm_asprintf(buffers + i, "0:%d %s %s %u %" PRIu32 ";",
+					   i, thread->dso_data->dso_name,
+					   thread->device.uuid, thread->events,
+					   thread->timeout)) < 0) {
+			_unlock_mutex();
+			goto out;
+		}
+		++ i;
+		size += current;
+	}
+	_unlock_mutex();
+
+	msg->size = size + strlen(message_data->id) + 1;
+	msg->data = dm_malloc(msg->size);
+	if (!msg->data)
+		goto out;
+	*msg->data = 0;
+
+	message = msg->data;
+	strcpy(message, message_data->id);
+	message += strlen(message_data->id);
+	*message = ' ';
+	message ++;
+	for (j = 0; j < i; ++j) {
+		strcpy(message, buffers[j]);
+		message += strlen(buffers[j]);
+	}
+
+	ret = 0;
+ out:
+	for (j = 0; j < i; ++j)
+		dm_free(buffers[j]);
+	return ret;
+
+}
+
+/* Cleanup at exit. */
+static void _exit_dm_lib(void)
+{
+	dm_lib_release();
+	dm_lib_exit();
+}
+
+static void _exit_timeout(void *unused __attribute__((unused)))
+{
+	_timeout_running = 0;
+	pthread_mutex_unlock(&_timeout_mutex);
+}
+
+/* Wake up monitor threads every so often. */
+static void *_timeout_thread(void *unused __attribute__((unused)))
+{
+	struct timespec timeout;
+	time_t curr_time;
+
+	timeout.tv_nsec = 0;
+	pthread_cleanup_push(_exit_timeout, NULL);
+	pthread_mutex_lock(&_timeout_mutex);
+
+	while (!dm_list_empty(&_timeout_registry)) {
+		struct thread_status *thread;
+
+		timeout.tv_sec = 0;
+		curr_time = time(NULL);
+
+		dm_list_iterate_items_gen(thread, &_timeout_registry, timeout_list) {
+			if (thread->next_time <= curr_time) {
+				thread->next_time = curr_time + thread->timeout;
+				pthread_kill(thread->thread, SIGALRM);
+			}
+
+			if (thread->next_time < timeout.tv_sec || !timeout.tv_sec)
+				timeout.tv_sec = thread->next_time;
+		}
+
+		pthread_cond_timedwait(&_timeout_cond, &_timeout_mutex,
+				       &timeout);
+	}
+
+	pthread_cleanup_pop(1);
+
+	return NULL;
+}
+
+static int _register_for_timeout(struct thread_status *thread)
+{
+	int ret = 0;
+
+	pthread_mutex_lock(&_timeout_mutex);
+
+	thread->next_time = time(NULL) + thread->timeout;
+
+	if (dm_list_empty(&thread->timeout_list)) {
+		dm_list_add(&_timeout_registry, &thread->timeout_list);
+		if (_timeout_running)
+			pthread_cond_signal(&_timeout_cond);
+	}
+
+	if (!_timeout_running) {
+		pthread_t timeout_id;
+
+		if (!(ret = -_pthread_create_smallstack(&timeout_id, _timeout_thread, NULL)))
+			_timeout_running = 1;
+	}
+
+	pthread_mutex_unlock(&_timeout_mutex);
+
+	return ret;
+}
+
+static void _unregister_for_timeout(struct thread_status *thread)
+{
+	pthread_mutex_lock(&_timeout_mutex);
+	if (!dm_list_empty(&thread->timeout_list)) {
+		dm_list_del(&thread->timeout_list);
+		dm_list_init(&thread->timeout_list);
+	}
+	pthread_mutex_unlock(&_timeout_mutex);
+}
+
+__attribute__((format(printf, 4, 5)))
+static void _no_intr_log(int level, const char *file, int line,
+			const char *f, ...)
+{
+	va_list ap;
+
+	if (errno == EINTR)
+		return;
+	if (level > _LOG_WARN)
+		return;
+
+	va_start(ap, f);
+
+	if (level < _LOG_WARN)
+		vfprintf(stderr, f, ap);
+	else
+		vprintf(f, ap);
+
+	va_end(ap);
+
+	if (level < _LOG_WARN)
+		fprintf(stderr, "\n");
+	else
+		fprintf(stdout, "\n");
+}
+
+static sigset_t _unblock_sigalrm(void)
+{
+	sigset_t set, old;
+
+	sigemptyset(&set);
+	sigaddset(&set, SIGALRM);
+	pthread_sigmask(SIG_UNBLOCK, &set, &old);
+	return old;
+}
+
+#define DM_WAIT_RETRY 0
+#define DM_WAIT_INTR 1
+#define DM_WAIT_FATAL 2
+
+/* Wait on a device until an event occurs. */
+static int _event_wait(struct thread_status *thread, struct dm_task **task)
+{
+	sigset_t set;
+	int ret = DM_WAIT_RETRY;
+	struct dm_task *dmt;
+	struct dm_info info;
+
+	*task = 0;
+
+	if (!(dmt = dm_task_create(DM_DEVICE_WAITEVENT)))
+		return DM_WAIT_RETRY;
+
+	thread->current_task = dmt;
+
+	if (!dm_task_set_uuid(dmt, thread->device.uuid) ||
+	    !dm_task_set_event_nr(dmt, thread->event_nr))
+		goto out;
+
+	/*
+	 * This is so that you can break out of waiting on an event,
+	 * either for a timeout event, or to cancel the thread.
+	 */
+	set = _unblock_sigalrm();
+	dm_log_init(_no_intr_log);
+	errno = 0;
+	if (dm_task_run(dmt)) {
+		thread->current_events |= DM_EVENT_DEVICE_ERROR;
+		ret = DM_WAIT_INTR;
+
+		if ((ret = dm_task_get_info(dmt, &info)))
+			thread->event_nr = info.event_nr;
+	} else if (thread->events & DM_EVENT_TIMEOUT && errno == EINTR) {
+		thread->current_events |= DM_EVENT_TIMEOUT;
+		ret = DM_WAIT_INTR;
+	} else if (thread->status == DM_THREAD_SHUTDOWN && errno == EINTR) {
+		ret = DM_WAIT_FATAL;
+	} else {
+		syslog(LOG_NOTICE, "dm_task_run failed, errno = %d, %s",
+		       errno, strerror(errno));
+		if (errno == ENXIO) {
+			syslog(LOG_ERR, "%s disappeared, detaching",
+			       thread->device.name);
+			ret = DM_WAIT_FATAL;
+		}
+	}
+
+	pthread_sigmask(SIG_SETMASK, &set, NULL);
+	dm_log_init(NULL);
+
+      out:
+	if (ret == DM_WAIT_FATAL || ret == DM_WAIT_RETRY) {
+		dm_task_destroy(dmt);
+		thread->current_task = NULL;
+	} else
+		*task = dmt;
+
+	return ret;
+}
+
+/* Register a device with the DSO. */
+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->dso_private));
+}
+
+/* Unregister a device with the DSO. */
+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->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_private));
+}
+
+/* Thread cleanup handler to unregister device. */
+static void _monitor_unregister(void *arg)
+{
+	struct thread_status *thread = arg, *thread_iter;
+
+	if (!_do_unregister_device(thread))
+		syslog(LOG_ERR, "%s: %s unregister failed\n", __func__,
+		       thread->device.name);
+	if (thread->current_task)
+		dm_task_destroy(thread->current_task);
+	thread->current_task = NULL;
+
+	_lock_mutex();
+	if (thread->events & DM_EVENT_TIMEOUT) {
+		/* _unregister_for_timeout locks another mutex, we
+		   don't want to deadlock so we release our mutex for
+		   a bit */
+		_unlock_mutex();
+		_unregister_for_timeout(thread);
+		_lock_mutex();
+	}
+	/* we may have been relinked to unused registry since we were
+	   called, so check that */
+	dm_list_iterate_items(thread_iter, &_thread_registry_unused)
+		if (thread_iter == thread) {
+			thread->status = DM_THREAD_DONE;
+			_unlock_mutex();
+			return;
+		}
+	thread->status = DM_THREAD_DONE;
+	pthread_mutex_lock(&_timeout_mutex);
+	UNLINK_THREAD(thread);
+	LINK(thread, &_thread_registry_unused);
+	pthread_mutex_unlock(&_timeout_mutex);
+	_unlock_mutex();
+}
+
+static struct dm_task *_get_device_status(struct thread_status *ts)
+{
+	struct dm_task *dmt = dm_task_create(DM_DEVICE_STATUS);
+
+	if (!dmt)
+		return NULL;
+
+	if (!dm_task_set_uuid(dmt, ts->device.uuid)) {
+		dm_task_destroy(dmt);
+		return NULL;
+	}
+
+	if (!dm_task_run(dmt)) {
+		dm_task_destroy(dmt);
+		return NULL;
+	}
+
+	return dmt;
+}
+
+/* Device monitoring thread. */
+static void *_monitor_thread(void *arg)
+{
+	struct thread_status *thread = arg;
+	int wait_error = 0;
+	struct dm_task *task;
+
+	pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
+	pthread_cleanup_push(_monitor_unregister, thread);
+
+	/* Wait for do_process_request() to finish its task. */
+	_lock_mutex();
+	thread->status = DM_THREAD_RUNNING;
+	_unlock_mutex();
+
+	/* Loop forever awaiting/analyzing device events. */
+	while (1) {
+		thread->current_events = 0;
+
+		wait_error = _event_wait(thread, &task);
+		if (wait_error == DM_WAIT_RETRY)
+			continue;
+
+		if (wait_error == DM_WAIT_FATAL)
+			break;
+
+		/* Timeout occurred, task is not filled properly.
+		 * We get device status here for processing it in DSO.
+		 */
+		if (wait_error == DM_WAIT_INTR &&
+		    thread->current_events & DM_EVENT_TIMEOUT) {
+			dm_task_destroy(task);
+			task = _get_device_status(thread);
+			/* FIXME: syslog fail here ? */
+			if (!(thread->current_task = task))
+				continue;
+		}
+
+		/*
+		 * We know that wait succeeded and stored a
+		 * pointer to dm_task with device status into task.
+		 */
+
+		/*
+		 * Check against filter.
+		 *
+		 * If there's current events delivered from _event_wait() AND
+		 * the device got registered for those events AND
+		 * those events haven't been processed yet, call
+		 * the DSO's process_event() handler.
+		 */
+		_lock_mutex();
+		if (thread->status == DM_THREAD_SHUTDOWN) {
+			_unlock_mutex();
+			break;
+		}
+		_unlock_mutex();
+
+		if (thread->events & thread->current_events) {
+			_lock_mutex();
+			thread->processing = 1;
+			_unlock_mutex();
+
+			_do_process_event(thread, task);
+			dm_task_destroy(task);
+			thread->current_task = NULL;
+
+			_lock_mutex();
+			thread->processing = 0;
+			_unlock_mutex();
+		} else {
+			dm_task_destroy(task);
+			thread->current_task = NULL;
+		}
+	}
+
+	pthread_cleanup_pop(1);
+
+	return NULL;
+}
+
+/* Create a device monitoring thread. */
+static int _create_thread(struct thread_status *thread)
+{
+	return _pthread_create_smallstack(&thread->thread, _monitor_thread, thread);
+}
+
+static int _terminate_thread(struct thread_status *thread)
+{
+	return pthread_kill(thread->thread, SIGALRM);
+}
+
+/* DSO reference counting. Call with _global_mutex locked! */
+static void _lib_get(struct dso_data *data)
+{
+	data->ref_count++;
+}
+
+static void _lib_put(struct dso_data *data)
+{
+	if (!--data->ref_count) {
+		dlclose(data->dso_handle);
+		UNLINK_DSO(data);
+		_free_dso_data(data);
+	}
+}
+
+/* Find DSO data. */
+static struct dso_data *_lookup_dso(struct message_data *data)
+{
+	struct dso_data *dso_data, *ret = NULL;
+
+	dm_list_iterate_items(dso_data, &_dso_registry)
+	    if (!strcmp(data->dso_name, dso_data->dso_name)) {
+		_lib_get(dso_data);
+		ret = dso_data;
+		break;
+	}
+
+	return ret;
+}
+
+/* Lookup DSO symbols we need. */
+static int _lookup_symbol(void *dl, void **symbol, const char *name)
+{
+	if ((*symbol = dlsym(dl, name)))
+		return 1;
+
+	return 0;
+}
+
+static int lookup_symbols(void *dl, struct dso_data *data)
+{
+	return _lookup_symbol(dl, (void *) &data->process_event,
+			     "process_event") &&
+	    _lookup_symbol(dl, (void *) &data->register_device,
+			  "register_device") &&
+	    _lookup_symbol(dl, (void *) &data->unregister_device,
+			  "unregister_device");
+}
+
+/* Load an application specific DSO. */
+static struct dso_data *_load_dso(struct message_data *data)
+{
+	void *dl;
+	struct dso_data *ret = NULL;
+
+	if (!(dl = dlopen(data->dso_name, RTLD_NOW))) {
+		const char *dlerr = dlerror();
+		syslog(LOG_ERR, "dmeventd %s dlopen failed: %s", data->dso_name,
+		       dlerr);
+		data->msg->size =
+		    dm_asprintf(&(data->msg->data), "%s %s dlopen failed: %s",
+				data->id, data->dso_name, dlerr);
+		return NULL;
+	}
+
+	if (!(ret = _alloc_dso_data(data))) {
+		dlclose(dl);
+		return NULL;
+	}
+
+	if (!(lookup_symbols(dl, ret))) {
+		_free_dso_data(ret);
+		dlclose(dl);
+		return NULL;
+	}
+
+	/*
+	 * Keep handle to close the library once
+	 * we've got no references to it any more.
+	 */
+	ret->dso_handle = dl;
+	_lib_get(ret);
+
+	_lock_mutex();
+	LINK_DSO(ret);
+	_unlock_mutex();
+
+	return ret;
+}
+
+/* Return success on daemon active check. */
+static int _active(struct message_data *message_data)
+{
+	return 0;
+}
+
+/*
+ * Register for an event.
+ *
+ * Only one caller at a time here, because we use
+ * a FIFO and lock it against multiple accesses.
+ */
+static int _register_for_event(struct message_data *message_data)
+{
+	int ret = 0;
+	struct thread_status *thread, *thread_new = NULL;
+	struct dso_data *dso_data;
+
+	if (!(dso_data = _lookup_dso(message_data)) &&
+	    !(dso_data = _load_dso(message_data))) {
+		stack;
+#ifdef ELIBACC
+		ret = -ELIBACC;
+#else
+		ret = -ENODEV;
+#endif
+		goto out;
+	}
+
+	/* Preallocate thread status struct to avoid deadlock. */
+	if (!(thread_new = _alloc_thread_status(message_data, dso_data))) {
+		stack;
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	if (!_fill_device_data(thread_new)) {
+		stack;
+		ret = -ENODEV;
+		goto out;
+	}
+
+	_lock_mutex();
+
+	/* If creation of timeout thread fails (as it may), we fail
+	   here completely. The client is responsible for either
+	   retrying later or trying to register without timeout
+	   events. However, if timeout thread cannot be started, it
+	   usually means we are so starved on resources that we are
+	   almost as good as dead already... */
+	if (thread_new->events & DM_EVENT_TIMEOUT) {
+		ret = -_register_for_timeout(thread_new);
+		if (ret)
+			goto outth;
+	}
+
+	if (!(thread = _lookup_thread_status(message_data))) {
+		_unlock_mutex();
+
+		if (!(ret = _do_register_device(thread_new)))
+			goto out;
+
+		thread = thread_new;
+		thread_new = NULL;
+
+		/* Try to create the monitoring thread for this device. */
+		_lock_mutex();
+		if ((ret = -_create_thread(thread))) {
+			_unlock_mutex();
+			_do_unregister_device(thread);
+			_free_thread_status(thread);
+			goto out;
+		} else
+			LINK_THREAD(thread);
+	}
+
+	/* Or event # into events bitfield. */
+	thread->events |= message_data->events.field;
+
+    outth:
+	_unlock_mutex();
+
+      out:
+	/*
+	 * Deallocate thread status after releasing
+	 * the lock in case we haven't used it.
+	 */
+	if (thread_new)
+		_free_thread_status(thread_new);
+
+	return ret;
+}
+
+/*
+ * Unregister for an event.
+ *
+ * Only one caller at a time here as with register_for_event().
+ */
+static int _unregister_for_event(struct message_data *message_data)
+{
+	int ret = 0;
+	struct thread_status *thread;
+
+	/*
+	 * Clear event in bitfield and deactivate
+	 * monitoring thread in case bitfield is 0.
+	 */
+	_lock_mutex();
+
+	if (!(thread = _lookup_thread_status(message_data))) {
+		_unlock_mutex();
+		ret = -ENODEV;
+		goto out;
+	}
+
+	if (thread->status == DM_THREAD_DONE) {
+		/* the thread has terminated while we were not
+		   watching */
+		_unlock_mutex();
+		return 0;
+	}
+
+	thread->events &= ~message_data->events.field;
+
+	if (!(thread->events & DM_EVENT_TIMEOUT))
+		_unregister_for_timeout(thread);
+	/*
+	 * In case there's no events to monitor on this device ->
+	 * unlink and terminate its monitoring thread.
+	 */
+	if (!thread->events) {
+		pthread_mutex_lock(&_timeout_mutex);
+		UNLINK_THREAD(thread);
+		LINK(thread, &_thread_registry_unused);
+		pthread_mutex_unlock(&_timeout_mutex);
+	}
+	_unlock_mutex();
+
+      out:
+	return ret;
+}
+
+/*
+ * Get registered device.
+ *
+ * Only one caller at a time here as with register_for_event().
+ */
+static int _registered_device(struct message_data *message_data,
+			     struct thread_status *thread)
+{
+	struct dm_event_daemon_message *msg = message_data->msg;
+
+	const char *fmt = "%s %s %s %u";
+	const char *id = message_data->id;
+	const char *dso = thread->dso_data->dso_name;
+	const char *dev = thread->device.uuid;
+	int r;
+	unsigned events = ((thread->status == DM_THREAD_RUNNING)
+			   && (thread->events)) ? thread->events : thread->
+	    events | DM_EVENT_REGISTRATION_PENDING;
+
+	dm_free(msg->data);
+
+	if ((r = dm_asprintf(&(msg->data), fmt, id, dso, dev, events)) < 0) {
+		msg->size = 0;
+		return -ENOMEM;
+	}
+
+	msg->size = (uint32_t) r;
+
+	return 0;
+}
+
+static int _want_registered_device(char *dso_name, char *device_uuid,
+				  struct thread_status *thread)
+{
+	/* If DSO names and device paths are equal. */
+	if (dso_name && device_uuid)
+		return !strcmp(dso_name, thread->dso_data->dso_name) &&
+		    !strcmp(device_uuid, thread->device.uuid) &&
+			(thread->status == DM_THREAD_RUNNING ||
+			 (thread->events & DM_EVENT_REGISTRATION_PENDING));
+
+	/* If DSO names are equal. */
+	if (dso_name)
+		return !strcmp(dso_name, thread->dso_data->dso_name) &&
+			(thread->status == DM_THREAD_RUNNING ||
+			 (thread->events & DM_EVENT_REGISTRATION_PENDING));
+
+	/* If device paths are equal. */
+	if (device_uuid)
+		return !strcmp(device_uuid, thread->device.uuid) &&
+			(thread->status == DM_THREAD_RUNNING ||
+			 (thread->events & DM_EVENT_REGISTRATION_PENDING));
+
+	return 1;
+}
+
+static int _get_registered_dev(struct message_data *message_data, int next)
+{
+	struct thread_status *thread, *hit = NULL;
+	int ret = -ENOENT;
+
+	_lock_mutex();
+
+	/* Iterate list of threads checking if we want a particular one. */
+	dm_list_iterate_items(thread, &_thread_registry)
+		if (_want_registered_device(message_data->dso_name,
+					    message_data->device_uuid,
+					    thread)) {
+			hit = thread;
+			break;
+		}
+
+	/*
+	 * If we got a registered device and want the next one ->
+	 * fetch next conforming element off the list.
+	 */
+	if (hit && !next)
+		goto reg;
+
+	if (!hit)
+		goto out;
+
+	while (1) {
+		if (dm_list_end(&_thread_registry, &thread->list))
+			goto out;
+
+		thread = dm_list_item(thread->list.n, struct thread_status);
+		if (_want_registered_device(message_data->dso_name, NULL, thread)) {
+			hit = thread;
+			break;
+		}
+	}
+
+      reg:
+	ret = _registered_device(message_data, hit);
+
+      out:
+	_unlock_mutex();
+
+	return ret;
+}
+
+static int _get_registered_device(struct message_data *message_data)
+{
+	return _get_registered_dev(message_data, 0);
+}
+
+static int _get_next_registered_device(struct message_data *message_data)
+{
+	return _get_registered_dev(message_data, 1);
+}
+
+static int _set_timeout(struct message_data *message_data)
+{
+	struct thread_status *thread;
+
+	_lock_mutex();
+	if ((thread = _lookup_thread_status(message_data)))
+		thread->timeout = message_data->timeout.secs;
+	_unlock_mutex();
+
+	return thread ? 0 : -ENODEV;
+}
+
+static int _get_timeout(struct message_data *message_data)
+{
+	struct thread_status *thread;
+	struct dm_event_daemon_message *msg = message_data->msg;
+
+	dm_free(msg->data);
+
+	_lock_mutex();
+	if ((thread = _lookup_thread_status(message_data))) {
+		msg->size =
+		    dm_asprintf(&(msg->data), "%s %" PRIu32, message_data->id,
+				thread->timeout);
+	} else {
+		msg->data = NULL;
+		msg->size = 0;
+	}
+	_unlock_mutex();
+
+	return thread ? 0 : -ENODEV;
+}
+
+/* Initialize a fifos structure with path names. */
+static void _init_fifos(struct dm_event_fifos *fifos)
+{
+	memset(fifos, 0, sizeof(*fifos));
+
+	fifos->client_path = DM_EVENT_FIFO_CLIENT;
+	fifos->server_path = DM_EVENT_FIFO_SERVER;
+}
+
+/* Open fifos used for client communication. */
+static int _open_fifos(struct dm_event_fifos *fifos)
+{
+	struct stat st;
+
+	/* Create client fifo. */
+	(void) dm_prepare_selinux_context(fifos->client_path, S_IFIFO);
+	if ((mkfifo(fifos->client_path, 0600) == -1) && errno != EEXIST) {
+		syslog(LOG_ERR, "%s: Failed to create client fifo %s: %m.\n",
+		       __func__, fifos->client_path);
+		(void) dm_prepare_selinux_context(NULL, 0);
+		return 0;
+	}
+
+	/* Create server fifo. */
+	(void) dm_prepare_selinux_context(fifos->server_path, S_IFIFO);
+	if ((mkfifo(fifos->server_path, 0600) == -1) && errno != EEXIST) {
+		syslog(LOG_ERR, "%s: Failed to create server fifo %s: %m.\n",
+		       __func__, fifos->server_path);
+		(void) dm_prepare_selinux_context(NULL, 0);
+		return 0;
+	}
+
+	(void) dm_prepare_selinux_context(NULL, 0);
+
+	/* Warn about wrong permissions if applicable */
+	if ((!stat(fifos->client_path, &st)) && (st.st_mode & 0777) != 0600)
+		syslog(LOG_WARNING, "Fixing wrong permissions on %s: %m.\n",
+		       fifos->client_path);
+
+	if ((!stat(fifos->server_path, &st)) && (st.st_mode & 0777) != 0600)
+		syslog(LOG_WARNING, "Fixing wrong permissions on %s: %m.\n",
+		       fifos->server_path);
+
+	/* If they were already there, make sure permissions are ok. */
+	if (chmod(fifos->client_path, 0600)) {
+		syslog(LOG_ERR, "Unable to set correct file permissions on %s: %m.\n",
+		       fifos->client_path);
+		return 0;
+	}
+
+	if (chmod(fifos->server_path, 0600)) {
+		syslog(LOG_ERR, "Unable to set correct file permissions on %s: %m.\n",
+		       fifos->server_path);
+		return 0;
+	}
+
+	/* Need to open read+write or we will block or fail */
+	if ((fifos->server = open(fifos->server_path, O_RDWR)) < 0) {
+		syslog(LOG_ERR, "Failed to open fifo server %s: %m.\n",
+		       fifos->server_path);
+		return 0;
+	}
+
+	/* Need to open read+write for select() to work. */
+	if ((fifos->client = open(fifos->client_path, O_RDWR)) < 0) {
+		syslog(LOG_ERR, "Failed to open fifo client %s: %m", fifos->client_path);
+		if (close(fifos->server))
+			syslog(LOG_ERR, "Failed to close fifo server %s: %m", fifos->server_path);
+		return 0;
+	}
+
+	return 1;
+}
+
+/*
+ * Read message from client making sure that data is available
+ * and a complete message is read.  Must not block indefinitely.
+ */
+static int _client_read(struct dm_event_fifos *fifos,
+		       struct dm_event_daemon_message *msg)
+{
+	struct timeval t;
+	unsigned bytes = 0;
+	int ret = 0;
+	fd_set fds;
+	size_t size = 2 * sizeof(uint32_t);	/* status + size */
+	uint32_t *header = alloca(size);
+	char *buf = (char *)header;
+
+	msg->data = NULL;
+
+	errno = 0;
+	while (bytes < size && errno != EOF) {
+		/* Watch client read FIFO for input. */
+		FD_ZERO(&fds);
+		FD_SET(fifos->client, &fds);
+		t.tv_sec = 1;
+		t.tv_usec = 0;
+		ret = select(fifos->client + 1, &fds, NULL, NULL, &t);
+
+		if (!ret && !bytes)	/* nothing to read */
+			return 0;
+
+		if (!ret)	/* trying to finish read */
+			continue;
+
+		if (ret < 0)	/* error */
+			return 0;
+
+		ret = read(fifos->client, buf + bytes, size - bytes);
+		bytes += ret > 0 ? ret : 0;
+		if (header && (bytes == 2 * sizeof(uint32_t))) {
+			msg->cmd = ntohl(header[0]);
+			msg->size = ntohl(header[1]);
+			buf = msg->data = dm_malloc(msg->size);
+			size = msg->size;
+			bytes = 0;
+			header = 0;
+		}
+	}
+
+	if (bytes != size) {
+		dm_free(msg->data);
+		msg->data = NULL;
+		msg->size = 0;
+	}
+
+	return bytes == size;
+}
+
+/*
+ * Write a message to the client making sure that it is ready to write.
+ */
+static int _client_write(struct dm_event_fifos *fifos,
+			struct dm_event_daemon_message *msg)
+{
+	unsigned bytes = 0;
+	int ret = 0;
+	fd_set fds;
+
+	size_t size = 2 * sizeof(uint32_t) + msg->size;
+	uint32_t *header = alloca(size);
+	char *buf = (char *)header;
+
+	header[0] = htonl(msg->cmd);
+	header[1] = htonl(msg->size);
+	if (msg->data)
+		memcpy(buf + 2 * sizeof(uint32_t), msg->data, msg->size);
+
+	errno = 0;
+	while (bytes < size && errno != EIO) {
+		do {
+			/* Watch client write FIFO to be ready for output. */
+			FD_ZERO(&fds);
+			FD_SET(fifos->server, &fds);
+		} while (select(fifos->server + 1, NULL, &fds, NULL, NULL) !=
+			 1);
+
+		ret = write(fifos->server, buf + bytes, size - bytes);
+		bytes += ret > 0 ? ret : 0;
+	}
+
+	return bytes == size;
+}
+
+/*
+ * Handle a client request.
+ *
+ * We put the request handling functions into
+ * a list because of the growing number.
+ */
+static int _handle_request(struct dm_event_daemon_message *msg,
+			  struct message_data *message_data)
+{
+	static struct request {
+		unsigned int cmd;
+		int (*f)(struct message_data *);
+	} requests[] = {
+		{ DM_EVENT_CMD_REGISTER_FOR_EVENT, _register_for_event},
+		{ DM_EVENT_CMD_UNREGISTER_FOR_EVENT, _unregister_for_event},
+		{ DM_EVENT_CMD_GET_REGISTERED_DEVICE, _get_registered_device},
+		{ DM_EVENT_CMD_GET_NEXT_REGISTERED_DEVICE,
+			_get_next_registered_device},
+		{ DM_EVENT_CMD_SET_TIMEOUT, _set_timeout},
+		{ DM_EVENT_CMD_GET_TIMEOUT, _get_timeout},
+		{ DM_EVENT_CMD_ACTIVE, _active},
+		{ DM_EVENT_CMD_GET_STATUS, _get_status},
+	}, *req;
+
+	for (req = requests; req < requests + sizeof(requests) / sizeof(struct request); req++)
+		if (req->cmd == msg->cmd)
+			return req->f(message_data);
+
+	return -EINVAL;
+}
+
+/* Process a request passed from the communication thread. */
+static int _do_process_request(struct dm_event_daemon_message *msg)
+{
+	int ret;
+	char *answer;
+	static struct message_data message_data;
+
+	/* Parse the message. */
+	memset(&message_data, 0, sizeof(message_data));
+	message_data.msg = msg;
+	if (msg->cmd == DM_EVENT_CMD_HELLO || msg->cmd == DM_EVENT_CMD_DIE)  {
+		ret = 0;
+		answer = msg->data;
+		if (answer) {
+			msg->size = dm_asprintf(&(msg->data), "%s %s %d", answer,
+						msg->cmd == DM_EVENT_CMD_DIE ? "DYING" : "HELLO",
+                                                DM_EVENT_PROTOCOL_VERSION);
+			dm_free(answer);
+		} else {
+			msg->size = 0;
+			msg->data = NULL;
+		}
+	} else if (msg->cmd != DM_EVENT_CMD_ACTIVE && !_parse_message(&message_data)) {
+		stack;
+		ret = -EINVAL;
+	} else
+		ret = _handle_request(msg, &message_data);
+
+	msg->cmd = ret;
+	if (!msg->data)
+		msg->size = dm_asprintf(&(msg->data), "%s %s", message_data.id, strerror(-ret));
+
+	_free_message(&message_data);
+
+	return ret;
+}
+
+/* Only one caller at a time. */
+static void _process_request(struct dm_event_fifos *fifos)
+{
+	int die = 0;
+	struct dm_event_daemon_message msg;
+
+	memset(&msg, 0, sizeof(msg));
+
+	/*
+	 * Read the request from the client (client_read, client_write
+	 * give true on success and false on failure).
+	 */
+	if (!_client_read(fifos, &msg))
+		return;
+
+	if (msg.cmd == DM_EVENT_CMD_DIE)
+		die = 1;
+
+	/* _do_process_request fills in msg (if memory allows for
+	   data, otherwise just cmd and size = 0) */
+	_do_process_request(&msg);
+
+	if (!_client_write(fifos, &msg))
+		stack;
+
+	dm_free(msg.data);
+
+	if (die) raise(9);
+}
+
+static void _process_initial_registrations(void)
+{
+	int i = 0;
+	char *reg;
+	struct dm_event_daemon_message msg = { 0, 0, NULL };
+
+	while ((reg = _initial_registrations[i])) {
+		msg.cmd = DM_EVENT_CMD_REGISTER_FOR_EVENT;
+		if ((msg.size = strlen(reg))) {
+			msg.data = reg;
+			_do_process_request(&msg);
+		}
+		++ i;
+	}
+}
+
+static void _cleanup_unused_threads(void)
+{
+	int ret;
+	struct dm_list *l;
+	struct thread_status *thread;
+	int join_ret = 0;
+
+	_lock_mutex();
+	while ((l = dm_list_first(&_thread_registry_unused))) {
+		thread = dm_list_item(l, struct thread_status);
+		if (thread->processing)
+			break;	/* cleanup on the next round */
+
+		if (thread->status == DM_THREAD_RUNNING) {
+			thread->status = DM_THREAD_SHUTDOWN;
+			break;
+		}
+
+		if (thread->status == DM_THREAD_SHUTDOWN) {
+			if (!thread->events) {
+				/* turn codes negative -- should we be returning this? */
+				ret = _terminate_thread(thread);
+
+				if (ret == ESRCH) {
+					thread->status = DM_THREAD_DONE;
+				} else if (ret) {
+					syslog(LOG_ERR,
+					       "Unable to terminate thread: %s\n",
+					       strerror(-ret));
+					stack;
+				}
+				break;
+			}
+
+			dm_list_del(l);
+			syslog(LOG_ERR,
+			       "thread can't be on unused list unless !thread->events");
+			thread->status = DM_THREAD_RUNNING;
+			LINK_THREAD(thread);
+
+			continue;
+		}
+
+		if (thread->status == DM_THREAD_DONE) {
+			dm_list_del(l);
+			join_ret = pthread_join(thread->thread, NULL);
+			_free_thread_status(thread);
+		}
+	}
+
+	_unlock_mutex();
+
+	if (join_ret)
+		syslog(LOG_ERR, "Failed pthread_join: %s\n", strerror(join_ret));
+}
+
+static void _sig_alarm(int signum __attribute__((unused)))
+{
+	pthread_testcancel();
+}
+
+/* Init thread signal handling. */
+static void _init_thread_signals(void)
+{
+	sigset_t my_sigset;
+	struct sigaction act;
+
+	memset(&act, 0, sizeof(act));
+	act.sa_handler = _sig_alarm;
+	sigaction(SIGALRM, &act, NULL);
+	sigfillset(&my_sigset);
+
+	/* These are used for exiting */
+	sigdelset(&my_sigset, SIGTERM);
+	sigdelset(&my_sigset, SIGINT);
+	sigdelset(&my_sigset, SIGHUP);
+	sigdelset(&my_sigset, SIGQUIT);
+
+	pthread_sigmask(SIG_BLOCK, &my_sigset, NULL);
+}
+
+/*
+ * exit_handler
+ * @sig
+ *
+ * Set the global variable which the process should
+ * be watching to determine when to exit.
+ */
+static void _exit_handler(int sig __attribute__((unused)))
+{
+	/*
+	 * We exit when '_exit_now' is set.
+	 * That is, when a signal has been received.
+	 *
+	 * We can not simply set '_exit_now' unless all
+	 * threads are done processing.
+	 */
+	if (!_thread_registries_empty) {
+		syslog(LOG_ERR, "There are still devices being monitored.");
+		syslog(LOG_ERR, "Refusing to exit.");
+	} else
+		_exit_now = 1;
+
+}
+
+#ifdef linux
+static int _set_oom_adj(const char *oom_adj_path, int val)
+{
+	FILE *fp;
+
+	if (!(fp = fopen(oom_adj_path, "w"))) {
+		perror("oom_adj: fopen failed");
+		return 0;
+	}
+
+	fprintf(fp, "%i", val);
+
+	if (dm_fclose(fp))
+		perror("oom_adj: fclose failed");
+
+	return 1;
+}
+
+/*
+ * Protection against OOM killer if kernel supports it
+ */
+static int _protect_against_oom_killer(void)
+{
+	struct stat st;
+
+	if (stat(OOM_ADJ_FILE, &st) == -1) {
+		if (errno != ENOENT)
+			perror(OOM_ADJ_FILE ": stat failed");
+
+		/* Try old oom_adj interface as a fallback */
+		if (stat(OOM_ADJ_FILE_OLD, &st) == -1) {
+			if (errno == ENOENT)
+				perror(OOM_ADJ_FILE_OLD " not found");
+			else
+				perror(OOM_ADJ_FILE_OLD ": stat failed");
+			return 1;
+		}
+
+		return _set_oom_adj(OOM_ADJ_FILE_OLD, OOM_DISABLE) ||
+		       _set_oom_adj(OOM_ADJ_FILE_OLD, OOM_ADJUST_MIN);
+	}
+
+	return _set_oom_adj(OOM_ADJ_FILE, OOM_SCORE_ADJ_MIN);
+}
+
+static int _handle_preloaded_fifo(int fd, const char *path)
+{
+	struct stat st_fd, st_path;
+	int flags;
+
+	if ((flags = fcntl(fd, F_GETFD)) < 0)
+		return 0;
+
+	if (flags & FD_CLOEXEC)
+		return 0;
+
+	if (fstat(fd, &st_fd) < 0 || !S_ISFIFO(st_fd.st_mode))
+		return 0;
+
+	if (stat(path, &st_path) < 0 ||
+	    st_path.st_dev != st_fd.st_dev ||
+	    st_path.st_ino != st_fd.st_ino)
+		return 0;
+
+	if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0)
+		return 0;
+
+	return 1;
+}
+
+static int _systemd_handover(struct dm_event_fifos *fifos)
+{
+	const char *e;
+	char *p;
+	unsigned long env_pid, env_listen_fds;
+	int r = 0;
+
+	memset(fifos, 0, sizeof(*fifos));
+
+	/* LISTEN_PID must be equal to our PID! */
+	if (!(e = getenv(SD_LISTEN_PID_ENV_VAR_NAME)))
+		goto out;
+
+	errno = 0;
+	env_pid = strtoul(e, &p, 10);
+	if (errno || !p || *p || env_pid <= 0 ||
+	    getpid() != (pid_t) env_pid)
+		goto out;
+
+	/* LISTEN_FDS must be 2 and the fds must be FIFOSs! */
+	if (!(e = getenv(SD_LISTEN_FDS_ENV_VAR_NAME)))
+		goto out;
+
+	errno = 0;
+	env_listen_fds = strtoul(e, &p, 10);
+	if (errno || !p || *p || env_listen_fds != 2)
+		goto out;
+
+	/* Check and handle the FIFOs passed in */
+	r = (_handle_preloaded_fifo(SD_FD_FIFO_SERVER, DM_EVENT_FIFO_SERVER) &&
+	     _handle_preloaded_fifo(SD_FD_FIFO_CLIENT, DM_EVENT_FIFO_CLIENT));
+
+	if (r) {
+		fifos->server = SD_FD_FIFO_SERVER;
+		fifos->server_path = DM_EVENT_FIFO_SERVER;
+		fifos->client = SD_FD_FIFO_CLIENT;
+		fifos->client_path = DM_EVENT_FIFO_CLIENT;
+	}
+
+out:
+	unsetenv(SD_LISTEN_PID_ENV_VAR_NAME);
+	unsetenv(SD_LISTEN_FDS_ENV_VAR_NAME);
+	return r;
+}
+#endif
+
+static void remove_lockfile(void)
+{
+	if (unlink(DMEVENTD_PIDFILE))
+		perror(DMEVENTD_PIDFILE ": unlink failed");
+}
+
+static void _daemonize(void)
+{
+	int child_status;
+	int fd;
+	pid_t pid;
+	struct rlimit rlim;
+	struct timeval tval;
+	sigset_t my_sigset;
+
+	sigemptyset(&my_sigset);
+	if (sigprocmask(SIG_SETMASK, &my_sigset, NULL) < 0) {
+		fprintf(stderr, "Unable to restore signals.\n");
+		exit(EXIT_FAILURE);
+	}
+	signal(SIGTERM, &_exit_handler);
+
+	switch (pid = fork()) {
+	case -1:
+		perror("fork failed:");
+		exit(EXIT_FAILURE);
+
+	case 0:		/* Child */
+		break;
+
+	default:
+		/* Wait for response from child */
+		while (!waitpid(pid, &child_status, WNOHANG) && !_exit_now) {
+			tval.tv_sec = 0;
+			tval.tv_usec = 250000;	/* .25 sec */
+			select(0, NULL, NULL, NULL, &tval);
+		}
+
+		if (_exit_now)	/* Child has signaled it is ok - we can exit now */
+			exit(EXIT_SUCCESS);
+
+		/* Problem with child.  Determine what it is by exit code */
+		switch (WEXITSTATUS(child_status)) {
+		case EXIT_DESC_CLOSE_FAILURE:
+		case EXIT_DESC_OPEN_FAILURE:
+		case EXIT_FIFO_FAILURE:
+		case EXIT_CHDIR_FAILURE:
+		default:
+			fprintf(stderr, "Child exited with code %d\n", WEXITSTATUS(child_status));
+			break;
+		}
+
+		exit(WEXITSTATUS(child_status));
+	}
+
+	if (chdir("/"))
+		exit(EXIT_CHDIR_FAILURE);
+
+	if (getrlimit(RLIMIT_NOFILE, &rlim) < 0)
+		fd = 256;	/* just have to guess */
+	else
+		fd = rlim.rlim_cur;
+
+	for (--fd; fd >= 0; fd--) {
+#ifdef linux
+		/* Do not close fds preloaded by systemd! */
+		if (_systemd_activation &&
+		    (fd == SD_FD_FIFO_SERVER || fd == SD_FD_FIFO_CLIENT))
+			continue;
+#endif
+		(void) close(fd);
+	}
+
+	if ((open("/dev/null", O_RDONLY) < 0) ||
+	    (open("/dev/null", O_WRONLY) < 0) ||
+	    (open("/dev/null", O_WRONLY) < 0))
+		exit(EXIT_DESC_OPEN_FAILURE);
+
+	setsid();
+}
+
+static void restart(void)
+{
+	struct dm_event_fifos fifos;
+	struct dm_event_daemon_message msg = { 0, 0, NULL };
+	int i, count = 0;
+	char *message;
+	int length;
+	int version;
+
+	/* Get the list of registrations from the running daemon. */
+
+	if (!init_fifos(&fifos)) {
+		fprintf(stderr, "WARNING: Could not initiate communication with existing dmeventd.\n");
+		return;
+	}
+
+	if (!dm_event_get_version(&fifos, &version)) {
+		fprintf(stderr, "WARNING: Could not communicate with existing dmeventd.\n");
+		fini_fifos(&fifos);
+		return;
+	}
+
+	if (version < 1) {
+		fprintf(stderr, "WARNING: The running dmeventd instance is too old.\n"
+			        "Protocol version %d (required: 1). Action cancelled.\n",
+			        version);
+		exit(EXIT_FAILURE);
+	}
+
+	if (daemon_talk(&fifos, &msg, DM_EVENT_CMD_GET_STATUS, "-", "-", 0, 0)) {
+		exit(EXIT_FAILURE);
+	}
+
+	message = msg.data;
+	message = strchr(message, ' ');
+	++ message;
+	length = strlen(msg.data);
+	for (i = 0; i < length; ++i) {
+		if (msg.data[i] == ';') {
+			msg.data[i] = 0;
+			++count;
+		}
+	}
+
+	if (!(_initial_registrations = dm_malloc(sizeof(char*) * (count + 1)))) {
+		fprintf(stderr, "Memory allocation registration failed.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	for (i = 0; i < count; ++i) {
+		if (!(_initial_registrations[i] = dm_strdup(message))) {
+			fprintf(stderr, "Memory allocation for message failed.\n");
+			exit(EXIT_FAILURE);
+		}
+		message += strlen(message) + 1;
+	}
+	_initial_registrations[count] = 0;
+
+	if (daemon_talk(&fifos, &msg, DM_EVENT_CMD_DIE, "-", "-", 0, 0)) {
+		fprintf(stderr, "Old dmeventd refused to die.\n");
+		exit(EXIT_FAILURE);
+	}
+
+	fini_fifos(&fifos);
+}
+
+static void usage(char *prog, FILE *file)
+{
+	fprintf(file, "Usage:\n"
+		"%s [-d [-d [-d]]] [-f] [-h] [-R] [-V] [-?]\n\n"
+		"   -d       Log debug messages to syslog (-d, -dd, -ddd)\n"
+		"   -f       Don't fork, run in the foreground\n"
+		"   -h -?    Show this help information\n"
+		"   -R       Restart dmeventd\n"
+		"   -V       Show version of dmeventd\n\n", prog);
+}
+
+int main(int argc, char *argv[])
+{
+	signed char opt;
+	struct dm_event_fifos fifos;
+	//struct sys_log logdata = {DAEMON_NAME, LOG_DAEMON};
+
+	opterr = 0;
+	optind = 0;
+
+	while ((opt = getopt(argc, argv, "?fhVdR")) != EOF) {
+		switch (opt) {
+		case 'h':
+			usage(argv[0], stdout);
+			exit(0);
+		case '?':
+			usage(argv[0], stderr);
+			exit(0);
+		case 'R':
+			_restart++;
+			break;
+		case 'f':
+			_foreground++;
+			break;
+		case 'd':
+			dmeventd_debug++;
+			break;
+		case 'V':
+			printf("dmeventd version: %s\n", DM_LIB_VERSION);
+			exit(1);
+		}
+	}
+
+	/*
+	 * Switch to C locale to avoid reading large locale-archive file
+	 * used by some glibc (on some distributions it takes over 100MB).
+	 * Daemon currently needs to use mlockall().
+	 */
+	if (setenv("LANG", "C", 1))
+		perror("Cannot set LANG to C");
+
+	if (_restart)
+		restart();
+
+#ifdef linux
+	_systemd_activation = _systemd_handover(&fifos);
+#endif
+
+	if (!_foreground)
+		_daemonize();
+
+	openlog("dmeventd", LOG_PID, LOG_DAEMON);
+
+	(void) dm_prepare_selinux_context(DMEVENTD_PIDFILE, S_IFREG);
+	if (dm_create_lockfile(DMEVENTD_PIDFILE) == 0)
+		exit(EXIT_FAILURE);
+
+	atexit(remove_lockfile);
+	(void) dm_prepare_selinux_context(NULL, 0);
+
+	/* Set the rest of the signals to cause '_exit_now' to be set */
+	signal(SIGINT, &_exit_handler);
+	signal(SIGHUP, &_exit_handler);
+	signal(SIGQUIT, &_exit_handler);
+
+#ifdef linux
+	/* Systemd has adjusted oom killer for us already */
+	if (!_systemd_activation && !_protect_against_oom_killer())
+		syslog(LOG_ERR, "Failed to protect against OOM killer");
+#endif
+
+	_init_thread_signals();
+
+	//multilog_clear_logging();
+	//multilog_add_type(std_syslog, &logdata);
+	//multilog_init_verbose(std_syslog, _LOG_DEBUG);
+	//multilog_async(1);
+
+	if (!_systemd_activation)
+		_init_fifos(&fifos);
+
+	pthread_mutex_init(&_global_mutex, NULL);
+
+	if (!_systemd_activation && !_open_fifos(&fifos))
+		exit(EXIT_FIFO_FAILURE);
+
+	/* Signal parent, letting them know we are ready to go. */
+	if (!_foreground)
+		kill(getppid(), SIGTERM);
+	syslog(LOG_NOTICE, "dmeventd ready for processing.");
+
+	if (_initial_registrations)
+		_process_initial_registrations();
+
+	while (!_exit_now) {
+		_process_request(&fifos);
+		_cleanup_unused_threads();
+		_lock_mutex();
+		if (!dm_list_empty(&_thread_registry)
+		    || !dm_list_empty(&_thread_registry_unused))
+			_thread_registries_empty = 0;
+		else
+			_thread_registries_empty = 1;
+		_unlock_mutex();
+	}
+
+	_exit_dm_lib();
+
+	pthread_mutex_destroy(&_global_mutex);
+
+	syslog(LOG_NOTICE, "dmeventd shutting down.");
+	closelog();
+
+	exit(EXIT_SUCCESS);
+}

=== added directory '.pc/dirs.patch/doc'
=== removed directory '.pc/dirs.patch/doc'
=== added file '.pc/dirs.patch/doc/example.conf.in'
--- .pc/dirs.patch/doc/example.conf.in	1970-01-01 00:00:00 +0000
+++ .pc/dirs.patch/doc/example.conf.in	2012-08-21 10:18:22 +0000
@@ -0,0 +1,773 @@
+# This is an example configuration file for the LVM2 system.
+# It contains the default settings that would be used if there was no
+# @DEFAULT_SYS_DIR@/lvm.conf file.
+#
+# Refer to 'man lvm.conf' for further information including the file layout.
+#
+# To put this file in a different directory and override @DEFAULT_SYS_DIR@ set
+# the environment variable LVM_SYSTEM_DIR before running the tools.
+#
+# N.B. Take care that each setting only appears once if uncommenting
+# example settings in this file.
+
+
+# This section allows you to configure which block devices should
+# be used by the LVM system.
+devices {
+
+    # Where do you want your volume groups to appear ?
+    dir = "/dev"
+
+    # An array of directories that contain the device nodes you wish
+    # to use with LVM2.
+    scan = [ "/dev" ]
+
+    # If set, the cache of block device nodes with all associated symlinks
+    # will be constructed out of the existing udev database content.
+    # This avoids using and opening any inapplicable non-block devices or
+    # subdirectories found in the device directory. This setting is applied
+    # to udev-managed device directory only, other directories will be scanned
+    # fully. LVM2 needs to be compiled with udev support for this setting to
+    # take effect. N.B. Any device node or symlink not managed by udev in
+    # udev directory will be ignored with this setting on.
+    obtain_device_list_from_udev = 1
+
+    # If several entries in the scanned directories correspond to the
+    # same block device and the tools need to display a name for device,
+    # all the pathnames are matched against each item in the following
+    # list of regular expressions in turn and the first match is used.
+    preferred_names = [ ]
+
+    # Try to avoid using undescriptive /dev/dm-N names, if present.
+    # preferred_names = [ "^/dev/mpath/", "^/dev/mapper/mpath", "^/dev/[hs]d" ]
+
+    # A filter that tells LVM2 to only use a restricted set of devices.
+    # The filter consists of an array of regular expressions.  These
+    # expressions can be delimited by a character of your choice, and
+    # prefixed with either an 'a' (for accept) or 'r' (for reject).
+    # The first expression found to match a device name determines if
+    # the device will be accepted or rejected (ignored).  Devices that
+    # don't match any patterns are accepted.
+
+    # Be careful if there there are symbolic links or multiple filesystem 
+    # entries for the same device as each name is checked separately against
+    # the list of patterns.  The effect is that if the first pattern in the 
+    # list to match a name is an 'a' pattern for any of the names, the device
+    # is accepted; otherwise if the first pattern in the list to match a name
+    # is an 'r' pattern for any of the names it is rejected; otherwise it is
+    # accepted.
+
+    # Don't have more than one filter line active at once: only one gets used.
+
+    # Run vgscan after you change this parameter to ensure that
+    # the cache file gets regenerated (see below).
+    # If it doesn't do what you expect, check the output of 'vgscan -vvvv'.
+
+
+    # By default we accept every block device:
+    filter = [ "a/.*/" ]
+
+    # Exclude the cdrom drive
+    # filter = [ "r|/dev/cdrom|" ]
+
+    # When testing I like to work with just loopback devices:
+    # filter = [ "a/loop/", "r/.*/" ]
+
+    # Or maybe all loops and ide drives except hdc:
+    # filter =[ "a|loop|", "r|/dev/hdc|", "a|/dev/ide|", "r|.*|" ]
+
+    # Use anchors if you want to be really specific
+    # filter = [ "a|^/dev/hda8$|", "r/.*/" ]
+
+    # The results of the filtering are cached on disk to avoid
+    # rescanning dud devices (which can take a very long time).
+    # By default this cache is stored in the @DEFAULT_SYS_DIR@/@DEFAULT_CACHE_SUBDIR@ directory
+    # in a file called '.cache'.
+    # It is safe to delete the contents: the tools regenerate it.
+    # (The old setting 'cache' is still respected if neither of
+    # these new ones is present.)
+    cache_dir = "@DEFAULT_SYS_DIR@/@DEFAULT_CACHE_SUBDIR@"
+    cache_file_prefix = ""
+
+    # You can turn off writing this cache file by setting this to 0.
+    write_cache_state = 1
+
+    # Advanced settings.
+
+    # List of pairs of additional acceptable block device types found 
+    # in /proc/devices with maximum (non-zero) number of partitions.
+    # types = [ "fd", 16 ]
+
+    # If sysfs is mounted (2.6 kernels) restrict device scanning to 
+    # the block devices it believes are valid.
+    # 1 enables; 0 disables.
+    sysfs_scan = 1
+
+    # By default, LVM2 will ignore devices used as component paths
+    # of device-mapper multipath devices.
+    # 1 enables; 0 disables.
+    multipath_component_detection = 1
+
+    # By default, LVM2 will ignore devices used as components of
+    # software RAID (md) devices by looking for md superblocks.
+    # 1 enables; 0 disables.
+    md_component_detection = 1
+
+    # By default, if a PV is placed directly upon an md device, LVM2
+    # will align its data blocks with the md device's stripe-width.
+    # 1 enables; 0 disables.
+    md_chunk_alignment = 1
+
+    # Default alignment of the start of a data area in MB.  If set to 0,
+    # a value of 64KB will be used.  Set to 1 for 1MiB, 2 for 2MiB, etc.
+    # default_data_alignment = @DEFAULT_DATA_ALIGNMENT@
+
+    # By default, the start of a PV's data area will be a multiple of
+    # the 'minimum_io_size' or 'optimal_io_size' exposed in sysfs.
+    # - minimum_io_size - the smallest request the device can perform
+    #   w/o incurring a read-modify-write penalty (e.g. MD's chunk size)
+    # - optimal_io_size - the device's preferred unit of receiving I/O
+    #   (e.g. MD's stripe width)
+    # minimum_io_size is used if optimal_io_size is undefined (0).
+    # If md_chunk_alignment is enabled, that detects the optimal_io_size.
+    # This setting takes precedence over md_chunk_alignment.
+    # 1 enables; 0 disables.
+    data_alignment_detection = 1
+
+    # Alignment (in KB) of start of data area when creating a new PV.
+    # md_chunk_alignment and data_alignment_detection are disabled if set.
+    # Set to 0 for the default alignment (see: data_alignment_default)
+    # or page size, if larger.
+    data_alignment = 0
+
+    # By default, the start of the PV's aligned data area will be shifted by
+    # the 'alignment_offset' exposed in sysfs.  This offset is often 0 but
+    # may be non-zero; e.g.: certain 4KB sector drives that compensate for
+    # windows partitioning will have an alignment_offset of 3584 bytes
+    # (sector 7 is the lowest aligned logical block, the 4KB sectors start
+    # at LBA -1, and consequently sector 63 is aligned on a 4KB boundary).
+    # But note that pvcreate --dataalignmentoffset will skip this detection.
+    # 1 enables; 0 disables.
+    data_alignment_offset_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
+
+    # During each LVM operation errors received from each device are counted.
+    # If the counter of a particular device exceeds the limit set here, no
+    # further I/O is sent to that device for the remainder of the respective
+    # operation. Setting the parameter to 0 disables the counters altogether.
+    disable_after_error_count = 0
+
+    # Allow use of pvcreate --uuid without requiring --restorefile.
+    require_restorefile_with_uuid = 1
+
+    # Minimum size (in KB) of block devices which can be used as PVs.
+    # In a clustered environment all nodes must use the same value.
+    # Any value smaller than 512KB is ignored.
+
+    # Ignore devices smaller than 2MB such as floppy drives.
+    pv_min_size = 2048
+
+    # The original built-in setting was 512 up to and including version 2.02.84.
+    # pv_min_size = 512
+
+    # Issue discards to a logical volumes's underlying physical volume(s) when
+    # the logical volume is no longer using the physical volumes' space (e.g.
+    # lvremove, lvreduce, etc).  Discards inform the storage that a region is
+    # no longer in use.  Storage that supports discards advertise the protocol
+    # specific way discards should be issued by the kernel (TRIM, UNMAP, or
+    # WRITE SAME with UNMAP bit set).  Not all storage will support or benefit
+    # from discards but SSDs and thinly provisioned LUNs generally do.  If set
+    # to 1, discards will only be issued if both the storage and kernel provide
+    # support.
+    # 1 enables; 0 disables.
+    issue_discards = 0
+}
+
+# This section allows you to configure the way in which LVM selects
+# free space for its Logical Volumes.
+#allocation {
+#    When searching for free space to extend an LV, the "cling"
+#    allocation policy will choose space on the same PVs as the last
+#    segment of the existing LV.  If there is insufficient space and a
+#    list of tags is defined here, it will check whether any of them are
+#    attached to the PVs concerned and then seek to match those PV tags
+#    between existing extents and new extents.
+#    Use the special tag "@*" as a wildcard to match any PV tag.
+#    
+#    Example: LVs are mirrored between two sites within a single VG.
+#    PVs are tagged with either @site1 or @site2 to indicate where
+#    they are situated.
+#
+#    cling_tag_list = [ "@site1", "@site2" ]
+#    cling_tag_list = [ "@*" ]
+#
+#    Changes made in version 2.02.85 extended the reach of the 'cling'
+#    policies to detect more situations where data can be grouped
+#    onto the same disks.  Set this to 0 to revert to the previous
+#    algorithm.
+#
+#    maximise_cling = 1
+#
+#    Set to 1 to guarantee that mirror logs will always be placed on 
+#    different PVs from the mirror images.  This was the default
+#    until version 2.02.85.
+#
+#    mirror_logs_require_separate_pvs = 0
+#
+#    Set to 1 to guarantee that thin pool metadata will always
+#    be placed on different PVs from the pool data.
+#
+#    thin_pool_metadata_require_separate_pvs = 0
+#}
+
+# This section that allows you to configure the nature of the
+# information that LVM2 reports.
+log {
+
+    # Controls the messages sent to stdout or stderr.
+    # There are three levels of verbosity, 3 being the most verbose.
+    verbose = 0
+
+    # Should we send log messages through syslog?
+    # 1 is yes; 0 is no.
+    syslog = 1
+
+    # Should we log error and debug messages to a file?
+    # By default there is no log file.
+    #file = "/var/log/lvm2.log"
+
+    # Should we overwrite the log file each time the program is run?
+    # By default we append.
+    overwrite = 0
+
+    # What level of log messages should we send to the log file and/or syslog?
+    # There are 6 syslog-like log levels currently in use - 2 to 7 inclusive.
+    # 7 is the most verbose (LOG_DEBUG).
+    level = 0
+
+    # Format of output messages
+    # Whether or not (1 or 0) to indent messages according to their severity
+    indent = 1
+
+    # Whether or not (1 or 0) to display the command name on each line output
+    command_names = 0
+
+    # A prefix to use before the message text (but after the command name,
+    # if selected).  Default is two spaces, so you can see/grep the severity
+    # of each message.
+    prefix = "  "
+
+    # To make the messages look similar to the original LVM tools use:
+    #   indent = 0
+    #   command_names = 1
+    #   prefix = " -- "
+
+    # Set this if you want log messages during activation.
+    # Don't use this in low memory situations (can deadlock).
+    # activation = 0
+}
+
+# Configuration of metadata backups and archiving.  In LVM2 when we
+# talk about a 'backup' we mean making a copy of the metadata for the
+# *current* system.  The 'archive' contains old metadata configurations.
+# Backups are stored in a human readeable text format.
+backup {
+
+    # Should we maintain a backup of the current metadata configuration ?
+    # Use 1 for Yes; 0 for No.
+    # Think very hard before turning this off!
+    backup = 1
+
+    # Where shall we keep it ?
+    # Remember to back up this directory regularly!
+    backup_dir = "@DEFAULT_SYS_DIR@/@DEFAULT_BACKUP_SUBDIR@"
+
+    # Should we maintain an archive of old metadata configurations.
+    # Use 1 for Yes; 0 for No.
+    # On by default.  Think very hard before turning this off.
+    archive = 1
+
+    # Where should archived files go ?
+    # Remember to back up this directory regularly!
+    archive_dir = "@DEFAULT_SYS_DIR@/@DEFAULT_ARCHIVE_SUBDIR@"
+
+    # What is the minimum number of archive files you wish to keep ?
+    retain_min = 10
+
+    # What is the minimum time you wish to keep an archive file for ?
+    retain_days = 30
+}
+
+# Settings for the running LVM2 in shell (readline) mode.
+shell {
+
+    # Number of lines of history to store in ~/.lvm_history
+    history_size = 100
+}
+
+
+# Miscellaneous global LVM2 settings
+global {
+
+    # The file creation mask for any files and directories created.
+    # Interpreted as octal if the first digit is zero.
+    umask = 077
+
+    # Allow other users to read the files
+    #umask = 022
+
+    # Enabling test mode means that no changes to the on disk metadata
+    # will be made.  Equivalent to having the -t option on every
+    # command.  Defaults to off.
+    test = 0
+
+    # Default value for --units argument
+    units = "h"
+
+    # Since version 2.02.54, the tools distinguish between powers of
+    # 1024 bytes (e.g. KiB, MiB, GiB) and powers of 1000 bytes (e.g.
+    # KB, MB, GB).
+    # If you have scripts that depend on the old behaviour, set this to 0
+    # temporarily until you update them.
+    si_unit_consistency = 1
+
+    # Whether or not to communicate with the kernel device-mapper.
+    # Set to 0 if you want to use the tools to manipulate LVM metadata 
+    # without activating any logical volumes.
+    # If the device-mapper kernel driver is not present in your kernel
+    # setting this to 0 should suppress the error messages.
+    activation = 1
+
+    # If we can't communicate with device-mapper, should we try running 
+    # the LVM1 tools?
+    # This option only applies to 2.4 kernels and is provided to help you
+    # switch between device-mapper kernels and LVM1 kernels.
+    # The LVM1 tools need to be installed with .lvm1 suffices
+    # e.g. vgscan.lvm1 and they will stop working after you start using
+    # the new lvm2 on-disk metadata format.
+    # The default value is set when the tools are built.
+    # fallback_to_lvm1 = 0
+
+    # The default metadata format that commands should use - "lvm1" or "lvm2".
+    # The command line override is -M1 or -M2.
+    # Defaults to "lvm2".
+    # format = "lvm2"
+
+    # Location of proc filesystem
+    proc = "/proc"
+
+    # Type of locking to use. Defaults to local file-based locking (1).
+    # Turn locking off by setting to 0 (dangerous: risks metadata corruption
+    # if LVM2 commands get run concurrently).
+    # Type 2 uses the external shared library locking_library.
+    # Type 3 uses built-in clustered locking.
+    # Type 4 uses read-only locking which forbids any operations that might 
+    # change metadata.
+    locking_type = 1
+
+    # Set to 0 to fail when a lock request cannot be satisfied immediately.
+    wait_for_locks = 1
+
+    # If using external locking (type 2) and initialisation fails,
+    # with this set to 1 an attempt will be made to use the built-in
+    # clustered locking.
+    # If you are using a customised locking_library you should set this to 0.
+    fallback_to_clustered_locking = 1
+
+    # If an attempt to initialise type 2 or type 3 locking failed, perhaps
+    # because cluster components such as clvmd are not running, with this set
+    # to 1 an attempt will be made to use local file-based locking (type 1).
+    # If this succeeds, only commands against local volume groups will proceed.
+    # Volume Groups marked as clustered will be ignored.
+    fallback_to_local_locking = 1
+
+    # Local non-LV directory that holds file-based locks while commands are
+    # in progress.  A directory like /tmp that may get wiped on reboot is OK.
+    locking_dir = "@DEFAULT_LOCK_DIR@"
+
+    # Whenever there are competing read-only and read-write access requests for
+    # a volume group's metadata, instead of always granting the read-only
+    # requests immediately, delay them to allow the read-write requests to be
+    # serviced.  Without this setting, write access may be stalled by a high
+    # volume of read-only requests.
+    # NB. This option only affects locking_type = 1 viz. local file-based
+    # locking.
+    prioritise_write_locks = 1
+
+    # Other entries can go here to allow you to load shared libraries
+    # e.g. if support for LVM1 metadata was compiled as a shared library use
+    #   format_libraries = "liblvm2format1.so" 
+    # Full pathnames can be given.
+
+    # Search this directory first for shared libraries.
+    #   library_dir = "/lib"
+
+    # The external locking library to load if locking_type is set to 2.
+    #   locking_library = "liblvm2clusterlock.so"
+
+    # Treat any internal errors as fatal errors, aborting the process that
+    # encountered the internal error. Please only enable for debugging.
+    abort_on_internal_errors = 0
+
+    # Check whether CRC is matching when parsed VG is used multiple times.
+    # This is useful to catch unexpected internal cached volume group
+    # structure modification. Please only enable for debugging.
+    detect_internal_vg_cache_corruption = 0
+
+    # If set to 1, no operations that change on-disk metadata will be permitted.
+    # Additionally, read-only commands that encounter metadata in need of repair
+    # will still be allowed to proceed exactly as if the repair had been 
+    # performed (except for the unchanged vg_seqno).
+    # Inappropriate use could mess up your system, so seek advice first!
+    metadata_read_only = 0
+
+    # 'mirror_segtype_default' defines which segtype will be used when the
+    # shorthand '-m' option is used for mirroring.  The possible options are:
+    #
+    # "mirror" - The original RAID1 implementation provided by LVM2/DM.  It is
+    # 	         characterized by a flexible log solution (core, disk, mirrored)
+    #		 and by the necessity to block I/O while reconfiguring in the
+    #		 event of a failure.  Snapshots of this type of RAID1 can be
+    #		 problematic.
+    #
+    # "raid1"  - This implementation leverages MD's RAID1 personality through
+    # 	       	 device-mapper.  It is characterized by a lack of log options.
+    #		 (A log is always allocated for every device and they are placed
+    #		 on the same device as the image - no separate devices are
+    #		 required.)  This mirror implementation does not require I/O
+    #		 to be blocked in the kernel in the event of a failure.
+    #
+    # Specify the '--type <mirror|raid1>' option to override this default
+    # setting.
+    mirror_segtype_default = "mirror"
+
+    # The default format for displaying LV names in lvdisplay was changed 
+    # in version 2.02.89 to show the LV name and path separately.
+    # Previously this was always shown as /dev/vgname/lvname even when that
+    # was never a valid path in the /dev filesystem.
+    # Set to 1 to reinstate the previous format.
+    #
+    # lvdisplay_shows_full_device_path = 0
+
+    # Whether to use (trust) a running instance of lvmetad. If this is set to
+    # 0, all commands fall back to the usual scanning mechanisms. When set to 1
+    # *and* when lvmetad is running (it is not auto-started), the volume group
+    # metadata and PV state flags are obtained from the lvmetad instance and no
+    # scanning is done by the individual commands. In a setup with lvmetad,
+    # lvmetad udev rules *must* be set up for LVM to work correctly. Without
+    # proper udev rules, all changes in block device configuration will be
+    # *ignored* until a manual 'vgscan' is performed.
+    use_lvmetad = 0
+}
+
+activation {
+    # Set to 1 to perform internal checks on the operations issued to
+    # libdevmapper.  Useful for debugging problems with activation.
+    # Some of the checks may be expensive, so it's best to use this
+    # only when there seems to be a problem.
+    checks = 0
+
+    # Set to 0 to disable udev synchronisation (if compiled into the binaries).
+    # Processes will not wait for notification from udev.
+    # They will continue irrespective of any possible udev processing
+    # in the background.  You should only use this if udev is not running
+    # or has rules that ignore the devices LVM2 creates.
+    # The command line argument --nodevsync takes precedence over this setting.
+    # If set to 1 when udev is not running, and there are LVM2 processes
+    # waiting for udev, run 'dmsetup udevcomplete_all' manually to wake them up.
+    udev_sync = 1
+
+    # Set to 0 to disable the udev rules installed by LVM2 (if built with
+    # --enable-udev_rules). LVM2 will then manage the /dev nodes and symlinks
+    # for active logical volumes directly itself.
+    # N.B. Manual intervention may be required if this setting is changed
+    # while any logical volumes are active.
+    udev_rules = 1
+
+    # Set to 1 for LVM2 to verify operations performed by udev. This turns on
+    # additional checks (and if necessary, repairs) on entries in the device
+    # directory after udev has completed processing its events. 
+    # Useful for diagnosing problems with LVM2/udev interactions.
+    verify_udev_operations = 0
+
+    # If set to 1 and if deactivation of an LV fails, perhaps because
+    # a process run from a quick udev rule temporarily opened the device,
+    # retry the operation for a few seconds before failing.
+    retry_deactivation = 1
+
+    # How to fill in missing stripes if activating an incomplete volume.
+    # Using "error" will make inaccessible parts of the device return
+    # I/O errors on access.  You can instead use a device path, in which 
+    # case, that device will be used to in place of missing stripes.
+    # But note that using anything other than "error" with mirrored 
+    # or snapshotted volumes is likely to result in data corruption.
+    missing_stripe_filler = "error"
+
+    # The linear target is an optimised version of the striped target
+    # that only handles a single stripe.  Set this to 0 to disable this
+    # optimisation and always use the striped target.
+    use_linear_target = 1
+
+    # How much stack (in KB) to reserve for use while devices suspended
+    # Prior to version 2.02.89 this used to be set to 256KB
+    reserved_stack = 64
+
+    # How much memory (in KB) to reserve for use while devices suspended
+    reserved_memory = 8192
+
+    # Nice value used while devices suspended
+    process_priority = -18
+
+    # If volume_list is defined, each LV is only activated if there is a
+    # match against the list.
+    #   "vgname" and "vgname/lvname" are matched exactly.
+    #   "@tag" matches any tag set in the LV or VG.
+    #   "@*" matches if any tag defined on the host is also set in the LV or VG
+    #
+    # volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
+
+    # If read_only_volume_list is defined, each LV that is to be activated 
+    # is checked against the list, and if it matches, it as activated
+    # in read-only mode.  (This overrides '--permission rw' stored in the
+    # metadata.)
+    #   "vgname" and "vgname/lvname" are matched exactly.
+    #   "@tag" matches any tag set in the LV or VG.
+    #   "@*" matches if any tag defined on the host is also set in the LV or VG
+    #
+    # read_only_volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
+
+    # Size (in KB) of each copy operation when mirroring
+    mirror_region_size = 512
+
+    # Setting to use when there is no readahead value stored in the metadata.
+    #
+    # "none" - Disable readahead.
+    # "auto" - Use default value chosen by kernel.
+    readahead = "auto"
+
+    # 'raid_fault_policy' defines how a device failure in a RAID logical
+    # volume is handled.  This includes logical volumes that have the following
+    # segment types: raid1, raid4, raid5*, and raid6*.
+    #
+    # In the event of a failure, the following policies will determine what
+    # actions are performed during the automated response to failures (when
+    # dmeventd is monitoring the RAID logical volume) and when 'lvconvert' is
+    # called manually with the options '--repair' and '--use-policies'.
+    #
+    # "warn"	- Use the system log to warn the user that a device in the RAID
+    # 		  logical volume has failed.  It is left to the user to run
+    #		  'lvconvert --repair' manually to remove or replace the failed
+    #		  device.  As long as the number of failed devices does not
+    #		  exceed the redundancy of the logical volume (1 device for
+    #		  raid4/5, 2 for raid6, etc) the logical volume will remain
+    #		  usable.
+    #
+    # "allocate" - Attempt to use any extra physical volumes in the volume
+    # 		  group as spares and replace faulty devices.
+    #
+    raid_fault_policy = "warn"
+
+    # 'mirror_image_fault_policy' and 'mirror_log_fault_policy' define
+    # how a device failure affecting a mirror (of "mirror" segment type) is
+    # handled.  A mirror is composed of mirror images (copies) and a log.
+    # A disk log ensures that a mirror does not need to be re-synced
+    # (all copies made the same) every time a machine reboots or crashes.
+    #
+    # In the event of a failure, the specified policy will be used to determine
+    # what happens. This applies to automatic repairs (when the mirror is being
+    # monitored by dmeventd) and to manual lvconvert --repair when
+    # --use-policies is given.
+    #
+    # "remove" - Simply remove the faulty device and run without it.  If
+    #            the log device fails, the mirror would convert to using
+    #            an in-memory log.  This means the mirror will not
+    #            remember its sync status across crashes/reboots and
+    #            the entire mirror will be re-synced.  If a
+    #            mirror image fails, the mirror will convert to a
+    #            non-mirrored device if there is only one remaining good
+    #            copy.
+    #
+    # "allocate" - Remove the faulty device and try to allocate space on
+    #            a new device to be a replacement for the failed device.
+    #            Using this policy for the log is fast and maintains the
+    #            ability to remember sync state through crashes/reboots.
+    #            Using this policy for a mirror device is slow, as it
+    #            requires the mirror to resynchronize the devices, but it
+    #            will preserve the mirror characteristic of the device.
+    #            This policy acts like "remove" if no suitable device and
+    #            space can be allocated for the replacement.
+    #
+    # "allocate_anywhere" - Not yet implemented. Useful to place the log device
+    #            temporarily on same physical volume as one of the mirror
+    #            images. This policy is not recommended for mirror devices
+    #            since it would break the redundant nature of the mirror. This
+    #            policy acts like "remove" if no suitable device and space can
+    #            be allocated for the replacement.
+
+    mirror_log_fault_policy = "allocate"
+    mirror_image_fault_policy = "remove"
+
+    # 'snapshot_autoextend_threshold' and 'snapshot_autoextend_percent' define
+    # how to handle automatic snapshot extension. The former defines when the
+    # snapshot should be extended: when its space usage exceeds this many
+    # percent. The latter defines how much extra space should be allocated for
+    # the snapshot, in percent of its current size.
+    #
+    # For example, if you set snapshot_autoextend_threshold to 70 and
+    # snapshot_autoextend_percent to 20, whenever a snapshot exceeds 70% usage,
+    # it will be extended by another 20%. For a 1G snapshot, using up 700M will
+    # trigger a resize to 1.2G. When the usage exceeds 840M, the snapshot will
+    # be extended to 1.44G, and so on.
+    #
+    # Setting snapshot_autoextend_threshold to 100 disables automatic
+    # extensions. The minimum value is 50 (A setting below 50 will be treated
+    # as 50).
+
+    snapshot_autoextend_threshold = 100
+    snapshot_autoextend_percent = 20
+
+    # 'thin_pool_autoextend_threshold' and 'thin_pool_autoextend_percent' define
+    # how to handle automatic pool extension. The former defines when the
+    # pool should be extended: when its space usage exceeds this many
+    # percent. The latter defines how much extra space should be allocated for
+    # the pool, in percent of its current size.
+    #
+    # For example, if you set thin_pool_autoextend_threshold to 70 and
+    # thin_pool_autoextend_percent to 20, whenever a pool exceeds 70% usage,
+    # it will be extended by another 20%. For a 1G pool, using up 700M will
+    # trigger a resize to 1.2G. When the usage exceeds 840M, the pool will
+    # be extended to 1.44G, and so on.
+    #
+    # Setting thin_pool_autoextend_threshold to 100 disables automatic
+    # extensions. The minimum value is 50 (A setting below 50 will be treated
+    # as 50).
+
+    thin_pool_autoextend_threshold = 100
+    thin_pool_autoextend_percent = 20
+
+    # Full path of the utility called to check that a thin metadata device
+    # is in a state that allows it to be used.
+    # Each time a thin pool needs to be activated, this utility is executed.
+    # The activation will only proceed if the utility has an exit status of 0.
+    # Set to "" to skip this check.  (Not recommended.)
+    # The thin tools are available as part of the device-mapper-persistent-data
+    # package from https://github.com/jthornber/thin-provisioning-tools.
+    #
+    thin_check_executable = "/sbin/thin_check -q"
+
+    # While activating devices, I/O to devices being (re)configured is
+    # suspended, and as a precaution against deadlocks, LVM2 needs to pin
+    # any memory it is using so it is not paged out.  Groups of pages that
+    # are known not to be accessed during activation need not be pinned
+    # into memory.  Each string listed in this setting is compared against
+    # each line in /proc/self/maps, and the pages corresponding to any
+    # lines that match are not pinned.  On some systems locale-archive was
+    # found to make up over 80% of the memory used by the process.
+    # mlock_filter = [ "locale/locale-archive", "gconv/gconv-modules.cache" ]
+
+    # Set to 1 to revert to the default behaviour prior to version 2.02.62
+    # which used mlockall() to pin the whole process's memory while activating
+    # devices.
+    use_mlockall = 0
+
+    # Monitoring is enabled by default when activating logical volumes.
+    # Set to 0 to disable monitoring or use the --ignoremonitoring option.
+    monitoring = 1
+
+    # When pvmove or lvconvert must wait for the kernel to finish
+    # synchronising or merging data, they check and report progress
+    # at intervals of this number of seconds.  The default is 15 seconds.
+    # If this is set to 0 and there is only one thing to wait for, there
+    # are no progress reports, but the process is awoken immediately the
+    # operation is complete.
+    polling_interval = 15
+}
+
+
+####################
+# Advanced section #
+####################
+
+# Metadata settings
+#
+# metadata {
+    # Default number of copies of metadata to hold on each PV.  0, 1 or 2.
+    # You might want to override it from the command line with 0 
+    # when running pvcreate on new PVs which are to be added to large VGs.
+
+    # pvmetadatacopies = 1
+
+    # Default number of copies of metadata to maintain for each VG.
+    # If set to a non-zero value, LVM automatically chooses which of
+    # the available metadata areas to use to achieve the requested
+    # number of copies of the VG metadata.  If you set a value larger
+    # than the the total number of metadata areas available then
+    # metadata is stored in them all.
+    # The default value of 0 ("unmanaged") disables this automatic
+    # management and allows you to control which metadata areas
+    # are used at the individual PV level using 'pvchange
+    # --metadataignore y/n'.
+
+    # vgmetadatacopies = 0
+
+    # Approximate default size of on-disk metadata areas in sectors.
+    # You should increase this if you have large volume groups or
+    # you want to retain a large on-disk history of your metadata changes.
+
+    # pvmetadatasize = 255
+
+    # List of directories holding live copies of text format metadata.
+    # These directories must not be on logical volumes!
+    # It's possible to use LVM2 with a couple of directories here,
+    # preferably on different (non-LV) filesystems, and with no other 
+    # on-disk metadata (pvmetadatacopies = 0). Or this can be in
+    # addition to on-disk metadata areas.
+    # The feature was originally added to simplify testing and is not
+    # supported under low memory situations - the machine could lock up.
+    #
+    # Never edit any files in these directories by hand unless you
+    # you are absolutely sure you know what you are doing! Use
+    # the supplied toolset to make changes (e.g. vgcfgrestore).
+
+    # dirs = [ "/etc/lvm/metadata", "/mnt/disk2/lvm/metadata2" ]
+#}
+
+# Event daemon
+#
+dmeventd {
+    # mirror_library is the library used when monitoring a mirror device.
+    #
+    # "libdevmapper-event-lvm2mirror.so" attempts to recover from
+    # failures.  It removes failed devices from a volume group and
+    # reconfigures a mirror as necessary. If no mirror library is
+    # provided, mirrors are not monitored through dmeventd.
+
+    mirror_library = "libdevmapper-event-lvm2mirror.so"
+
+    # snapshot_library is the library used when monitoring a snapshot device.
+    #
+    # "libdevmapper-event-lvm2snapshot.so" monitors the filling of
+    # snapshots and emits a warning through syslog when the use of
+    # the snapshot exceeds 80%. The warning is repeated when 85%, 90% and
+    # 95% of the snapshot is filled.
+
+    snapshot_library = "libdevmapper-event-lvm2snapshot.so"
+
+    # thin_library is the library used when monitoring a thin device.
+    #
+    # "libdevmapper-event-lvm2thin.so" monitors the filling of
+    # pool and emits a warning through syslog when the use of
+    # the pool exceeds 80%. The warning is repeated when 85%, 90% and
+    # 95% of the pool is filled.
+
+    thin_library = "libdevmapper-event-lvm2thin.so"
+
+    # Full path of the dmeventd binary.
+    #
+    # executable = "@DMEVENTD_PATH@"
+}

=== removed file '.pc/dirs.patch/doc/example.conf.in'
--- .pc/dirs.patch/doc/example.conf.in	2012-04-14 02:57:53 +0000
+++ .pc/dirs.patch/doc/example.conf.in	1970-01-01 00:00:00 +0000
@@ -1,662 +0,0 @@
-# This is an example configuration file for the LVM2 system.
-# It contains the default settings that would be used if there was no
-# @DEFAULT_SYS_DIR@/lvm.conf file.
-#
-# Refer to 'man lvm.conf' for further information including the file layout.
-#
-# To put this file in a different directory and override @DEFAULT_SYS_DIR@ set
-# the environment variable LVM_SYSTEM_DIR before running the tools.
-#
-# N.B. Take care that each setting only appears once if uncommenting
-# example settings in this file.
-
-
-# This section allows you to configure which block devices should
-# be used by the LVM system.
-devices {
-
-    # Where do you want your volume groups to appear ?
-    dir = "/dev"
-
-    # An array of directories that contain the device nodes you wish
-    # to use with LVM2.
-    scan = [ "/dev" ]
-
-    # If set, the cache of block device nodes with all associated symlinks
-    # will be constructed out of the existing udev database content.
-    # This avoids using and opening any inapplicable non-block devices or
-    # subdirectories found in the device directory. This setting is applied
-    # to udev-managed device directory only, other directories will be scanned
-    # fully. LVM2 needs to be compiled with udev support for this setting to
-    # take effect. N.B. Any device node or symlink not managed by udev in
-    # udev directory will be ignored with this setting on.
-    obtain_device_list_from_udev = 1
-
-    # If several entries in the scanned directories correspond to the
-    # same block device and the tools need to display a name for device,
-    # all the pathnames are matched against each item in the following
-    # list of regular expressions in turn and the first match is used.
-    preferred_names = [ ]
-
-    # Try to avoid using undescriptive /dev/dm-N names, if present.
-    # preferred_names = [ "^/dev/mpath/", "^/dev/mapper/mpath", "^/dev/[hs]d" ]
-
-    # A filter that tells LVM2 to only use a restricted set of devices.
-    # The filter consists of an array of regular expressions.  These
-    # expressions can be delimited by a character of your choice, and
-    # prefixed with either an 'a' (for accept) or 'r' (for reject).
-    # The first expression found to match a device name determines if
-    # the device will be accepted or rejected (ignored).  Devices that
-    # don't match any patterns are accepted.