Merge lp:~gandelman-a/ubuntu/saucy/lvm2/lp1223576 into lp:ubuntu/saucy/lvm2

[Adam Gandelman]

This merges Debian 2.02.98-6, which contains a number of fixes to udev rules that seem to fix many strange issue's I've been hitting on Saucy wrt LVM snapshot deletion.

lvm2 (2.02.98-6ubuntu1) saucy; urgency=low

  * Merge from Debian unstable (LP: #1223576), remaining changes:
    - Only build clvm support for corosync:
      - debian/control: Drop Build-Depends on libcman-dev, openais-dev
      - debian/rules: Remove openais + cman from --with-clvmd build option.
    - debian/patches/avoid-dev-block.patch: Prefer any other device name over
      names in /dev/block/ since lvm.conf won't handle this.
    - debian/rules:
      - copy .po file to .pot file for Rosetta (Ubuntu specific).
    - debian/{dmsetup,lvm2}-udeb.install:
      - install initramfs and udev hooks in udebs (Debian bug 504341).
    - auto-start VGs as their PVs are discovered (Ubuntu specific):
      - add debian/tree/lvm2/lib/udev/rules.d/85-lvm2.rules: use watershed plus
        the sledgehammer of vgscan/vgchange to turn on VGs as they come online.
      - debian/tree/lvm2/usr/share/initramfs-tools/scripts/hooks/lvm2:
        - add 85-lvm2.rules to the list of udev rules to copy.
        - depend on udev.
      - debian/control:
        - add versioned Depend on watershed in lvm2 for udev rules.
        - add Depends on watershed-udeb in lvm2-udeb for udev rules.
        - add versioned Depend/Breaks on udev in dmsetup for udev rules.
        - add Depend on initramfs-tools in dmsetup so system is not potentially
          rendered unbootable by out-of-order dpkg configuration.
        - In libdevmapper-event1.02.1 add Breaks: dmeventd
          (<< 2.02.95-4ubuntu1) due to debian symbol rename
      - debian/rules:
        - do not install local-top scripts since Ubuntu mounts root using udev.
        - do not install init scripts for lvm2, since udev starts LVM.
        - continue to build clvm support.
      - debian/lvm2.postinst: handle missing lvm2 init script.
      - debian/tree/dmsetup/lib/udev/rules.d/60-persistent-storage-dm.rules:
        watch dm devices for changes with inotify
    - add mountroot failure hooks to help fix bad boots (Debian bug 468115):
      - debian/tree/lvm2/usr/share/initramfs-tools/scripts/init-premount/lvm2
    - remaining changes to upstream event manager packages (Debian bug 514706):
      - debian/rules:
        - enable dmeventd during configure.
      - debian/dmeventd.{8,manpages}: install dmeventd files.
    - rename debian/clvm.defaults to debian/clvm.default so it is installed
      correctly.
    - debian/control: add dmsetup-udeb to libdevmapper1.02.1-udeb recommends.
    - debian/rules: make sure dmsetup and lvm2 initramfs-tools scripts are
      executable. When the Ubuntu-specific ones are added with a patch,
      they may lose their executable bit.
    - Add and install clvmd resource agent
    - Add dependency on libudev-dev to libdevmapper-dev so that the .pc file
      works.
    - debian/{clvmd.ra,clvm.init}:
      - create /run/lvm if it doesn't exist.
    - debian/clvm.init:
      - exit 3 if not running on status action.
    - Call dh_installman so that our dmeventd manpage actually gets installed
    - Install the missing fsadm manpage.
    - Complete libdevmapper-dev multiarch:
      - move .so symlinks and pkgconfig files to multiarched locations.
      - mark libdevmapper-dev M-A: same

 -- Adam Gandelman <email address hidden> Thu, 12 Sep 2013 16:03:09 -0700

[lp:~gandelman-a/ubuntu/saucy/lvm2/lp1223576]

85. By Adam Gandelman on 2013-09-13

Add merge bug ref.

[Dimitri John Ledkov (xnox)]

review on the bug report.

review: Approve

=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2013-05-30 11:02:10 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-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
-missing-dmeventd.patch

=== removed directory '.pc/avoid-dev-block.patch'
=== removed directory '.pc/avoid-dev-block.patch/lib'
=== removed directory '.pc/avoid-dev-block.patch/lib/device'
=== removed file '.pc/avoid-dev-block.patch/lib/device/dev-cache.c'
--- .pc/avoid-dev-block.patch/lib/device/dev-cache.c	2013-05-30 11:02:10 +0000
+++ .pc/avoid-dev-block.patch/lib/device/dev-cache.c	1970-01-01 00:00:00 +0000
@@ -1,1037 +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 "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 *entry_name, *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;
-
-	/*
-	 * Report any missing information as "log_very_verbose" only, do not
-	 * report it as a "warning" or "error" - the record could be removed
-	 * by the time we ask for more info (node name, symlink name...).
-	 * Whatever removes *any* block device in the system (even unrelated
-	 * to our operation), we would have a warning/error on output then.
-	 * That could be misleading. If there's really any problem with missing
-	 * information from udev db, we can still have a look at the verbose log.
-	 */
-	udev_list_entry_foreach(device_entry, udev_enumerate_get_list_entry(udev_enum)) {
-		entry_name = udev_list_entry_get_name(device_entry);
-
-		if (!(device = udev_device_new_from_syspath(udev, entry_name))) {
-			log_very_verbose("udev failed to return a device for entry %s.",
-					 entry_name);
-			continue;
-		}
-
-		if (!(node_name = udev_device_get_devnode(device)))
-			log_very_verbose("udev failed to return a device node for entry %s.",
-					 entry_name);
-		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_very_verbose("udev failed to return a symlink name for entry %s.",
-						 entry_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()) {
-			if (f && f->wipe)
-				f->wipe(f); /* Calls _full_scan(1) */
-			else
-				_full_scan(1);
-		}
-	} else
-		_full_scan(0);
-
-	di->current = btree_first(_cache.devices);
-	di->filter = f;
-	if (di->filter)
-		di->filter->use_count++;
-
-	return di;
-}
-
-void dev_iter_destroy(struct dev_iter *iter)
-{
-	if (iter->filter)
-		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 directory '.pc/dirs.patch'
=== removed directory '.pc/dirs.patch/daemons'
=== removed directory '.pc/dirs.patch/daemons/dmeventd'
=== removed file '.pc/dirs.patch/daemons/dmeventd/Makefile.in'
--- .pc/dirs.patch/daemons/dmeventd/Makefile.in	2012-05-27 19:05:21 +0000
+++ .pc/dirs.patch/daemons/dmeventd/Makefile.in	1970-01-01 00:00:00 +0000
@@ -1,108 +0,0 @@
-#
-# 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

=== removed file '.pc/dirs.patch/daemons/dmeventd/dmeventd.c'
--- .pc/dirs.patch/daemons/dmeventd/dmeventd.c	2013-03-03 12:33:47 +0000
+++ .pc/dirs.patch/daemons/dmeventd/dmeventd.c	1970-01-01 00:00:00 +0000
@@ -1,2026 +0,0 @@
-/*
- * 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
-/*
- * 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_ACTIVATION_ENV_VAR_NAME "SD_ACTIVATION"
-#  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;
-	struct message_data message_data = { .msg =  msg };
-
-	/* Parse the message. */
-	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 = { 0 };
-
-	/*
-	 * 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 = { .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));
-
-	/* SD_ACTIVATION must be set! */
-	if (!(e = getenv(SD_ACTIVATION_ENV_VAR_NAME)) || strcmp(e, "1"))
-		goto out;
-
-	/* 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_ACTIVATION_ENV_VAR_NAME);
-	unsetenv(SD_LISTEN_PID_ENV_VAR_NAME);
-	unsetenv(SD_LISTEN_FDS_ENV_VAR_NAME);
-	return r;
-}
-#endif
-
-static void _remove_files_on_exit(void)
-{
-	if (unlink(DMEVENTD_PIDFILE))
-		perror(DMEVENTD_PIDFILE ": unlink failed");
-
-	if (!_systemd_activation) {
-		if (unlink(DM_EVENT_FIFO_CLIENT))
-			perror(DM_EVENT_FIFO_CLIENT " : unlink failed");
-
-		if (unlink(DM_EVENT_FIFO_SERVER))
-			perror(DM_EVENT_FIFO_SERVER " : 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");
-		exit(EXIT_FAILURE);
-	}
-
-	if (!dm_event_get_version(&fifos, &version)) {
-		fprintf(stderr, "WARNING: Could not communicate with existing dmeventd.\n");
-		fini_fifos(&fifos);
-		exit(EXIT_FAILURE);
-	}
-
-	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);
-	}
-
-	/*
-	 * Wait for daemon to die, detected by sending further DIE messages
-	 * until one fails.
-	 */
-	for (i = 0; i < 10; ++i) {
-		if (daemon_talk(&fifos, &msg, DM_EVENT_CMD_DIE, "-", "-", 0, 0))
-			break; /* yep, it's dead probably */
-		usleep(10);
-	}
-
-	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_files_on_exit);
-	(void) dm_prepare_selinux_context(NULL, 0);
-
-	/* Set the rest of the signals to cause '_exit_now' to be set */
-	signal(SIGTERM, &_exit_handler);
-	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);
-}

=== removed directory '.pc/dirs.patch/doc'
=== removed file '.pc/dirs.patch/doc/example.conf.in'
--- .pc/dirs.patch/doc/example.conf.in	2013-05-30 11:02:10 +0000
+++ .pc/dirs.patch/doc/example.conf.in	1970-01-01 00:00:00 +0000
@@ -1,816 +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.
-
-    # 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/.*/" ]
-
-    # Since "filter" is often overriden from command line, it is not suitable
-    # for system-wide device filtering (udev rules, lvmetad). To hide devices
-    # from LVM-specific udev processing and/or from lvmetad, you need to set
-    # global_filter. The syntax is the same as for normal "filter"
-    # above. Devices that fail the global_filter are not even opened by LVM.
-
-    # global_filter = []
-
-    # 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.)
-    # N.B. If obtain_device_list_from_udev is set to 1 the list of
-    # devices is instead obtained from udev and any existing .cache
-    # file is removed.
-    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
-
-    # Set to 1 to suppress all non-essential messages from stdout.
-    # This has the same effect as -qq.
-    # When this is set, the following commands still produce output:
-    # dumpconfig, lvdisplay, lvmdiskscan, lvs, pvck, pvdisplay, 
-    # pvs, version, vgcfgrestore -l, vgdisplay, vgs.
-    # Non-essential messages are shifted from log level 4 to log level 5
-    # for syslog and lvm2_log_fn purposes.
-    # Any 'yes' or 'no' questions not overridden by other arguments
-    # are suppressed and default to 'no'.
-    silent = 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.
-    #
-    #		 There is an inherent race in the dmeventd failure handling
-    #		 logic with snapshots of devices using this type of RAID1 that
-    #		 in the worst case could cause a deadlock.
-    #		   Ref: https://bugzilla.redhat.com/show_bug.cgi?id=817130#c10
-    #
-    # "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.
-    #		 This mirror implementation is not cluster-aware and cannot be
-    #		 used in a shared (active/active) fashion in a cluster.
-    #
-    # 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 'pvscan --cache' is performed.
-    #
-    # If lvmetad has been running while use_lvmetad was 0, it MUST be stopped
-    # before changing use_lvmetad to 1 and started again afterwards.
-    use_lvmetad = 0
-
-    # 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 or after it is deactivated
-    # 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 = "@THIN_CHECK_CMD@"
-
-    # String with options passed with thin_check command. By default,
-    # option '-q' is for quiet output.
-    thin_check_options = [ "-q" ]
-}
-
-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 auto_activation_volume_list is defined, each LV that is to be
-    # activated is checked against the list while using the autoactivation
-    # option (--activate ay/-a ay), and if it matches, it is activated.
-    #   "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
-    #
-    # auto_activation_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
-
-    # 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 directory '.pc/dirs.patch/lib'
=== removed directory '.pc/dirs.patch/lib/commands'
=== removed file '.pc/dirs.patch/lib/commands/toolcontext.c'
--- .pc/dirs.patch/lib/commands/toolcontext.c	2013-05-30 11:02:10 +0000
+++ .pc/dirs.patch/lib/commands/toolcontext.c	1970-01-01 00:00:00 +0000
@@ -1,1688 +0,0 @@
-/*
- * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2012 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 "toolcontext.h"
-#include "metadata.h"
-#include "defaults.h"
-#include "lvm-string.h"
-#include "activate.h"
-#include "filter.h"
-#include "filter-composite.h"
-#include "filter-md.h"
-#include "filter-mpath.h"
-#include "filter-persistent.h"
-#include "filter-regex.h"
-#include "filter-sysfs.h"
-#include "label.h"
-#include "lvm-file.h"
-#include "format-text.h"
-#include "display.h"
-#include "memlock.h"
-#include "str_list.h"
-#include "segtype.h"
-#include "lvmcache.h"
-#include "lvmetad.h"
-#include "dev-cache.h"
-#include "archiver.h"
-
-#ifdef HAVE_LIBDL
-#include "sharedlib.h"
-#endif
-
-#ifdef LVM1_INTERNAL
-#include "format1.h"
-#endif
-
-#ifdef POOL_INTERNAL
-#include "format_pool.h"
-#endif
-
-#include <locale.h>
-#include <sys/stat.h>
-#include <sys/utsname.h>
-#include <syslog.h>
-#include <time.h>
-
-#ifdef linux
-#  include <malloc.h>
-#endif
-
-static const size_t linebuffer_size = 4096;
-
-static int _get_env_vars(struct cmd_context *cmd)
-{
-	const char *e;
-
-	/* Set to "" to avoid using any system directory */
-	if ((e = getenv("LVM_SYSTEM_DIR"))) {
-		if (dm_snprintf(cmd->system_dir, sizeof(cmd->system_dir),
-				 "%s", e) < 0) {
-			log_error("LVM_SYSTEM_DIR environment variable "
-				  "is too long.");
-			return 0;
-		}
-	}
-
-	return 1;
-}
-
-static void _get_sysfs_dir(struct cmd_context *cmd)
-{
-	static char proc_mounts[PATH_MAX];
-	static char *split[4], buffer[PATH_MAX + 16];
-	FILE *fp;
-	char *sys_mnt = NULL;
-
-	cmd->sysfs_dir[0] = '\0';
-	if (!*cmd->proc_dir) {
-		log_debug("No proc filesystem found: skipping sysfs detection");
-		return;
-	}
-
-	if (dm_snprintf(proc_mounts, sizeof(proc_mounts),
-			 "%s/mounts", cmd->proc_dir) < 0) {
-		log_error("Failed to create /proc/mounts string for sysfs detection");
-		return;
-	}
-
-	if (!(fp = fopen(proc_mounts, "r"))) {
-		log_sys_error("_get_sysfs_dir fopen", proc_mounts);
-		return;
-	}
-
-	while (fgets(buffer, sizeof(buffer), fp)) {
-		if (dm_split_words(buffer, 4, 0, split) == 4 &&
-		    !strcmp(split[2], "sysfs")) {
-			sys_mnt = split[1];
-			break;
-		}
-	}
-
-	if (fclose(fp))
-		log_sys_error("fclose", proc_mounts);
-
-	if (!sys_mnt) {
-		log_error("Failed to find sysfs mount point");
-		return;
-	}
-
-	strncpy(cmd->sysfs_dir, sys_mnt, sizeof(cmd->sysfs_dir));
-}
-
-static void _init_logging(struct cmd_context *cmd)
-{
-	int append = 1;
-	time_t t;
-
-	const char *log_file;
-	char timebuf[26];
-
-	/* Syslog */
-	cmd->default_settings.syslog =
-	    find_config_tree_int(cmd, "log/syslog", DEFAULT_SYSLOG);
-	if (cmd->default_settings.syslog != 1)
-		fin_syslog();
-
-	if (cmd->default_settings.syslog > 1)
-		init_syslog(cmd->default_settings.syslog);
-
-	/* Debug level for log file output */
-	cmd->default_settings.debug =
-	    find_config_tree_int(cmd, "log/level", DEFAULT_LOGLEVEL);
-	init_debug(cmd->default_settings.debug);
-
-	/*
-	 * Suppress all non-essential stdout?
-	 * -qq can override the default of 0 to 1 later.
-	 * Once set to 1, there is no facility to change it back to 0.
-	 */
-	cmd->default_settings.silent = silent_mode() ? :
-	    find_config_tree_int(cmd, "log/silent", DEFAULT_SILENT);
-	init_silent(cmd->default_settings.silent);
-
-	/* Verbose level for tty output */
-	cmd->default_settings.verbose =
-	    find_config_tree_int(cmd, "log/verbose", DEFAULT_VERBOSE);
-	init_verbose(cmd->default_settings.verbose + VERBOSE_BASE_LEVEL);
-
-	/* Log message formatting */
-	init_indent(find_config_tree_int(cmd, "log/indent",
-					 DEFAULT_INDENT));
-	init_abort_on_internal_errors(find_config_tree_int(cmd, "global/abort_on_internal_errors",
-							   DEFAULT_ABORT_ON_INTERNAL_ERRORS));
-
-	cmd->default_settings.msg_prefix =
-		find_config_tree_str_allow_empty(cmd, "log/prefix", DEFAULT_MSG_PREFIX);
-
-	init_msg_prefix(cmd->default_settings.msg_prefix);
-
-	cmd->default_settings.cmd_name = find_config_tree_int(cmd,
-							 "log/command_names",
-							 DEFAULT_CMD_NAME);
-	init_cmd_name(cmd->default_settings.cmd_name);
-
-	/* Test mode */
-	cmd->default_settings.test =
-	    find_config_tree_int(cmd, "global/test", 0);
-	init_test(cmd->default_settings.test);
-
-	/* Settings for logging to file */
-	if (find_config_tree_int(cmd, "log/overwrite", DEFAULT_OVERWRITE))
-		append = 0;
-
-	log_file = find_config_tree_str(cmd, "log/file", 0);
-
-	if (log_file) {
-		release_log_memory();
-		fin_log();
-		init_log_file(log_file, append);
-	}
-
-	log_file = find_config_tree_str(cmd, "log/activate_file", 0);
-	if (log_file)
-		init_log_direct(log_file, append);
-
-	init_log_while_suspended(find_config_tree_int(cmd,
-						 "log/activation", 0));
-
-	t = time(NULL);
-	ctime_r(&t, &timebuf[0]);
-	timebuf[24] = '\0';
-	log_verbose("Logging initialised at %s", timebuf);
-
-	/* Tell device-mapper about our logging */
-#ifdef DEVMAPPER_SUPPORT
-	dm_log_with_errno_init(print_log);
-#endif
-	reset_log_duplicated();
-	reset_lvm_errno(1);
-}
-
-#ifdef UDEV_SYNC_SUPPORT
-/*
- * Until the DM_UEVENT_GENERATED_FLAG was introduced in kernel patch 
- * 856a6f1dbd8940e72755af145ebcd806408ecedd
- * some operations could not be performed by udev, requiring our fallback code.
- */
-static int _dm_driver_has_stable_udev_support(void)
-{
-	char vsn[80];
-	unsigned maj, min, patchlevel;
-
-	return driver_version(vsn, sizeof(vsn)) &&
-	       (sscanf(vsn, "%u.%u.%u", &maj, &min, &patchlevel) == 3) &&
-	       (maj == 4 ? min >= 18 : maj > 4);
-}
-#endif
-
-static int _process_config(struct cmd_context *cmd)
-{
-	mode_t old_umask;
-	const char *read_ahead;
-	struct stat st;
-	const struct dm_config_node *cn;
-	const struct dm_config_value *cv;
-	int64_t pv_min_kb;
-	const char *lvmetad_socket;
-
-	/* umask */
-	cmd->default_settings.umask = find_config_tree_int(cmd,
-						      "global/umask",
-						      DEFAULT_UMASK);
-
-	if ((old_umask = umask((mode_t) cmd->default_settings.umask)) !=
-	    (mode_t) cmd->default_settings.umask)
-		log_verbose("Set umask from %04o to %04o",
-                            old_umask, cmd->default_settings.umask);
-
-	/* dev dir */
-	if (dm_snprintf(cmd->dev_dir, sizeof(cmd->dev_dir), "%s/",
-			 find_config_tree_str(cmd, "devices/dir",
-					 DEFAULT_DEV_DIR)) < 0) {
-		log_error("Device directory given in config file too long");
-		return 0;
-	}
-#ifdef DEVMAPPER_SUPPORT
-	dm_set_dev_dir(cmd->dev_dir);
-
-	if (!dm_set_uuid_prefix("LVM-"))
-		return_0;
-#endif
-
-	/* proc dir */
-	if (dm_snprintf(cmd->proc_dir, sizeof(cmd->proc_dir), "%s",
-			 find_config_tree_str(cmd, "global/proc",
-					 DEFAULT_PROC_DIR)) < 0) {
-		log_error("Device directory given in config file too long");
-		return 0;
-	}
-
-	if (*cmd->proc_dir && !dir_exists(cmd->proc_dir)) {
-		log_warn("WARNING: proc dir %s not found - some checks will be bypassed",
-			 cmd->proc_dir);
-		cmd->proc_dir[0] = '\0';
-	}
-
-	/* FIXME Use global value of sysfs_dir everywhere instead cmd->sysfs_dir. */
-	_get_sysfs_dir(cmd);
-	set_sysfs_dir_path(cmd->sysfs_dir);
-	dm_set_sysfs_dir(cmd->sysfs_dir);
-
-	/* activation? */
-	cmd->default_settings.activation = find_config_tree_int(cmd,
-							   "global/activation",
-							   DEFAULT_ACTIVATION);
-	set_activation(cmd->default_settings.activation);
-
-	cmd->default_settings.suffix = find_config_tree_int(cmd,
-						       "global/suffix",
-						       DEFAULT_SUFFIX);
-
-	if (!(cmd->default_settings.unit_factor =
-	      units_to_bytes(find_config_tree_str(cmd,
-					     "global/units",
-					     DEFAULT_UNITS),
-			     &cmd->default_settings.unit_type))) {
-		log_error("Invalid units specification");
-		return 0;
-	}
-
-	read_ahead = find_config_tree_str(cmd, "activation/readahead", DEFAULT_READ_AHEAD);
-	if (!strcasecmp(read_ahead, "auto"))
-		cmd->default_settings.read_ahead = DM_READ_AHEAD_AUTO;
-	else if (!strcasecmp(read_ahead, "none"))
-		cmd->default_settings.read_ahead = DM_READ_AHEAD_NONE;
-	else {
-		log_error("Invalid readahead specification");
-		return 0;
-	}
-
-	cmd->default_settings.udev_rules = find_config_tree_int(cmd,
-								"activation/udev_rules",
-								DEFAULT_UDEV_RULES);
-
-	cmd->default_settings.udev_sync = find_config_tree_int(cmd,
-								"activation/udev_sync",
-								DEFAULT_UDEV_SYNC);
-
-	init_retry_deactivation(find_config_tree_int(cmd, "activation/retry_deactivation",
-							DEFAULT_RETRY_DEACTIVATION));
-
-	init_activation_checks(find_config_tree_int(cmd, "activation/checks",
-						      DEFAULT_ACTIVATION_CHECKS));
-
-#ifdef UDEV_SYNC_SUPPORT
-	/*
-	 * We need udev rules to be applied, otherwise we would end up with no
-	 * nodes and symlinks! However, we can disable the synchronization itself
-	 * in runtime and still have only udev to create the nodes and symlinks
-	 * without any fallback.
-	 */
-	cmd->default_settings.udev_fallback = cmd->default_settings.udev_rules ?
-		find_config_tree_int(cmd, "activation/verify_udev_operations",
-				     DEFAULT_VERIFY_UDEV_OPERATIONS) : 1;
-
-	/* Do not rely fully on udev if the udev support is known to be incomplete. */
-	if (!cmd->default_settings.udev_fallback && !_dm_driver_has_stable_udev_support()) {
-		log_very_verbose("Kernel driver has incomplete udev support so "
-				 "LVM will check and perform some operations itself.");
-		cmd->default_settings.udev_fallback = 1;
-	}
-
-#else
-	/* We must use old node/symlink creation code if not compiled with udev support at all! */
-	cmd->default_settings.udev_fallback = 1;
-#endif
-
-	cmd->use_linear_target = find_config_tree_int(cmd,
-						      "activation/use_linear_target",
-						       DEFAULT_USE_LINEAR_TARGET);
-
-	cmd->stripe_filler = find_config_tree_str(cmd,
-						  "activation/missing_stripe_filler",
-						  DEFAULT_STRIPE_FILLER);
-
-	/* FIXME Missing error code checks from the stats, not log_warn?, notify if setting overridden, delay message/check till it is actually used (eg consider if lvm shell - file could appear later after this check)? */
-	if (!strcmp(cmd->stripe_filler, "/dev/ioerror") &&
-	    stat(cmd->stripe_filler, &st))
-		cmd->stripe_filler = "error";
-
-	if (strcmp(cmd->stripe_filler, "error")) {
-		if (stat(cmd->stripe_filler, &st)) {
-			log_warn("WARNING: activation/missing_stripe_filler = \"%s\" "
-				 "is invalid,", cmd->stripe_filler);
-			log_warn("         stat failed: %s", strerror(errno));
-			log_warn("Falling back to \"error\" missing_stripe_filler.");
-			cmd->stripe_filler = "error";
-		} else if (!S_ISBLK(st.st_mode)) {
-			log_warn("WARNING: activation/missing_stripe_filler = \"%s\" "
-				 "is not a block device.", cmd->stripe_filler);
-			log_warn("Falling back to \"error\" missing_stripe_filler.");
-			cmd->stripe_filler = "error";
-		}
-	}
-
-	cmd->si_unit_consistency = find_config_tree_int(cmd,
-						  "global/si_unit_consistency",
-						  DEFAULT_SI_UNIT_CONSISTENCY);
-
-	if ((cn = find_config_tree_node(cmd, "activation/mlock_filter")))
-		for (cv = cn->v; cv; cv = cv->next) 
-			if ((cv->type != DM_CFG_STRING) || !cv->v.str[0]) 
-				log_error("Ignoring invalid activation/mlock_filter entry in config file");
-
-	cmd->metadata_read_only = find_config_tree_int(cmd, "global/metadata_read_only",
-						       DEFAULT_METADATA_READ_ONLY);
-
-	pv_min_kb = find_config_tree_int64(cmd, "devices/pv_min_size", DEFAULT_PV_MIN_SIZE_KB);
-	if (pv_min_kb < PV_MIN_SIZE_KB) {
-		log_warn("Ignoring too small pv_min_size %" PRId64 "KB, using default %dKB.",
-			 pv_min_kb, PV_MIN_SIZE_KB);
-		pv_min_kb = PV_MIN_SIZE_KB;
-	}
-	/* LVM stores sizes internally in units of 512-byte sectors. */
-	init_pv_min_size((uint64_t)pv_min_kb * (1024 >> SECTOR_SHIFT));
-
-	init_detect_internal_vg_cache_corruption
-		(find_config_tree_int(cmd, "global/detect_internal_vg_cache_corruption",
-				      DEFAULT_DETECT_INTERNAL_VG_CACHE_CORRUPTION));
-
-	lvmetad_disconnect();
-
-	lvmetad_socket = getenv("LVM_LVMETAD_SOCKET");
-	if (!lvmetad_socket)
-		lvmetad_socket = DEFAULT_RUN_DIR "/lvmetad.socket";
-
-	/* TODO?
-		lvmetad_socket = find_config_tree_str(cmd, "lvmetad/socket_path",
-						      DEFAULT_RUN_DIR "/lvmetad.socket");
-	*/
-	lvmetad_set_socket(lvmetad_socket);
-	cn = find_config_tree_node(cmd, "devices/global_filter");
-	lvmetad_set_token(cn ? cn->v : NULL);
-	lvmetad_set_active(find_config_tree_int(cmd, "global/use_lvmetad", 0));
-	lvmetad_init(cmd);
-
-	return 1;
-}
-
-static int _set_tag(struct cmd_context *cmd, const char *tag)
-{
-	log_very_verbose("Setting host tag: %s", dm_pool_strdup(cmd->libmem, tag));
-
-	if (!str_list_add(cmd->libmem, &cmd->tags, tag)) {
-		log_error("_set_tag: str_list_add %s failed", tag);
-		return 0;
-	}
-
-	return 1;
-}
-
-static int _check_host_filters(struct cmd_context *cmd, const struct dm_config_node *hn,
-			       int *passes)
-{
-	const struct dm_config_node *cn;
-	const struct dm_config_value *cv;
-
-	*passes = 1;
-
-	for (cn = hn; cn; cn = cn->sib) {
-		if (!cn->v)
-			continue;
-		if (!strcmp(cn->key, "host_list")) {
-			*passes = 0;
-			if (cn->v->type == DM_CFG_EMPTY_ARRAY)
-				continue;
-			for (cv = cn->v; cv; cv = cv->next) {
-				if (cv->type != DM_CFG_STRING) {
-					log_error("Invalid hostname string "
-						  "for tag %s", cn->key);
-					return 0;
-				}
-				if (!strcmp(cv->v.str, cmd->hostname)) {
-					*passes = 1;
-					return 1;
-				}
-			}
-		}
-		if (!strcmp(cn->key, "host_filter")) {
-			log_error("host_filter not supported yet");
-			return 0;
-		}
-	}
-
-	return 1;
-}
-
-static int _init_tags(struct cmd_context *cmd, struct dm_config_tree *cft)
-{
-	const struct dm_config_node *tn, *cn;
-	const char *tag;
-	int passes;
-
-	if (!(tn = dm_config_find_node(cft->root, "tags")) || !tn->child)
-		return 1;
-
-	/* NB hosttags 0 when already 1 intentionally does not delete the tag */
-	if (!cmd->hosttags && dm_config_find_int(cft->root, "tags/hosttags",
-					      DEFAULT_HOSTTAGS)) {
-		/* FIXME Strip out invalid chars: only A-Za-z0-9_+.- */
-		if (!_set_tag(cmd, cmd->hostname))
-			return_0;
-		cmd->hosttags = 1;
-	}
-
-	for (cn = tn->child; cn; cn = cn->sib) {
-		if (cn->v)
-			continue;
-		tag = cn->key;
-		if (*tag == '@')
-			tag++;
-		if (!validate_name(tag)) {
-			log_error("Invalid tag in config file: %s", cn->key);
-			return 0;
-		}
-		if (cn->child) {
-			passes = 0;
-			if (!_check_host_filters(cmd, cn->child, &passes))
-				return_0;
-			if (!passes)
-				continue;
-		}
-		if (!_set_tag(cmd, tag))
-			return_0;
-	}
-
-	return 1;
-}
-
-static int _load_config_file(struct cmd_context *cmd, const char *tag)
-{
-	static char config_file[PATH_MAX] = "";
-	const char *filler = "";
-	struct stat info;
-	struct config_tree_list *cfl;
-
-	if (*tag)
-		filler = "_";
-
-	if (dm_snprintf(config_file, sizeof(config_file), "%s/lvm%s%s.conf",
-			 cmd->system_dir, filler, tag) < 0) {
-		log_error("LVM_SYSTEM_DIR or tag was too long");
-		return 0;
-	}
-
-	if (!(cfl = dm_pool_alloc(cmd->libmem, sizeof(*cfl)))) {
-		log_error("config_tree_list allocation failed");
-		return 0;
-	}
-
-	if (!(cfl->cft = config_file_open(config_file, 0))) {
-		log_error("config_tree allocation failed");
-		return 0;
-	}
-
-	/* Is there a config file? */
-	if (stat(config_file, &info) == -1) {
-		if (errno == ENOENT) {
-			dm_list_add(&cmd->config_files, &cfl->list);
-			goto out;
-		}
-		log_sys_error("stat", config_file);
-		config_file_destroy(cfl->cft);
-		return 0;
-	}
-
-	log_very_verbose("Loading config file: %s", config_file);
-	if (!config_file_read(cfl->cft)) {
-		log_error("Failed to load config file %s", config_file);
-		config_file_destroy(cfl->cft);
-		return 0;
-	}
-
-	dm_list_add(&cmd->config_files, &cfl->list);
-
-      out:
-	if (*tag) {
-		if (!_init_tags(cmd, cfl->cft))
-			return_0;
-	} else
-		/* Use temporary copy of lvm.conf while loading other files */
-		cmd->cft = cfl->cft;
-
-	return 1;
-}
-
-/* Find and read first config file */
-static int _init_lvm_conf(struct cmd_context *cmd)
-{
-	/* No config file if LVM_SYSTEM_DIR is empty */
-	if (!*cmd->system_dir) {
-		if (!(cmd->cft = config_file_open(NULL, 0))) {
-			log_error("Failed to create config tree");
-			return 0;
-		}
-		return 1;
-	}
-
-	if (!_load_config_file(cmd, ""))
-		return_0;
-
-	return 1;
-}
-
-/* Read any additional config files */
-static int _init_tag_configs(struct cmd_context *cmd)
-{
-	struct str_list *sl;
-
-	/* Tag list may grow while inside this loop */
-	dm_list_iterate_items(sl, &cmd->tags) {
-		if (!_load_config_file(cmd, sl->str))
-			return_0;
-	}
-
-	return 1;
-}
-
-static struct dm_config_tree *_merge_config_files(struct cmd_context *cmd, struct dm_config_tree *cft)
-{
-	struct config_tree_list *cfl;
-
-	/* Replace temporary duplicate copy of lvm.conf */
-	if (cft->root) {
-		if (!(cft = config_file_open(NULL, 0))) {
-			log_error("Failed to create config tree");
-			return 0;
-		}
-	}
-
-	dm_list_iterate_items(cfl, &cmd->config_files) {
-		/* Merge all config trees into cmd->cft using merge/tag rules */
-		if (!merge_config_tree(cmd, cft, cfl->cft))
-			return_0;
-	}
-
-	return cft;
-}
-
-static void _destroy_tags(struct cmd_context *cmd)
-{
-	struct dm_list *slh, *slht;
-
-	dm_list_iterate_safe(slh, slht, &cmd->tags) {
-		dm_list_del(slh);
-	}
-}
-
-int config_files_changed(struct cmd_context *cmd)
-{
-	struct config_tree_list *cfl;
-
-	dm_list_iterate_items(cfl, &cmd->config_files) {
-		if (config_file_changed(cfl->cft))
-			return 1;
-	}
-
-	return 0;
-}
-
-/*
- * Returns cmdline config_tree that overrides all others, if present.
- */
-static struct dm_config_tree *_destroy_tag_configs(struct cmd_context *cmd)
-{
-	struct config_tree_list *cfl;
-	struct dm_config_tree *cft_cmdline = NULL, *cft;
-
-	cft = dm_config_remove_cascaded_tree(cmd->cft);
-	if (cft) {
-		cft_cmdline = cmd->cft;
-		cmd->cft = cft;
-	}
-
-	dm_list_iterate_items(cfl, &cmd->config_files) {
-		if (cfl->cft == cmd->cft)
-			cmd->cft = NULL;
-		config_file_destroy(cfl->cft);
-	}
-
-	if (cmd->cft) {
-		config_file_destroy(cmd->cft);
-		cmd->cft = NULL;
-	}
-
-	dm_list_init(&cmd->config_files);
-
-	return cft_cmdline;
-}
-
-static int _init_dev_cache(struct cmd_context *cmd)
-{
-	const struct dm_config_node *cn;
-	const struct dm_config_value *cv;
-	size_t len, udev_dir_len = strlen(DM_UDEV_DEV_DIR);
-	int len_diff;
-	int device_list_from_udev;
-
-	init_dev_disable_after_error_count(
-		find_config_tree_int(cmd, "devices/disable_after_error_count",
-				     DEFAULT_DISABLE_AFTER_ERROR_COUNT));
-
-	if (!dev_cache_init(cmd))
-		return_0;
-
-	device_list_from_udev = udev_is_running() ?
-		find_config_tree_bool(cmd, "devices/obtain_device_list_from_udev",
-				      DEFAULT_OBTAIN_DEVICE_LIST_FROM_UDEV) : 0;
-	init_obtain_device_list_from_udev(device_list_from_udev);
-
-	if (!(cn = find_config_tree_node(cmd, "devices/scan"))) {
-		if (!dev_cache_add_dir("/dev")) {
-			log_error("Failed to add /dev to internal "
-				  "device cache");
-			return 0;
-		}
-		log_verbose("device/scan not in config file: "
-			    "Defaulting to /dev");
-		return 1;
-	}
-
-	for (cv = cn->v; cv; cv = cv->next) {
-		if (cv->type != DM_CFG_STRING) {
-			log_error("Invalid string in config file: "
-				  "devices/scan");
-			return 0;
-		}
-
-		if (device_list_from_udev) {
-			len = strlen(cv->v.str);
-
-			/*
-			 * DM_UDEV_DEV_DIR always has '/' at its end.
-			 * If the item in the conf does not have it, be sure
-			 * to make the right comparison without the '/' char!
-			 */
-			len_diff = len && cv->v.str[len - 1] != '/' ?
-					udev_dir_len - 1 != len :
-					udev_dir_len != len;
-
-			if (len_diff || strncmp(DM_UDEV_DEV_DIR, cv->v.str, len)) {
-				device_list_from_udev = 0;
-				init_obtain_device_list_from_udev(0);
-			}
-		}
-
-		if (!dev_cache_add_dir(cv->v.str)) {
-			log_error("Failed to add %s to internal device cache",
-				  cv->v.str);
-			return 0;
-		}
-	}
-
-	if (!(cn = find_config_tree_node(cmd, "devices/loopfiles")))
-		return 1;
-
-	for (cv = cn->v; cv; cv = cv->next) {
-		if (cv->type != DM_CFG_STRING) {
-			log_error("Invalid string in config file: "
-				  "devices/loopfiles");
-			return 0;
-		}
-
-		if (!dev_cache_add_loopfile(cv->v.str)) {
-			log_error("Failed to add loopfile %s to internal "
-				  "device cache", cv->v.str);
-			return 0;
-		}
-	}
-
-
-	return 1;
-}
-
-#define MAX_FILTERS 5
-
-static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
-{
-	int nr_filt = 0;
-	const struct dm_config_node *cn;
-	struct dev_filter *filters[MAX_FILTERS] = { 0 };
-	struct dev_filter *composite;
-
-	/*
-	 * Filters listed in order: top one gets applied first.
-	 * Failure to initialise some filters is not fatal.
-	 * Update MAX_FILTERS definition above when adding new filters.
-	 */
-
-	/*
-	 * sysfs filter. Only available on 2.6 kernels.  Non-critical.
-	 * Listed first because it's very efficient at eliminating
-	 * unavailable devices.
-	 */
-	if (find_config_tree_bool(cmd, "devices/sysfs_scan",
-			     DEFAULT_SYSFS_SCAN)) {
-		if ((filters[nr_filt] = sysfs_filter_create(cmd->sysfs_dir)))
-			nr_filt++;
-	}
-
-	/* regex filter. Optional. */
-	if (!(cn = find_config_tree_node(cmd, "devices/filter")))
-		log_very_verbose("devices/filter not found in config file: "
-				 "no regex filter installed");
-
-	else if (!(filters[nr_filt] = regex_filter_create(cn->v))) {
-		log_error("Failed to create regex device filter");
-		goto bad;
-	} else
-		nr_filt++;
-
-	/* device type filter. Required. */
-	cn = find_config_tree_node(cmd, "devices/types");
-	if (!(filters[nr_filt] = lvm_type_filter_create(cmd->proc_dir, cn))) {
-		log_error("Failed to create lvm type filter");
-		goto bad;
-	}
-	nr_filt++;
-
-	/* md component filter. Optional, non-critical. */
-	if (find_config_tree_bool(cmd, "devices/md_component_detection",
-			     DEFAULT_MD_COMPONENT_DETECTION)) {
-		init_md_filtering(1);
-		if ((filters[nr_filt] = md_filter_create()))
-			nr_filt++;
-	}
-
-	/* mpath component filter. Optional, non-critical. */
-	if (find_config_tree_bool(cmd, "devices/multipath_component_detection",
-			     DEFAULT_MULTIPATH_COMPONENT_DETECTION)) {
-		if ((filters[nr_filt] = mpath_filter_create(cmd->sysfs_dir)))
-			nr_filt++;
-	}
-
-	/* Only build a composite filter if we really need it. */
-	if (nr_filt == 1)
-		return filters[0];
-
-	if (!(composite = composite_filter_create(nr_filt, filters)))
-		goto_bad;
-
-	return composite;
-bad:
-	while (--nr_filt >= 0)
-		 filters[nr_filt]->destroy(filters[nr_filt]);
-
-	return NULL;
-}
-
-static int _init_filters(struct cmd_context *cmd, unsigned load_persistent_cache)
-{
-	static char cache_file[PATH_MAX];
-	const char *dev_cache = NULL, *cache_dir, *cache_file_prefix;
-	struct dev_filter *f3 = NULL, *f4 = NULL, *toplevel_components[2] = { 0 };
-	struct stat st;
-	const struct dm_config_node *cn;
-
-	cmd->dump_filter = 0;
-
-	if (!(f3 = _init_filter_components(cmd)))
-		goto_bad;
-
-	init_ignore_suspended_devices(find_config_tree_int(cmd,
-	    "devices/ignore_suspended_devices", DEFAULT_IGNORE_SUSPENDED_DEVICES));
-
-	/*
-	 * If 'cache_dir' or 'cache_file_prefix' is set, ignore 'cache'.
-	 */
-	cache_dir = find_config_tree_str(cmd, "devices/cache_dir", NULL);
-	cache_file_prefix = find_config_tree_str(cmd, "devices/cache_file_prefix", NULL);
-
-	if (cache_dir || cache_file_prefix) {
-		if (dm_snprintf(cache_file, sizeof(cache_file),
-		    "%s%s%s/%s.cache",
-		    cache_dir ? "" : cmd->system_dir,
-		    cache_dir ? "" : "/",
-		    cache_dir ? : DEFAULT_CACHE_SUBDIR,
-		    cache_file_prefix ? : DEFAULT_CACHE_FILE_PREFIX) < 0) {
-			log_error("Persistent cache filename too long.");
-			goto bad;
-		}
-	} else if (!(dev_cache = find_config_tree_str(cmd, "devices/cache", NULL)) &&
-		   (dm_snprintf(cache_file, sizeof(cache_file),
-				"%s/%s/%s.cache",
-				cmd->system_dir, DEFAULT_CACHE_SUBDIR,
-				DEFAULT_CACHE_FILE_PREFIX) < 0)) {
-		log_error("Persistent cache filename too long.");
-		goto bad;
-	}
-
-	if (!dev_cache)
-		dev_cache = cache_file;
-
-	if (!(f4 = persistent_filter_create(f3, dev_cache))) {
-		log_verbose("Failed to create persistent device filter.");
-		f3->destroy(f3);
-		return_0;
-	}
-
-	/* Should we ever dump persistent filter state? */
-	if (find_config_tree_int(cmd, "devices/write_cache_state", 1))
-		cmd->dump_filter = 1;
-
-	if (!*cmd->system_dir)
-		cmd->dump_filter = 0;
-
-	/*
-	 * Only load persistent filter device cache on startup if it is newer
-	 * than the config file and this is not a long-lived process.
-	 */
-	if (load_persistent_cache && !cmd->is_long_lived &&
-	    !stat(dev_cache, &st) &&
-	    (st.st_ctime > config_file_timestamp(cmd->cft)) &&
-	    !persistent_filter_load(f4, NULL))
-		log_verbose("Failed to load existing device cache from %s",
-			    dev_cache);
-
-	if (!(cn = find_config_tree_node(cmd, "devices/global_filter"))) {
-		cmd->filter = f4;
-	} else if (!(cmd->lvmetad_filter = regex_filter_create(cn->v)))
-		goto_bad;
-	else {
-		toplevel_components[0] = cmd->lvmetad_filter;
-		toplevel_components[1] = f4;
-		if (!(cmd->filter = composite_filter_create(2, toplevel_components)))
-			goto_bad;
-	}
-
-	return 1;
-bad:
-	if (f3)
-		f3->destroy(f3);
-	if (f4)
-		f4->destroy(f4);
-	if (toplevel_components[0])
-		toplevel_components[0]->destroy(toplevel_components[0]);
-	return 0;
-}
-
-struct format_type *get_format_by_name(struct cmd_context *cmd, const char *format)
-{
-        struct format_type *fmt;
-
-        dm_list_iterate_items(fmt, &cmd->formats)
-                if (!strcasecmp(fmt->name, format) ||
-                    !strcasecmp(fmt->name + 3, format) ||
-                    (fmt->alias && !strcasecmp(fmt->alias, format)))
-                        return fmt;
-
-        return NULL;
-}
-
-static int _init_formats(struct cmd_context *cmd)
-{
-	const char *format;
-
-	struct format_type *fmt;
-
-#ifdef HAVE_LIBDL
-	const struct dm_config_node *cn;
-#endif
-
-#ifdef LVM1_INTERNAL
-	if (!(fmt = init_lvm1_format(cmd)))
-		return 0;
-	fmt->library = NULL;
-	dm_list_add(&cmd->formats, &fmt->list);
-#endif
-
-#ifdef POOL_INTERNAL
-	if (!(fmt = init_pool_format(cmd)))
-		return 0;
-	fmt->library = NULL;
-	dm_list_add(&cmd->formats, &fmt->list);
-#endif
-
-#ifdef HAVE_LIBDL
-	/* Load any formats in shared libs if not static */
-	if (!is_static() &&
-	    (cn = find_config_tree_node(cmd, "global/format_libraries"))) {
-
-		const struct dm_config_value *cv;
-		struct format_type *(*init_format_fn) (struct cmd_context *);
-		void *lib;