Revert broken commit:

2009-07-15 06:10:51  Un-export vg_read_internal.

lvm-functions.c:774: warning: implicit declaration of function 'vg_read_internal'

INSTALL

@@ -1,44 +1,30 @@
-LVM2 installation
-=================
+Installation
+============
 
-1) Install device-mapper
-
-   Ensure the device-mapper has been installed on the machine.
-
-   The device-mapper should be in the kernel (look for 'device-mapper'
-   messages in the kernel logs) and /usr/include/libdevmapper.h 
-   and libdevmapper.so should be present.
-
-   The device-mapper is available from:
-     ftp://ftp.sistina.com/pub/LVM2/device-mapper/
-
-
-2) Generate custom makefiles.
+1) Generate custom makefiles.
 
    Run the 'configure' script from the top directory.
 
-   If you wish to use the built-in LVM2 shell and have GNU readline 
-   installed (http://www.gnu.org/directory/readline.html) use:
-     ./configure --enable-readline
-
    If you don't want to include the LVM1 backwards-compatibility code use:
      ./configure --with-lvm1=none 
 
    To separate the LVM1 support into a shared library loaded by lvm.conf use:
      ./configure --with-lvm1=shared
 
+   Use ./configure --help to see other options.
 
-3) Build and install LVM2.
+2) Build and install.
 
-   Run 'make install' from the top directory.
+   Run 'make' from the top directory to build everything you configured.
+   Run 'make install' to build and install everything you configured.
 
+   If you only want the device-mapper libraries and tools use
+   'make device-mapper' or 'make install_device-mapper'.
 
-4) Create a configuration file
+3) If using LVM2, create a configuration file.
 
    The tools will work fine without a configuration file being
    present, but you ought to review the example file in doc/example.conf.
-   For example, specifying the devices that LVM2 is to use can
-   make the tools run more efficiently - and avoid scanning /dev/cdrom!
 
 Please also refer to the WHATS_NEW file and the manual pages for the 
 individual commands.

Makefile.in

@@ -22,40 +22,47 @@ ifeq ("@INTL@", "yes")
   SUBDIRS += po
 endif
 
-SUBDIRS += lib tools daemons
+SUBDIRS += lib tools daemons libdm
 
-ifeq ("@DMEVENTD@", "yes")
-  SUBDIRS += dmeventd
+ifeq ("@APPLIB@", "yes")
+  SUBDIRS += liblvm
 endif
 
 ifeq ($(MAKECMDGOALS),distclean)
   SUBDIRS += daemons/clvmd \
-	     dmeventd \
+	     daemons/dmeventd/plugins \
+	     daemons/dmeventd \
 	     lib/format1 \
 	     lib/format_pool \
 	     lib/locking \
 	     lib/mirror \
 	     lib/snapshot \
+	     test/api \
 	     test \
 	     po
-  DISTCLEAN_TARGETS += lib/misc/configure.h
+  DISTCLEAN_TARGETS += lib/misc/configure.h lib/misc/lvm-version.h
   DISTCLEAN_DIRS += lcov_reports*
 endif
 
 include make.tmpl
 
-daemons: lib
-lib: include
-tools: lib
-dmeventd: tools
-po: tools daemons dmeventd
+libdm: include
+lib: libdm
+liblvm: lib
+daemons: lib tools
+tools: lib device-mapper
+po: tools daemons
+
+libdm.device-mapper: include.device-mapper
+daemons.device-mapper: libdm.device-mapper
+tools.device-mapper: libdm.device-mapper
+device-mapper: tools.device-mapper daemons.device-mapper man.device-mapper
 
 ifeq ("@INTL@", "yes")
 lib.pofile: include.pofile
 tools.pofile: lib.pofile
 daemons.pofile: lib.pofile
-dmeventd.pofile: tools.pofile
-po.pofile: tools.pofile daemons.pofile dmeventd.pofile
+po.pofile: tools.pofile daemons.pofile
 pofile: po.pofile
 endif
 
@@ -84,18 +91,21 @@ endif
 
 lcov-reset:
 	$(LCOV) -d $(top_srcdir)/dmeventd --zerocounters
+	$(LCOV) -d $(top_srcdir)/libdm --zerocounters
 	$(LCOV) -d $(top_srcdir)/lib --zerocounters
 	$(LCOV) -d $(top_srcdir)/tools --zerocounters
 
 lcov: all
 	$(RM) -rf $(LCOV_REPORTS_DIR)
 	$(MKDIR_P) $(LCOV_REPORTS_DIR)
+	$(LCOV) -b ${top_srcdir}/libdm -d $(top_srcdir)/libdm -c -o $(LCOV_REPORTS_DIR)/libdm.info
 	$(LCOV) -b $(top_srcdir)/lib -d $(top_srcdir)/lib -c -o $(LCOV_REPORTS_DIR)/lib.info
 	$(LCOV) -b $(top_srcdir)/tools -d $(top_srcdir)/tools -c -o $(LCOV_REPORTS_DIR)/tools.info
 	DMEVENTD_INFO="$(LCOV_REPORTS_DIR)/dmeventd.info" ;\
 	DMEVENTD_INFO_A="-a $$DMEVENTDINFO" ;\
 	$(LCOV) -b $(top_srcdir)/dmeventd -d $(top_srcdir)/dmeventd -c -o $$DMEVENTD_INFO || DMEVENTD_INFO_A="" ;\
 	$(LCOV) $$DMEVENTD_INFO_A -a $(LCOV_REPORTS_DIR)/lib.info \
+		-a $(LCOV_REPORTS_DIR)/libdm.info \
 		-a $(LCOV_REPORTS_DIR)/tools.info \
 		-o $(LCOV_REPORTS_DIR)/lvm.info
 ifneq ("@GENHTML@", "")

README

@@ -1,23 +1,27 @@
-This directory contains LVM2, the new version of the userland LVM
-tools designed for the new device-mapper for the Linux kernel.
+This tree contains the LVM2 and device-mapper tools and libraries.
 
-The device-mapper needs to be installed before compiling these LVM2 tools.
-
-For more information about LVM2 read the WHATS_NEW file.
+For more information about LVM2 read the changelog in the WHATS_NEW file.
 Installation instructions are in INSTALL.
 
 There is no warranty - see COPYING and COPYING.LIB.
 
 Tarballs are available from:
   ftp://sources.redhat.com/pub/lvm2/
-  ftp://sources.redhat.com/pub/dm/
 
 To access the CVS tree use:
   cvs -d :pserver:cvs@sources.redhat.com:/cvs/lvm2 login
   CVS password: cvs
   cvs -d :pserver:cvs@sources.redhat.com:/cvs/lvm2 co LVM2
 
-Mailing list for discussion/bug reports etc.
+Mailing list for general discussion related to LVM2:
   linux-lvm@redhat.com
   Subscribe from https://www.redhat.com/mailman/listinfo/linux-lvm
 
+Mailing list for LVM2 development, patches and commits:
+  lvm-devel@redhat.com
+  Subscribe from https://www.redhat.com/mailman/listinfo/linux-lvm
+
+Mailing list for device-mapper development, including kernel patches
+and multipath-tools:
+  dm-devel@redhat.com
+  Subscribe from https://www.redhat.com/mailman/listinfo/dm-devel

VERSION

@@ -1 +1 @@
-2.02.40-cvs (2008-06-27)
+2.02.50-cvs (2009-07-15)

VERSION_DM

@@ -0,0 +1 @@
+1.02.35-cvs (2009-07-15)

WHATS_NEW

@@ -1,5 +1,277 @@
-Version 2.02.40 - 
+Version 2.02.50 - 
 ================================
+
+Version 2.02.49 - 15th July 2009
+================================
+  Exclude VG_GLOBAL from vg_write_lock_held so scans open devs read-only again.
+  Add unit test case for liblvm VG create/delete APIs.
+  Add liblvm APIs to implement creation and deletion of VGs.
+  Initialize cmd->cmd_line to "liblvm" in new liblvm library.
+  Place handles to liblvm objects for pv, vg, lv, lvseg, pvseg inside lvm.h.
+  Refactor vgsplit and vgextend to remove READ_REQUIRE_RESIZEABLE flag.
+  Use _exit() not exit() after forking to avoid flushing libc buffers twice.
+  Add cast to log_info arg in _find_labeller to avoid Sparc64 warning.
+  Make cmd->cmd_line const.
+  Fix dev name mismatch in vgcreate man page example.
+  Refactor vg_remove_single for use in liblvm.
+  Make all tools use consistent lock ordering obtaining VG_ORPHAN lock second.
+  Check md devices for a partition table during device scan.
+  Add extended device (blkext) and md partition (mdp) types to filters.
+  Make text metadata read errors for segment areas more precise.
+  Fix text segment metadata read errors to mention correct segment name.
+  Include segment and LV names in text segment import error messages.
+  Add parent node to config_node structure.
+  Update vgsplit and vgcreate to call new vg_create and 'set' functions.
+  Change vg_create to take minimal parameters, obtain a lock, and return vg_t.
+  Refactor vgchange extent_size, max_lv, max_pv, and alloc_policy for liblvm.
+  Update t-vgcreate-usage.sh to test for default vg properties.
+  Fix memory leak in vgsplit when re-reading the vg.
+  Make various exit/cleanup paths more robust after lvm init failures.
+  Use LCK_NONBLOCK implicitly instead of explicit vg_read() flag.
+  Remove unnecessary locking and existence tests from new vg_read() interface.
+  Permit several segment types to be registered by a single shared object.
+  Update the man pages to document size units uniformly.
+  Allow commandline sizes to be specified in terms of bytes and sectors.
+  Update 'md_chunk_alignment' to use stripe-width to align PV data area.
+  Update test/t-inconsistent-metadata.sh to match new vg_read interface.
+  Add lvmcache_init() to polldaemon initialization.
+  Convert tools to use new vg_read / vg_read_for_update.
+  Fix segfault in vg_release when vg->cmd is NULL.
+
+Version 2.02.48 - 30th June 2009
+================================
+  Abort if automatic metadata correction fails when reading VG to update it.
+  Explicitly request fallback to default major number in device mapper.
+  Ignore suspended devices during repair.
+  Call vgreduce --removemissing automatically to fix missing PVs in dmeventd.
+  Suggest using lvchange --resync when adding leg to not-yet-synced mirror.
+  Destroy toolcontext on clvmd exit to avoid memory pool leaks.
+  Fix lvconvert not to poll mirror if no conversion in progress.
+  Fix memory leaks in toolcontext error path.
+  Reinstate partial activation support in clustered mode. (2.02.40)
+  Allow metadata correction even when PVs are missing.
+  Use 'lvm lvresize' instead of 'lvresize' in fsadm.
+  Do not use '-n' realine option in fsadm for busybox compatiblity.
+  Add vg_lock_newname() library function for vgrename, vgsplit and vgcreate.
+  Round up requested readahead to at least one page and print warning.
+  Try to repair vg before actual vgremove when force flag provided.
+  Fix possible double release of VG after recovery.
+  Add parameter to process_each_vg specifying what to do with inconsistent VG.
+  Unify error messages when processing inconsistent volume group.
+  Use lvconvert --repair instead of vgreduce in mirror dmeventd DSO.
+  Introduce lvconvert --use_policies (repair policy according to lvm.conf).
+  Update clvmd-corosync to match new corosync API.
+  Fix lib Makefile to include any shared libraries in default target.
+  Fix rename of active snapshot with virtual origin.
+  Fix convert polling to ignore LV with different UUID.
+  Cache underlying device readahead only before activation calls.
+  Fix segfault when calculating readahead on missing device in vgreduce.
+  Remove verbose 'visited' messages.
+  Handle multi-extent mirror log allocation when smallest PV has only 1 extent.
+  Add LSB standard headers and functions (incl. reload) to clvmd initscript.
+  When creating new LV, double-check that name is not already in use.
+  Remove /dev/vgname/lvname symlink automatically if LV is no longer visible.
+  Rename internal vorigin LV to match visible LV.
+  Suppress 'removed' messages displayed when internal LVs are removed.
+  Fix lvchange -a and -p for sparse LVs.
+  Fix lvcreate --virtualsize to activate the new device immediately.
+  Make --snapshot optional with lvcreate --virtualsize.
+  Generalise --virtualoriginsize to --virtualsize.
+  Skip virtual origins in process_each_lv_in_vg() without --all.
+  Fix counting of virtual origin LVs in vg_validate.
+  Attempt to load dm-zero module if zero target needed but not present.
+
+Version 2.02.47 - 22nd May 2009
+===============================
+  Rename liblvm.so to liblvm2app.so and use configure --enable-applib.
+  Reinstate version in liblvm2cmd.so soname. (2.02.44)
+
+Version 2.02.46 - 21st May 2009
+===============================
+  Inherit readahead setting from underlying devices during activation.
+  Detect LVs active on remote nodes by querying locks if supported.
+  Enable online resizing of mirrors.
+  Use suspend with flush when device size was changed during table preload.
+  Implement query_resource_fn for cluster_locking.
+  Support query_resource_fn in locking modules.
+  Introduce CLVMD_CMD_LOCK_QUERY command for clvmd.
+  Fix pvmove to revert operation if temporary mirror creation fails.
+  Fix metadata export for VG with missing PVs.
+  Add vgimportclone and install it and the man page by default.
+  Force max_lv restriction only for newly created LV.
+  Remove unneeded import parameter from lv_create_empty.
+  Merge lv_is_displayable and lv_is_visible functions.
+  Introduce lv_set_visible & lv_set_hidden functions.
+  Fix lv_is_visible to handle virtual origin.
+  Introduce link_lv_to_vg and unlink_lv_from_vg functions.
+  Remove lv_count from VG and use counter function instead.
+  Fix snapshot segment import to not use duplicate segments & replace.
+  Do not query nonexistent devices for readahead.
+  Remove NON_BLOCKING lock flag from tools and set a policy to auto-set.
+  Remove snapshot_count from VG and use function instead.
+  Fix first_seg() call for empty segment list.
+  Add install_lvm2 makefile target to install only the LVM2 components.
+  Reject missing PVs from allocation in toollib.
+  Fix PV datalignment for values starting prior to MDA area. (2.02.45)
+  Add sparse devices: lvcreate -s --virtualoriginsize (hidden zero origin).
+  Fix minimum width of devices column in reports.
+  Add lvs origin_size field.
+  Fix linux configure --enable-debug to exclude -O2.
+  Implement lvconvert --repair for repairing partially-failed mirrors.
+  Fix vgreduce --removemissing failure exit code.
+  Fix remote metadata backup for clvmd.
+  Introduce unlock_and_release_vg macro.
+  Introduce vg_release() to be called to free every struct volume_group.
+  Alloc PV internal structure from VG mempool if possible.
+  Fix metadata backup to run after vg_commit always.
+  Tidy clvmd volume lock cache functions.
+  Fix pvs report for orphan PVs when segment attributes are requested.
+  Fix pvs -a output to not read volume groups from non-PV devices.
+  Add MMC (mmcblk) device type to filters.
+  Introduce memory pools per volume group (to reduce memory for large VGs).
+  Use copy of PV structure when manipulating global PV lists.
+  Always return exit error status when locking of volume group fails.
+  Fix mirror log convert validation question.
+  Avoid referencing files from DESTDIR during build process.
+  Avoid creating some static libraries unless configured --enable-static_link.
+  Enable use of cached metadata for pvs and pvdisplay commands.
+  Add missing 'device-mapper' internal subdir build dependency.
+  Fix memory leak in mirror allocation code.
+  Save and restore the previous logging level when log level is changed.
+  Fix error message when archive initialization fails.
+  Make sure clvmd-corosync releases the lockspace when it exits.
+  Fix segfault for vgcfgrestore on VG with missing PVs.
+  Block SIGTERM & SIGINT in clvmd subthreads.
+  Detect and conditionally wipe swapspace signatures in pvcreate.
+  Fix maximal volume count check for snapshots if max_lv set for volume group.
+  Fix lvcreate to remove unused cow volume if the snapshot creation fails.
+  Fix error messages when PV uuid or pe_start reading fails.
+  Build new liblvm application-level library.
+  Rename liblvm.a to liblvm-internal.a.
+  Flush memory pool and fix locking in clvmd refresh and backup command.
+  Fix unlocks in clvmd-corosync. (2.02.45)
+  Fix error message when adding metadata directory to internal list fails.
+  Fix size and error message of memory allocation at backup initialization.
+  Remove old metadata backup file after renaming VG.
+  Restore log_suppress state when metadata backup file is up-to-date.
+
+Version 2.02.45 - 3rd March 2009
+================================
+  Avoid scanning empty metadata areas for VG names.
+  Attempt proper clean up in child before executing new binary in exec_cmd().
+  Do not scan devices if reporting only attributes from PV label.
+  Use pkgconfig to obtain corosync library details during configuration.
+  Fix error returns in clvmd-corosync interface to DLM.
+  Add --refresh to vgchange and vgmknodes man pages.
+  Pass --test from lvresize to fsadm as --dry-run.
+  Supply argv[] list to exec_cmd() to allow for variable number of parameters.
+  Prevent fsadm from checking mounted filesystems.
+  No longer treats any other key as 'no' when prompting in fsadm.
+  Tidy fsadm command line processing.
+  Add lib/lvm.h and lib/lvm_base.c for the new library interface.
+  Move tools/version.h to lib/misc/lvm-version.h.
+  Split LVM_VERSION into MAJOR, MINOR, PATCHLEVEL, RELEASE and RELEASE_DATE.
+  Add system_dir parameter to create_toolcontext().
+  Add --dataalignment to pvcreate to specify alignment of data area.
+  Exclude LCK_CACHE locks from _vg_lock_count, fixing interrupt unblocking.
+  Provide da and mda locations in debug message when writing text format label.
+  Mention the restriction on file descriptors at invocation on the lvm man page.
+  Index cached vgmetadata by vgid not vgname to cope with duplicate vgnames.
+  No longer require kernel and metadata major numbers to match.
+  Add a fully-functional get_cluster_name() to clvmd corosync interface.
+  Remove duplicate cpg_initialize from clvmd startup.
+  Add option to /etc/sysconfig/cluster to select cluster type for clvmd.
+  Allow clvmd to start up if its lockspace already exists.
+  Separate PV label attributes which do not need parse metadata when reporting.
+  Remove external dependency on the 'cut' command from fsadm.
+  Fix pvs segfault when pv mda attributes requested for not available PV.
+  Add fsadm support for reszing ext4 filesysystems.
+  Move locking_type reading inside init_locking().
+  Rename get_vgs() to get_vgnames() and clarify related error messages.
+  Allow clvmd to be built with all cluster managers & select one on cmdline.
+  Mention --with-clvmd=corosync in ./configure.
+  Replace internal vg_check_status() implementation.
+  Rename vg_read() to vg_read_internal().
+
+Version 2.02.44 - 26th January 2009
+===================================
+  Fix --enable-static_link after the recent repository changes.
+  Add corosync/DLM cluster interface to clvmd.
+  Add --nameprefixes, --unquoted, --rows to pvs, vgs, lvs man pages.
+  Fix lvresize size conversion for fsadm when block size is not 1K.
+  Fix pvs segfault when run with orphan PV and some VG fields.
+  Display a 'dev_size' of zero for missing devices in reports.
+  Add pv_mda_size to pvs and vg_mda_size to vgs.
+  Fix lvmdump /sys listing to include virtual devices directory.
+  Add "--refresh" functionality to vgchange and vgmknodes.
+  Avoid exceeding LV size when wiping device.
+  Calculate mirror log size instead of using 1 extent.
+  Ensure requested device number is available before activating with it.
+  Fix incorrect exit status from 'help <command>'.
+  Fix vgrename using UUID if there are VGs with identical names.
+  Fix segfault when invalid field given in reporting commands.
+  Move is_static from cmd to global is_static().
+  Refactor init_lvm() for lvmcmdline and clvmd.
+  Add liblvm interactive test infrastructure to build.
+  Add skeleton lvm2.h file in preparation for a shared library interface.
+  Use better random seed value in temp file creation.
+  Add read_urandom to read /dev/urandom. Use in uuid calculation.
+  Use displayable_lvs_in_vg and lv_is_displayable for consistency throughout.
+  Fix race in vgcreate that would result in second caller overwriting first.
+  Fix uninitialised lv_count in vgdisplay -c.
+  Don't skip updating pvid hash when lvmcache_info struct got swapped.
+  Add tinfo to termcap search path for pld-linux.
+  Fix startup race in clvmd.
+  Generate Red Hat clvmd startup script at config time with correct paths.
+  Fix clvmd & dmeventd builds after tree restructuring.
+  Cope with snapshot dependencies when removing a whole VG with lvremove.
+  Make man pages and tool help text consistent using | for alternative options.
+
+Version 2.02.43 - 10th November 2008
+====================================
+  Merge device-mapper into the lvm2 tree.
+  Correct prototype for --permission on lvchange and lvcreate man pages.
+  Exit with non-zero status from vgdisplay if couldn't show any requested VG.
+  Move list.c into libdevmapper and rename functions.
+  Rename a couple of variables that matched function names.
+  Use simplified x.y.z version number in libdevmapper.pc.
+  Remove ancient debian directory.
+  Split out lvm-logging.h from log.h and lvm-globals.[ch] from log.[ch].
+
+Version 2.02.42 - 26th October 2008
+===================================
+  Accept locking fallback_to_* options in the global section as documented.
+  Fix temp table activation in mirror conversions not to happen in other cmds.
+  Fix temp table in mirror conversions to use always-present error not zero.
+
+Version 2.02.41 - 17th October 2008
+===================================
+  Use temp table to set device size when converting mirrors.
+  In resume_mirror_images replace activate_lv with resume_lv as workaround.
+  Avoid overwriting in-use on-disk text metadata by forgetting MDA_HEADER_SIZE.
+  Fix snapshot monitoring library to not cancel monitoring invalid snapshot.
+  Generate man pages from templates and include version.
+  Add usrlibdir and usrsbindir to configure.
+  Fix conversion of md chunk size into sectors.
+  Free text metadata buffer after a failure writing it.
+  Fix misleading error message when there are no allocatable extents in VG.
+  Fix handling of PVs which reappeared with old metadata version.
+  Fix mirror DSO to call vgreduce with proper parameters.
+  Fix validation of --minor and --major in lvcreate to require -My always.
+  Fix release: clvmd build, vgreduce consolidate & tests, /dev/ioerror warning.
+
+Version 2.02.40 - 19th September 2008
+=====================================
+  Allow lvremove to remove LVs from VGs with missing PVs.
+  In VG with PVs missing, by default allow activation of LVs that are complete.
+  Track PARTIAL_LV and MISSING_PV flags internally.
+  Require --force with --removemissing in vgreduce to remove partial LVs.
+  No longer write out PARTIAL flag into metadata backups.
+  Treat new default activation/missing_stripe_filler "error" as an error target.
+  Remove internal partial_mode.
+  Add devices/md_chunk_alignment to lvm.conf.
+  Pass struct physical_volume to pe_align and adjust for md chunk size.
+  Store sysfs location in struct cmd_context.
   Avoid shuffling remaining mirror images when removing one, retaining primary.
   Add missing LV error target activation in _remove_mirror_images.
   Prevent resizing an LV while lvconvert is using it.

WHATS_NEW_DM

@@ -1,5 +1,48 @@
-Version 1.02.29 -
-=====================================
+Version 1.02.35 - 
+================================
+
+Version 1.02.34 - 15th July 2009
+================================
+  Use _exit() not exit() after forking to avoid flushing libc buffers twice.
+  Rename plog macro to LOG_LINE & add LOG_MESG variant for dm_dump_memory_debug.
+  Change plog to use dm_log_with_errno unless deprecated dm_log_init was used.
+  Add dm_log_with_errno and dm_log_with_errno_init, deprecating the old fns.
+  Fix whitespace in linear target line to fix identical table line detection.
+  Add device number to more log messages during activation.
+
+Version 1.02.33 - 30th June 2009
+================================
+  Don't fallback to default major number: use dm_task_set_major_minor. (1.02.31)
+  Do not fork daemon when dmeventd cannot be found.
+  Add crypt target handling to libdevmapper tree nodes.
+  Add splitname command to dmsetup.
+  Add subsystem, vg_name, lv_name, lv_layer fields to dmsetup reports.
+  Make mempool optional in dm_split_lvm_name().
+
+Version 1.02.32 - 21st May 2009
+===============================
+  Only generate libdevmapper.a when configured to link statically.
+  Export dm_tree_node_size_changed() from libdevmapper.
+  Propagate the table size_changed property up the dm device tree.
+  Detect failure to free memory pools when releasing the library.
+  Fix segfault when getopt processes dmsetup -U, -G and -M options.
+
+Version 1.02.31 - 3rd March 2009
+================================
+  If kernel supports only one dm major number, use in place of any supplied.
+
+Version 1.02.30 - 26th January 2009
+====================================
+  Add "all" field to reports expanding to all fields of report type.
+  Enforce device name length and character limitations in libdm.
+  Replace _dm_snprintf with EMIT_PARAMS macro for creating target lines.
+
+Version 1.02.29 - 10th November 2008
+====================================
+  Merge device-mapper into the LVM2 tree.
+  Split out dm-logging.h from log.h.
+  Use lvm-types.h.
+  Add usrsbindir to configure.
 
 Version 1.02.28 - 18th September 2008
 =====================================

configure.in

@@ -1,6 +1,6 @@
 ###############################################################################
 ## Copyright (C) 2000-2004 Sistina Software, Inc. All rights reserved.
-## Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
+## Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
 ##
 ## This copyrighted material is made available to anyone wishing to use,
 ## modify, copy, or redistribute it subject to the terms and conditions
@@ -28,6 +28,7 @@ AC_CANONICAL_TARGET([])
 
 case "$host_os" in
 	linux*)
+		CFLAGS="$CFLAGS"
 		COPTIMISE_FLAG="-O2"
 		CLDFLAGS="$CLDFLAGS -Wl,--version-script,.export.sym"
 		CLDWHOLEARCHIVE="-Wl,-whole-archive"
@@ -41,7 +42,7 @@ case "$host_os" in
 		SELINUX=yes
 		REALTIME=yes
 		CLUSTER=internal
-		FSADM=no
+		FSADM=yes
 		;;
 	darwin*)
 		CFLAGS="$CFLAGS -no-cpp-precomp -fno-common"
@@ -62,6 +63,7 @@ esac
 
 ################################################################################
 dnl -- Checks for programs.
+AC_PROG_SED
 AC_PROG_AWK
 AC_PROG_CC
 
@@ -127,6 +129,15 @@ AC_FUNC_STAT
 AC_FUNC_STRTOD
 AC_FUNC_VPRINTF
 
+################################################################################
+dnl -- Enables statically-linked tools
+AC_MSG_CHECKING(whether to use static linking)
+AC_ARG_ENABLE(static_link,
+  [  --enable-static_link    Use this to link the tools to their libraries
+                          statically.  Default is dynamic linking],
+  STATIC_LINK=$enableval, STATIC_LINK=no)
+AC_MSG_RESULT($STATIC_LINK)
+
 ################################################################################
 dnl -- Prefix is /usr by default, the exec_prefix default is setup later
 AC_PREFIX_DEFAULT(/usr)
@@ -158,6 +169,33 @@ if test x$GROUP != x; then
 	GROUP="-g $GROUP"
 fi
 
+################################################################################
+dnl -- Setup device node ownership
+AC_MSG_CHECKING(device node uid)
+
+AC_ARG_WITH(device-uid,
+  [  --with-device-uid=UID   Set the owner used for new device nodes [[UID=0]] ],
+  [ DM_DEVICE_UID="$withval" ], [ DM_DEVICE_UID="0" ] )
+AC_MSG_RESULT($DM_DEVICE_UID)
+
+################################################################################
+dnl -- Setup device group ownership
+AC_MSG_CHECKING(device node gid)
+
+AC_ARG_WITH(device-gid,
+  [  --with-device-gid=UID   Set the group used for new device nodes [[GID=0]] ],
+  [ DM_DEVICE_GID="$withval" ], [ DM_DEVICE_GID="0" ] )
+AC_MSG_RESULT($DM_DEVICE_GID)
+
+################################################################################
+dnl -- Setup device mode
+AC_MSG_CHECKING(device node mode)
+
+AC_ARG_WITH(device-mode,
+  [  --with-device-mode=MODE Set the mode used for new device nodes [[MODE=0600]] ],
+  [ DM_DEVICE_MODE="$withval" ], [ DM_DEVICE_MODE="0600" ] )
+AC_MSG_RESULT($DM_DEVICE_MODE)
+
 ################################################################################
 dnl -- LVM1 tool fallback option
 AC_MSG_CHECKING(whether to enable lvm1 fallback)
@@ -287,7 +325,7 @@ AC_MSG_RESULT($REALTIME)
 dnl -- Build cluster LVM daemon
 AC_MSG_CHECKING(whether to build cluster LVM daemon)
 AC_ARG_WITH(clvmd,
-  [  --with-clvmd=TYPE       Build cluster LVM Daemon: cman/gulm/none/all
+  [  --with-clvmd=TYPE       Build cluster LVM Daemon: cman/gulm/corosync/none/all
                           [TYPE=none] ],
   [ CLVMD="$withval" ],
   [ CLVMD="none" ])
@@ -301,6 +339,19 @@ if  test x$CLVMD != xnone && test x$CLUSTER = xnone; then
 	CLUSTER=internal
 fi
 
+dnl -- Look for corosync libraries if required.
+if [[ "x$CLVMD" = xcorosync -o "x$CLVMD" = xall ]]; then
+	PKG_CHECK_MODULES(QUORUM, libquorum, [],
+		[AC_MSG_RESULT([no pkg for quorum library, using -lquorum]);
+		QUORUM_LIBS="-lquorum"])
+	PKG_CHECK_MODULES(CONFDB, libconfdb, [],
+		[AC_MSG_RESULT([no pkg for confdb library, using -lconfdb]);
+		CONFDB_LIBS="-lconfdb"])
+	PKG_CHECK_MODULES(CPG, libcpg, [],
+		[AC_MSG_RESULT([no pkg for libcpg library, using -lcpg]);
+		CPG_LIBS="-lcpg"])
+fi
+
 ################################################################################
 dnl -- Enable debugging
 AC_MSG_CHECKING(whether to enable debugging)
@@ -343,14 +394,24 @@ fi
 ################################################################################
 dnl -- Disable devmapper
 AC_MSG_CHECKING(whether to use device-mapper)
-AC_ARG_ENABLE(devmapper, [  --disable-devmapper     Disable device-mapper interaction],
+AC_ARG_ENABLE(devmapper, [  --disable-devmapper     Disable LVM2 device-mapper interaction],
 DEVMAPPER=$enableval)
 AC_MSG_RESULT($DEVMAPPER)
 
 if test x$DEVMAPPER = xyes; then
-	AC_DEFINE([DEVMAPPER_SUPPORT], 1, [Define to 1 to enable device-mapper interaction.])
+	AC_DEFINE([DEVMAPPER_SUPPORT], 1, [Define to 1 to enable LVM2 device-mapper interaction.])
 fi
 
+################################################################################
+dnl -- Compatibility mode
+AC_ARG_ENABLE(compat,   [  --enable-compat         Enable support for old device-mapper versions],
+  DM_COMPAT=$enableval, DM_COMPAT=no)
+
+################################################################################
+dnl -- Disable ioctl
+AC_ARG_ENABLE(ioctl,   [  --disable-driver        Disable calls to device-mapper in the kernel],
+  DM_IOCTLS=$enableval)
+
 ################################################################################
 dnl -- Disable O_DIRECT
 AC_MSG_CHECKING(whether to enable O_DIRECT)
@@ -362,6 +423,18 @@ if test x$ODIRECT = xyes; then
 	AC_DEFINE([O_DIRECT_SUPPORT], 1, [Define to 1 to enable O_DIRECT support.])
 fi
 
+################################################################################
+dnl -- Enable liblvm2app.so
+AC_MSG_CHECKING(whether to build liblvm2app.so application library)
+AC_ARG_ENABLE(applib,
+  [  --enable-applib         Build application library],
+  APPLIB=$enableval, APPLIB=no)
+AC_MSG_RESULT($APPLIB)
+AC_SUBST([LVM2APP_LIB])
+test x$APPLIB = xyes \
+  && LVM2APP_LIB=-llvm2app \
+  || LVM2APP_LIB=
+
 ################################################################################
 dnl -- Enable cmdlib
 AC_MSG_CHECKING(whether to compile liblvm2cmd.so)
@@ -373,6 +446,10 @@ test x$CMDLIB = xyes \
   && LVM2CMD_LIB=-llvm2cmd \
   || LVM2CMD_LIB=
 
+################################################################################
+dnl -- Enable pkg-config
+AC_ARG_ENABLE(pkgconfig,   [  --enable-pkgconfig      Install pkgconfig support],
+  PKGCONFIG=$enableval, PKGCONFIG=no)
 
 ################################################################################
 dnl -- Enable fsadm
@@ -388,6 +465,8 @@ AC_ARG_ENABLE(dmeventd, [  --enable-dmeventd       Enable the device-mapper even
 DMEVENTD=$enableval)
 AC_MSG_RESULT($DMEVENTD)
 
+BUILD_DMEVENTD=$DMEVENTD
+
 dnl -- dmeventd currently requires internal mirror support
 if test x$DMEVENTD = xyes; then
    if test x$MIRRORS != xinternal; then
@@ -405,6 +484,20 @@ fi
 if test x$DMEVENTD = xyes; then
 	AC_DEFINE([DMEVENTD], 1, [Define to 1 to enable the device-mapper event daemon.])
 fi
+
+################################################################################
+dnl -- getline included in recent libc
+
+AC_CHECK_LIB(c, getline, AC_DEFINE([HAVE_GETLINE], 1,
+  [Define to 1 if getline is available.]))
+
+################################################################################
+dnl -- canonicalize_file_name included in recent libc
+
+AC_CHECK_LIB(c, canonicalize_file_name,
+  AC_DEFINE([HAVE_CANONICALIZE_FILE_NAME], 1,
+    [Define to 1 if canonicalize_file_name is available.]))
+
 ################################################################################
 dnl -- Clear default exec_prefix - install into /sbin rather than /usr/sbin
 if [[ "x$exec_prefix" = xNONE -a "x$prefix" = xNONE ]];
@@ -414,7 +507,7 @@ fi;
 ################################################################################
 dnl -- Check for termcap (Shamelessly copied from parted 1.4.17)
 if test x$READLINE != xno; then
-	AC_SEARCH_LIBS([tgetent], [ncurses curses termcap termlib],
+	AC_SEARCH_LIBS([tgetent], [tinfo ncurses curses termcap termlib],
 	  [tg_found=yes], [tg_found=no])
 	test x$READLINE:$tg_found = xyes:no &&
 	  AC_MSG_ERROR(
@@ -450,15 +543,6 @@ Features cannot be 'shared' when building statically
 )
 fi
 
-################################################################################
-dnl -- Enables statically-linked tools
-AC_MSG_CHECKING(whether to use static linking)
-AC_ARG_ENABLE(static_link,
-  [  --enable-static_link    Use this to link the tools to their libraries
-                          statically.  Default is dynamic linking],
-  STATIC_LINK=$enableval, STATIC_LINK=no)
-AC_MSG_RESULT($STATIC_LINK)
-
 ################################################################################
 dnl -- Disable selinux
 AC_MSG_CHECKING(whether to enable selinux support)
@@ -545,6 +629,7 @@ AC_ARG_ENABLE(nls, [  --enable-nls            Enable Native Language Support],
 AC_MSG_RESULT($INTL)
 
 if test x$INTL = xyes; then
+# FIXME - Move this - can be device-mapper too
 	INTL_PACKAGE="lvm2"
 	AC_PATH_PROG(MSGFMT, msgfmt)
 	if [[ "x$MSGFMT" == x ]];
@@ -570,16 +655,15 @@ AC_ARG_WITH(staticdir,
 	    [ STATICDIR="$withval" ],
 	    [ STATICDIR='${exec_prefix}/sbin' ])
 
-AC_ARG_WITH(dmdir,
-	    [  --with-dmdir=DIR        Build against device-mapper source tree in DIR],
-	    [ DMDIR="$withval" CPPFLAGS="$CPPFLAGS -I$DMDIR/include"],
-	    [ DMDIR= ])
+AC_ARG_WITH(usrlibdir,
+	    [  --with-usrlibdir=DIR],
+	    [ usrlibdir="$withval"],
+	    [ usrlibdir='${prefix}/lib' ])
 
-# Convert a relative dir name to absolute.
-case $DMDIR in
-  /*) ;;
-  *) DMDIR="`pwd`/$DMDIR" ;;
-esac
+AC_ARG_WITH(usrsbindir,
+	    [  --with-usrsbindir=DIR],
+	    [ usrsbindir="$withval"],
+	    [ usrsbindir='${prefix}/sbin' ])
 
 ################################################################################
 dnl -- Ensure additional headers required
@@ -608,8 +692,6 @@ if test x$INTL = xyes; then
 	AC_CHECK_HEADERS(libintl.h,,AC_MSG_ERROR(bailing out))
 fi
 
-AC_CHECK_HEADERS(libdevmapper.h,,AC_MSG_ERROR(bailing out))
-
 if test x$HAVE_SELINUX = xyes; then
 	AC_CHECK_HEADERS(selinux/selinux.h,,AC_MSG_ERROR(bailing out))
 fi
@@ -622,9 +704,62 @@ if test x$MODPROBE_CMD != x; then
 fi
 
 ################################################################################
-LVM_VERSION="\"`cat VERSION 2>/dev/null || echo Unknown`\""
+dnl -- dmeventd pidfile and executable path
+AH_TEMPLATE(DMEVENTD_PIDFILE, [Path to dmeventd pidfile.])
+if test "$BUILD_DMEVENTD" = yes; then
+	AC_ARG_WITH(dmeventd-pidfile,
+		    [  --with-dmeventd-pidfile=PATH    dmeventd pidfile [[/var/run/dmeventd.pid]] ],
+		    [ AC_DEFINE_UNQUOTED(DMEVENTD_PIDFILE,"$withval") ],
+		    [ AC_DEFINE_UNQUOTED(DMEVENTD_PIDFILE,"/var/run/dmeventd.pid") ])
+fi
+
+AH_TEMPLATE(DMEVENTD_PATH, [Path to dmeventd binary.])
+if test "$BUILD_DMEVENTD" = yes; then
+        dmeventd_prefix="$exec_prefix"
+        if test "x$dmeventd_prefix" = "xNONE"; then
+                dmeventd_prefix="$prefix"
+        fi
+        if test "x$dmeventd_prefix" = "xNONE"; then
+                dmeventd_prefix=""
+        fi
+	AC_ARG_WITH(dmeventd-path,
+		    [  --with-dmeventd-path=PATH       dmeventd path [[${exec_prefix}/sbin/dmeventd]] ],
+		    [ AC_DEFINE_UNQUOTED(DMEVENTD_PATH,"$withval") ],
+		    [ AC_DEFINE_UNQUOTED(DMEVENTD_PATH,"$dmeventd_prefix/sbin/dmeventd") ])
+fi
 
 ################################################################################
+dnl -- which kernel interface to use (ioctl only)
+AC_MSG_CHECKING(for kernel interface choice)
+AC_ARG_WITH(interface,
+  [  --with-interface=IFACE  Choose kernel interface (ioctl) [[ioctl]] ],
+  [ interface="$withval" ],
+  [ interface=ioctl ])
+if [[ "x$interface" != xioctl ]];
+then
+  AC_MSG_ERROR(--with-interface=ioctl required. fs no longer supported.)
+fi
+AC_MSG_RESULT($interface)
+
+################################################################################
+DM_LIB_VERSION="\"`cat VERSION_DM 2>/dev/null || echo Unknown`\""
+AC_DEFINE_UNQUOTED(DM_LIB_VERSION, $DM_LIB_VERSION, [Library version])
+
+DM_LIB_PATCHLEVEL=`cat VERSION_DM | $AWK -F '[[-. ]]' '{printf "%s.%s.%s",$1,$2,$3}'`
+
+LVM_VERSION="\"`cat VERSION 2>/dev/null || echo Unknown`\""
+
+VER=`cat VERSION`
+LVM_RELEASE_DATE="\"`echo $VER | $SED 's/.*(//;s/).*//'`\""
+VER=`echo "$VER" | $AWK '{print $1}'`
+LVM_RELEASE="\"`echo "$VER" | $AWK -F '-' '{print $2}'`\""
+VER=`echo "$VER" | $AWK -F '-' '{print $1}'`
+LVM_MAJOR=`echo "$VER" | $AWK -F '.' '{print $1}'`
+LVM_MINOR=`echo "$VER" | $AWK -F '.' '{print $2}'`
+LVM_PATCHLEVEL=`echo "$VER" | $AWK -F '.' '{print $3}'`
+
+################################################################################
+AC_SUBST(APPLIB)
 AC_SUBST(BUILD_DMEVENTD)
 AC_SUBST(CFLAGS)
 AC_SUBST(CFLOW_CMD)
@@ -634,12 +769,15 @@ AC_SUBST(CLDWHOLEARCHIVE)
 AC_SUBST(CLUSTER)
 AC_SUBST(CLVMD)
 AC_SUBST(CMDLIB)
+AC_SUBST(CONFDB_CFLAGS)
+AC_SUBST(CONFDB_LIBS)
+AC_SUBST(CONFDIR)
 AC_SUBST(COPTIMISE_FLAG)
+AC_SUBST(CPG_CFLAGS)
+AC_SUBST(CPG_LIBS)
 AC_SUBST(CSCOPE_CMD)
 AC_SUBST(DEBUG)
 AC_SUBST(DEVMAPPER)
-AC_SUBST(DMDIR)
-# FIXME: rename to LVM_USE_DMEVENTD
 AC_SUBST(DMEVENTD)
 AC_SUBST(DM_COMPAT)
 AC_SUBST(DM_DEVICE_GID)
@@ -647,6 +785,7 @@ AC_SUBST(DM_DEVICE_MODE)
 AC_SUBST(DM_DEVICE_UID)
 AC_SUBST(DM_IOCTLS)
 AC_SUBST(DM_LIB_VERSION)
+AC_SUBST(DM_LIB_PATCHLEVEL)
 AC_SUBST(FSADM)
 AC_SUBST(GROUP)
 AC_SUBST(HAVE_LIBDL)
@@ -661,18 +800,30 @@ AC_SUBST(LIB_SUFFIX)
 AC_SUBST(LOCALEDIR)
 AC_SUBST(LVM1)
 AC_SUBST(LVM1_FALLBACK)
-# FIXME: rename to LVM_CONF_DIR
-AC_SUBST(CONFDIR)
 AC_SUBST(LVM_VERSION)
+AC_SUBST(LVM_MAJOR)
+AC_SUBST(LVM_MINOR)
+AC_SUBST(LVM_PATCHLEVEL)
+AC_SUBST(LVM_RELEASE)
+AC_SUBST(LVM_RELEASE_DATE)
 AC_SUBST(MIRRORS)
 AC_SUBST(MSGFMT)
 AC_SUBST(OWNER)
 AC_SUBST(PKGCONFIG)
 AC_SUBST(POOL)
+AC_SUBST(QUORUM_CFLAGS)
+AC_SUBST(QUORUM_LIBS)
 AC_SUBST(SNAPSHOTS)
 AC_SUBST(STATICDIR)
 AC_SUBST(STATIC_LINK)
 AC_SUBST([LIB_PTHREAD])
+AC_SUBST(interface)
+AC_SUBST(kerneldir)
+AC_SUBST(missingkernel)
+AC_SUBST(kernelvsn)
+AC_SUBST(tmpdir)
+AC_SUBST(usrlibdir)
+AC_SUBST(usrsbindir)
 
 ################################################################################
 dnl -- First and last lines should not contain files to generate in order to
@@ -680,36 +831,35 @@ dnl -- keep utility scripts running properly
 AC_CONFIG_FILES([
 Makefile
 make.tmpl
-include/Makefile
-lib/Makefile
-man/Makefile
-po/Makefile
-dmeventd/Makefile
 daemons/Makefile
 daemons/clvmd/Makefile
-dmeventd/mirror/Makefile
-dmeventd/snapshot/Makefile
+daemons/dmeventd/Makefile
+daemons/dmeventd/libdevmapper-event.pc
+daemons/dmeventd/plugins/Makefile
+daemons/dmeventd/plugins/mirror/Makefile
+daemons/dmeventd/plugins/snapshot/Makefile
 doc/Makefile
+include/Makefile
+lib/Makefile
 lib/format1/Makefile
 lib/format_pool/Makefile
 lib/locking/Makefile
 lib/mirror/Makefile
+lib/misc/lvm-version.h
 lib/snapshot/Makefile
-test/Makefile
+libdm/Makefile
+libdm/libdevmapper.pc
+liblvm/Makefile
+man/Makefile
+po/Makefile
+scripts/clvmd_init_red_hat
 scripts/Makefile
+test/Makefile
+test/api/Makefile
 tools/Makefile
-tools/version.h
 ])
 AC_OUTPUT
 
 if test x$ODIRECT != xyes; then
   AC_MSG_WARN(Warning: O_DIRECT disabled: low-memory pvmove may lock up)
 fi
-
-if test x$FSADM == xyes; then
-  AC_MSG_WARN(fsadm support is untested)
-fi
-
-if test x$DMEVENTD == xyes; then
-  AC_MSG_WARN(dmeventd support is untested)
-fi

daemons/Makefile.in

@@ -15,9 +15,18 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 
+.PHONY: dmeventd clvmd
+
 ifneq ("@CLVMD@", "none")
   SUBDIRS = clvmd
 endif
 
+ifeq ("@DMEVENTD@", "yes")
+  SUBDIRS += dmeventd
+endif
+
 include $(top_srcdir)/make.tmpl
 
+ifeq ("@DMEVENTD@", "yes")
+device-mapper: dmeventd.device-mapper
+endif

daemons/clogd/Makefile

@@ -0,0 +1,77 @@
+###############################################################################
+###############################################################################
+##
+##  Copyright (C) 2009 Red Hat, Inc.  All rights reserved.
+##
+##  This copyrighted material is made available to anyone wishing to use,
+##  modify, copy, or redistribute it subject to the terms and conditions
+##  of the GNU General Public License v.2.
+##
+###############################################################################
+###############################################################################
+
+SOURCES = clogd.c cluster.c functions.c link_mon.c local.c logging.c
+
+TARGET = $(shell if [ ! -e /usr/include/linux/dm-clog-tfr.h ]; then \
+		echo 'no_clogd_kernel_headers'; \
+	elif [ ! -e /usr/include/linux/ext2_fs.h ]; then \
+		echo 'no_e2fsprogs_devel'; \
+	elif [ ! -e /usr/include/openais/saCkpt.h ]; then \
+		echo 'no_openais_devel'; \
+	else \
+		echo 'clogd'; \
+	fi)
+
+ifneq ($(DEBUG), )
+CFLAGS += -DDEBUG
+endif
+
+ifneq ($(MEMB), )
+CFLAGS += -DMEMB
+endif
+
+ifneq ($(CKPT), )
+CFLAGS += -DCKPT
+endif
+
+ifneq ($(RESEND), )
+CFLAGS += -DRESEND
+endif
+
+CFLAGS += -g
+
+LDFLAGS += $(shell if [ -e /usr/lib64/openais ]; then \
+		echo '-L/usr/lib64/openais -L/usr/lib64'; \
+	else \
+		echo '-L/usr/lib/openais -L/usr/lib'; \
+	fi)
+LDFLAGS += -lcpg -lSaCkpt -lext2fs
+
+all: ${TARGET}
+
+clogd: ${SOURCES}
+	${CC} ${CFLAGS} -o $@ $^ ${LDFLAGS}
+
+no_clogd_kernel_headers:
+	echo "Unable to find clogd kernel headers"
+	exit 1
+
+no_e2fsprogs_devel:
+	echo "Unable to find ext2fs kernel headers."
+	echo "Install 'e2fsprogs-devel'?"
+	exit 1
+
+no_openais_devel:
+	echo "Unable to find openAIS headers."
+	echo "http://sources.redhat.com/cluster/wiki/"
+	exit 1
+
+install: clogd
+	install -d /usr/sbin
+	install clogd /usr/sbin
+
+uninstall:
+	rm /usr/sbin/clogd
+
+clean:
+	rm -f *.o clogd *~

daemons/clogd/clogd.c

@@ -0,0 +1,265 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+#include <sched.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <linux/types.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <linux/dm-clog-tfr.h>
+#include <linux/dm-ioctl.h>
+
+#include "functions.h"
+#include "local.h"
+#include "cluster.h"
+#include "common.h"
+#include "logging.h"
+#include "link_mon.h"
+
+static int exit_now = 0;
+static sigset_t signal_mask;
+static int signal_received;
+
+static void process_signals(void);
+static void daemonize(void);
+static void init_all(void);
+static void cleanup_all(void);
+
+int main(int argc, char *argv[])
+{
+	daemonize();
+
+	init_all();
+
+	/* Parent can now exit, we're ready to handle requests */
+	kill(getppid(), SIGTERM);
+
+	LOG_PRINT("Starting clogd:");
+	LOG_PRINT(" Built: "__DATE__" "__TIME__"\n");
+	LOG_DBG(" Compiled with debugging.");
+
+	while (!exit_now) {
+		links_monitor();
+
+		links_issue_callbacks();
+
+		process_signals();
+	}
+	exit(EXIT_SUCCESS);
+}
+
+/*
+ * parent_exit_handler: exit the parent
+ * @sig: the signal
+ *
+ */
+static void parent_exit_handler(int sig)
+{
+	exit_now = 1;
+}
+
+/*
+ * create_lockfile - create and lock a lock file
+ * @lockfile: location of lock file
+ *
+ * Returns: 0 on success, -1 otherwise
+ */
+static int create_lockfile(char *lockfile)
+{
+	int fd;
+	struct flock lock;
+	char buffer[50];
+
+	if((fd = open(lockfile, O_CREAT | O_WRONLY,
+		      (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) < 0)
+		return -errno;
+
+	lock.l_type = F_WRLCK;
+	lock.l_start = 0;
+	lock.l_whence = SEEK_SET;
+	lock.l_len = 0;
+
+	if (fcntl(fd, F_SETLK, &lock) < 0) {
+		close(fd);
+		return -errno;
+	}
+
+	if (ftruncate(fd, 0) < 0) {
+		close(fd);
+		return -errno;
+	}
+
+	sprintf(buffer, "%d\n", getpid());
+
+	if(write(fd, buffer, strlen(buffer)) < strlen(buffer)){
+		close(fd);
+		unlink(lockfile);
+		return -errno;
+	}
+
+	return 0;
+}
+
+static void sig_handler(int sig)
+{
+	sigaddset(&signal_mask, sig);
+	++signal_received;
+}
+
+static void process_signal(int sig){
+	int r = 0;
+
+	switch(sig) {
+	case SIGINT:
+	case SIGQUIT:
+	case SIGTERM:
+	case SIGHUP:
+		r += log_status();
+		break;
+	case SIGUSR1:
+	case SIGUSR2:
+		log_debug();
+		/*local_debug();*/
+		cluster_debug();
+		return;
+	default:
+		LOG_PRINT("Unknown signal received... ignoring");
+		return;
+	}
+
+	if (!r) {
+		LOG_DBG("No current cluster logs... safe to exit.");
+		cleanup_all();
+		exit(EXIT_SUCCESS);
+	}
+
+	LOG_ERROR("Cluster logs exist.  Refusing to exit.");
+}
+
+static void process_signals(void)
+{
+	int x;
+
+	if (!signal_received)
+		return;
+
+	signal_received = 0;
+
+	for (x = 1; x < _NSIG; x++) {
+		if (sigismember(&signal_mask, x)) {
+			sigdelset(&signal_mask, x);
+			process_signal(x);
+		}
+	}
+}
+
+/*
+ * daemonize
+ *
+ * Performs the steps necessary to become a daemon.
+ */
+static void daemonize(void)
+{
+	int pid;
+	int status;
+
+	signal(SIGTERM, &parent_exit_handler);
+
+	pid = fork();
+
+	if (pid < 0) {
+		LOG_ERROR("Unable to fork()");
+		exit(EXIT_FAILURE);
+	}
+
+	if (pid) {
+		/* Parent waits here for child to get going */
+		while (!waitpid(pid, &status, WNOHANG) && !exit_now);
+		if (exit_now)
+			exit(EXIT_SUCCESS);
+
+		switch (WEXITSTATUS(status)) {
+		case EXIT_LOCKFILE:
+			LOG_ERROR("Failed to create lockfile");
+			LOG_ERROR("Process already running?");
+			break;
+		case EXIT_KERNEL_TFR_SOCKET:
+			LOG_ERROR("Unable to create netlink socket");
+			break;
+		case EXIT_KERNEL_TFR_BIND:
+			LOG_ERROR("Unable to bind to netlink socket");
+			break;
+		case EXIT_KERNEL_TFR_SETSOCKOPT:
+			LOG_ERROR("Unable to setsockopt on netlink socket");
+			break;
+		case EXIT_CLUSTER_CKPT_INIT:
+			LOG_ERROR("Unable to initialize checkpoint service");
+			LOG_ERROR("Has the cluster infrastructure been started?");
+			break;
+		case EXIT_FAILURE:
+			LOG_ERROR("Failed to start: Generic error");
+			break;
+		default:
+			LOG_ERROR("Failed to start: Unknown error");
+			break;
+		}
+		exit(EXIT_FAILURE);
+	}
+
+	setsid();
+	chdir("/");
+	umask(0);
+
+	close(0); close(1); close(2);
+	open("/dev/null", O_RDONLY); /* reopen stdin */
+	open("/dev/null", O_WRONLY); /* reopen stdout */
+	open("/dev/null", O_WRONLY); /* reopen stderr */
+
+	LOG_OPEN("clogd", LOG_PID, LOG_DAEMON);
+
+	if (create_lockfile("/var/run/clogd.pid"))
+		exit(EXIT_LOCKFILE);
+
+	signal(SIGINT, &sig_handler);
+	signal(SIGQUIT, &sig_handler);
+	signal(SIGTERM, &sig_handler);
+	signal(SIGHUP, &sig_handler);
+	signal(SIGPIPE, SIG_IGN);
+	signal(SIGUSR1, &sig_handler);
+	signal(SIGUSR2, &sig_handler);
+	sigemptyset(&signal_mask);
+	signal_received = 0;
+}
+
+/*
+ * init_all
+ *
+ * Initialize modules.  Exit on failure.
+ */
+static void init_all(void)
+{
+	int r;
+
+	if ((r = init_local()) ||
+	    (r = init_cluster())) {
+		exit(r);
+	}
+}
+
+/*
+ * cleanup_all
+ *
+ * Clean up before exiting
+ */
+static void cleanup_all(void)
+{
+	cleanup_local();
+	cleanup_cluster();
+}

daemons/clogd/cluster.h

@@ -0,0 +1,13 @@
+#ifndef __CLUSTER_LOG_CLUSTER_DOT_H__
+#define __CLUSTER_LOG_CLUSTER_DOT_H__
+
+int init_cluster(void);
+void cleanup_cluster(void);
+void cluster_debug(void);
+
+int create_cluster_cpg(char *str);
+int destroy_cluster_cpg(char *str);
+
+int cluster_send(struct clog_tfr *tfr);
+
+#endif /* __CLUSTER_LOG_CLUSTER_DOT_H__ */

daemons/clogd/common.h

@@ -0,0 +1,40 @@
+#ifndef __CLUSTER_LOG_COMMON_DOT_H__
+#define __CLUSTER_LOG_COMMON_DOT_H__
+
+/*
+#define EXIT_SUCCESS 0
+#define EXIT_FAILURE 1
+*/
+
+#define EXIT_LOCKFILE              2
+
+#define EXIT_KERNEL_TFR_SOCKET     3 /* Failed netlink socket create */
+#define EXIT_KERNEL_TFR_BIND       4
+#define EXIT_KERNEL_TFR_SETSOCKOPT 5
+
+#define EXIT_CLUSTER_CKPT_INIT     6 /* Failed to init checkpoint */
+
+#define EXIT_QUEUE_NOMEM           7
+
+/* Located in dm-clog-tfr.h
+#define RQ_TYPE(x) \
+	((x) == DM_CLOG_CTR) ? "DM_CLOG_CTR" : \
+	((x) == DM_CLOG_DTR) ? "DM_CLOG_DTR" : \
+	((x) == DM_CLOG_PRESUSPEND) ? "DM_CLOG_PRESUSPEND" : \
+	((x) == DM_CLOG_POSTSUSPEND) ? "DM_CLOG_POSTSUSPEND" : \
+	((x) == DM_CLOG_RESUME) ? "DM_CLOG_RESUME" : \
+	((x) == DM_CLOG_GET_REGION_SIZE) ? "DM_CLOG_GET_REGION_SIZE" : \
+	((x) == DM_CLOG_IS_CLEAN) ? "DM_CLOG_IS_CLEAN" : \
+	((x) == DM_CLOG_IN_SYNC) ? "DM_CLOG_IN_SYNC" : \
+	((x) == DM_CLOG_FLUSH) ? "DM_CLOG_FLUSH" : \
+	((x) == DM_CLOG_MARK_REGION) ? "DM_CLOG_MARK_REGION" : \
+	((x) == DM_CLOG_CLEAR_REGION) ? "DM_CLOG_CLEAR_REGION" : \
+	((x) == DM_CLOG_GET_RESYNC_WORK) ? "DM_CLOG_GET_RESYNC_WORK" : \
+	((x) == DM_CLOG_SET_REGION_SYNC) ? "DM_CLOG_SET_REGION_SYNC" : \
+	((x) == DM_CLOG_GET_SYNC_COUNT) ? "DM_CLOG_GET_SYNC_COUNT" : \
+	((x) == DM_CLOG_STATUS_INFO) ? "DM_CLOG_STATUS_INFO" : \
+	((x) == DM_CLOG_STATUS_TABLE) ? "DM_CLOG_STATUS_TABLE" : \
+	NULL
+*/
+
+#endif /* __CLUSTER_LOG_COMMON_DOT_H__ */

daemons/clogd/functions.h

@@ -0,0 +1,20 @@
+#ifndef __CLOG_FUNCTIONS_DOT_H__
+#define __CLOG_FUNCTIONS_DOT_H__
+
+#include <linux/dm-clog-tfr.h>
+
+#define LOG_RESUMED   1
+#define LOG_SUSPENDED 2
+
+int local_resume(struct clog_tfr *tfr);
+int cluster_postsuspend(char *);
+
+int do_request(struct clog_tfr *tfr, int server);
+int push_state(const char *uuid, const char *which, char **buf, uint32_t debug_who);
+int pull_state(const char *uuid, const char *which, char *buf, int size);
+
+int log_get_state(struct clog_tfr *tfr);
+int log_status(void);
+void log_debug(void);
+
+#endif /* __CLOG_FUNCTIONS_DOT_H__ */

daemons/clogd/link_mon.c

@@ -0,0 +1,138 @@
+#include <stdlib.h>
+#include <errno.h>
+#include <poll.h>
+
+#include "logging.h"
+
+struct link_callback {
+	int fd;
+	char *name;
+	void *data;
+	int (*callback)(void *data);
+
+	struct link_callback *next;
+};
+
+static int used_pfds = 0;
+static int free_pfds = 0;
+static struct pollfd *pfds = NULL;
+static struct link_callback *callbacks = NULL;
+
+int links_register(int fd, char *name, int (*callback)(void *data), void *data)
+{
+	int i;
+	struct link_callback *lc;
+
+	for (i = 0; i < used_pfds; i++) {
+		if (fd == pfds[i].fd) {
+			LOG_ERROR("links_register: Duplicate file descriptor");
+			return -EINVAL;
+		}
+	}
+
+	lc = malloc(sizeof(*lc));
+	if (!lc)
+		return -ENOMEM;
+
+	lc->fd = fd;
+	lc->name = name;
+	lc->data = data;
+	lc->callback = callback;
+
+	if (!free_pfds) {
+		struct pollfd *tmp;
+		tmp = realloc(pfds, sizeof(struct pollfd) * ((used_pfds*2) + 1));
+		if (!tmp) {
+			free(lc);
+			return -ENOMEM;
+		}
+		
+		pfds = tmp;
+		free_pfds = used_pfds + 1;
+	}
+
+	free_pfds--;
+	pfds[used_pfds].fd = fd;
+	pfds[used_pfds].events = POLLIN;
+	pfds[used_pfds].revents = 0;
+	used_pfds++;
+
+	lc->next = callbacks;
+	callbacks = lc;
+	LOG_DBG("Adding %s/%d", lc->name, lc->fd);
+	LOG_DBG(" used_pfds = %d, free_pfds = %d",
+		used_pfds, free_pfds);
+
+	return 0;
+}
+
+int links_unregister(int fd)
+{
+	int i;
+	struct link_callback *p, *c;
+
+	for (i = 0; i < used_pfds; i++)
+		if (fd == pfds[i].fd) {
+			/* entire struct is copied (overwritten) */
+			pfds[i] = pfds[used_pfds - 1];
+			used_pfds--;
+			free_pfds++;
+		}
+
+	for (p = NULL, c = callbacks; c; p = c, c = c->next)
+		if (fd == c->fd) {
+			LOG_DBG("Freeing up %s/%d", c->name, c->fd);
+			LOG_DBG(" used_pfds = %d, free_pfds = %d",
+				used_pfds, free_pfds);
+			if (p)
+				p->next = c->next;
+			else
+				callbacks = c->next;
+			free(c);
+			break;
+		}
+
+	return 0;
+}
+
+int links_monitor(void)
+{
+	int i, r;
+
+	for (i = 0; i < used_pfds; i++) {
+		pfds[i].revents = 0;
+	}
+
+	r = poll(pfds, used_pfds, -1);
+	if (r <= 0)
+		return r;
+
+	r = 0;
+	/* FIXME: handle POLLHUP */
+	for (i = 0; i < used_pfds; i++)
+		if (pfds[i].revents & POLLIN) {
+			LOG_DBG("Data ready on %d", pfds[i].fd);
+				
+			/* FIXME: Add this back return 1;*/
+			r++;
+		}
+
+	return r;
+}
+
+int links_issue_callbacks(void)
+{
+	int i;
+	struct link_callback *lc;
+
+	for (i = 0; i < used_pfds; i++)
+		if (pfds[i].revents & POLLIN)
+			for (lc = callbacks; lc; lc = lc->next)
+				if (pfds[i].fd == lc->fd) {
+					LOG_DBG("Issuing callback on %s/%d",
+						lc->name, lc->fd);
+					lc->callback(lc->data);
+					break;
+				}
+	return 0;
+}

daemons/clogd/link_mon.h

@@ -0,0 +1,9 @@
+#ifndef __LINK_MON_DOT_H__
+#define __LINK_MON_DOT_H__
+
+int links_register(int fd, char *name, int (*callback)(void *data), void *data);
+int links_unregister(int fd);
+int links_monitor(void);
+int links_issue_callbacks(void);
+
+#endif /* __LINK_MON_DOT_H__ */

daemons/clogd/list.h

@@ -0,0 +1,471 @@
+#ifndef _LINUX_LIST_H
+#define _LINUX_LIST_H
+
+/*
+ * These are non-NULL pointers that will result in page faults
+ * under normal circumstances, used to verify that nobody uses
+ * non-initialized list entries.
+ */
+#define LIST_POISON1  ((void *) 0x00100100)
+#define LIST_POISON2  ((void *) 0x00200200)
+
+/*
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+
+struct list_head {
+	struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+	struct list_head name = LIST_HEAD_INIT(name)
+
+#define INIT_LIST_HEAD(ptr) do { \
+	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add(struct list_head *new,
+			      struct list_head *prev,
+			      struct list_head *next)
+{
+	next->prev = new;
+	new->next = next;
+	new->prev = prev;
+	prev->next = new;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static inline void list_add(struct list_head *new, struct list_head *head)
+{
+	__list_add(new, head, head->next);
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static inline void list_add_tail(struct list_head *new, struct list_head *head)
+{
+	__list_add(new, head->prev, head);
+}
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_del(struct list_head * prev, struct list_head * next)
+{
+	next->prev = prev;
+	prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is
+ * in an undefined state.
+ */
+static inline void list_del(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+	entry->next = LIST_POISON1;
+	entry->prev = LIST_POISON2;
+}
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
+ */
+static inline void list_del_init(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+	INIT_LIST_HEAD(entry);
+}
+
+/**
+ * list_move - delete from one list and add as another's head
+ * @list: the entry to move
+ * @head: the head that will precede our entry
+ */
+static inline void list_move(struct list_head *list, struct list_head *head)
+{
+        __list_del(list->prev, list->next);
+        list_add(list, head);
+}
+
+/**
+ * list_move_tail - delete from one list and add as another's tail
+ * @list: the entry to move
+ * @head: the head that will follow our entry
+ */
+static inline void list_move_tail(struct list_head *list,
+				  struct list_head *head)
+{
+        __list_del(list->prev, list->next);
+        list_add_tail(list, head);
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static inline int list_empty(const struct list_head *head)
+{
+	return head->next == head;
+}
+
+/**
+ * list_empty_careful - tests whether a list is
+ * empty _and_ checks that no other CPU might be
+ * in the process of still modifying either member
+ *
+ * NOTE: using list_empty_careful() without synchronization
+ * can only be safe if the only activity that can happen
+ * to the list entry is list_del_init(). Eg. it cannot be used
+ * if another CPU could re-list_add() it.
+ *
+ * @head: the list to test.
+ */
+static inline int list_empty_careful(const struct list_head *head)
+{
+	struct list_head *next = head->next;
+	return (next == head) && (next == head->prev);
+}
+
+static inline void __list_splice(struct list_head *list,
+				 struct list_head *head)
+{
+	struct list_head *first = list->next;
+	struct list_head *last = list->prev;
+	struct list_head *at = head->next;
+
+	first->prev = head;
+	head->next = first;
+
+	last->next = at;
+	at->prev = last;
+}
+
+/**
+ * list_splice - join two lists
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static inline void list_splice(struct list_head *list, struct list_head *head)
+{
+	if (!list_empty(list))
+		__list_splice(list, head);
+}
+
+/**
+ * list_splice_init - join two lists and reinitialise the emptied list.
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ *
+ * The list at @list is reinitialised
+ */
+static inline void list_splice_init(struct list_head *list,
+				    struct list_head *head)
+{
+	if (!list_empty(list)) {
+		__list_splice(list, head);
+		INIT_LIST_HEAD(list);
+	}
+}
+
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+
+/**
+ * container_of - cast a member of a structure out to the containing structure
+ *
+ * @ptr:        the pointer to the member.
+ * @type:       the type of the container struct this is embedded in.
+ * @member:     the name of the member within the struct.
+ *
+ */
+#define container_of(ptr, type, member) ({                      \
+        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
+        (type *)( (char *)__mptr - offsetof(type,member) );})
+
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr:	the &struct list_head pointer.
+ * @type:	the type of the struct this is embedded in.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+	container_of(ptr, type, member)
+
+/**
+ * list_for_each	-	iterate over a list
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @head:	the head for your list.
+ */
+#define list_for_each(pos, head) \
+	for (pos = (head)->next; prefetch(pos->next), pos != (head); \
+        	pos = pos->next)
+
+/**
+ * __list_for_each	-	iterate over a list
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @head:	the head for your list.
+ *
+ * This variant differs from list_for_each() in that it's the
+ * simplest possible list iteration code, no prefetching is done.
+ * Use this for code that knows the list to be very short (empty
+ * or 1 entry) most of the time.
+ */
+#define __list_for_each(pos, head) \
+	for (pos = (head)->next; pos != (head); pos = pos->next)
+
+/**
+ * list_for_each_prev	-	iterate over a list backwards
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @head:	the head for your list.
+ */
+#define list_for_each_prev(pos, head) \
+	for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
+        	pos = pos->prev)
+
+/**
+ * list_for_each_safe	-	iterate over a list safe against removal of list entry
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @n:		another &struct list_head to use as temporary storage
+ * @head:	the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+	for (pos = (head)->next, n = pos->next; pos != (head); \
+		pos = n, n = pos->next)
+
+/**
+ * list_for_each_entry	-	iterate over list of given type
+ * @pos:	the type * to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry(pos, head, member)				\
+	for (pos = list_entry((head)->next, typeof(*pos), member);	\
+	     prefetch(pos->member.next), &pos->member != (head); 	\
+	     pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * @pos:	the type * to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_reverse(pos, head, member)			\
+	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
+	     prefetch(pos->member.prev), &pos->member != (head); 	\
+	     pos = list_entry(pos->member.prev, typeof(*pos), member))
+
+/**
+ * list_prepare_entry - prepare a pos entry for use as a start point in
+ *			list_for_each_entry_continue
+ * @pos:	the type * to use as a start point
+ * @head:	the head of the list
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_prepare_entry(pos, head, member) \
+	((pos) ? : list_entry(head, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_continue -	iterate over list of given type
+ *			continuing after existing point
+ * @pos:	the type * to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_continue(pos, head, member) 		\
+	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
+	     prefetch(pos->member.next), &pos->member != (head);	\
+	     pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @pos:	the type * to use as a loop counter.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe(pos, n, head, member)			\
+	for (pos = list_entry((head)->next, typeof(*pos), member),	\
+		n = list_entry(pos->member.next, typeof(*pos), member);	\
+	     &pos->member != (head); 					\
+	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+/*
+ * Double linked lists with a single pointer list head.
+ * Mostly useful for hash tables where the two pointer list head is
+ * too wasteful.
+ * You lose the ability to access the tail in O(1).
+ */
+
+struct hlist_head {
+	struct hlist_node *first;
+};
+
+struct hlist_node {
+	struct hlist_node *next, **pprev;
+};
+
+#define HLIST_HEAD_INIT { .first = NULL }
+#define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
+#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
+#define INIT_HLIST_NODE(ptr) ((ptr)->next = NULL, (ptr)->pprev = NULL)
+
+static inline int hlist_unhashed(const struct hlist_node *h)
+{
+	return !h->pprev;
+}
+
+static inline int hlist_empty(const struct hlist_head *h)
+{
+	return !h->first;
+}
+
+static inline void __hlist_del(struct hlist_node *n)
+{
+	struct hlist_node *next = n->next;
+	struct hlist_node **pprev = n->pprev;
+	*pprev = next;
+	if (next)
+		next->pprev = pprev;
+}
+
+static inline void hlist_del(struct hlist_node *n)
+{
+	__hlist_del(n);
+	n->next = LIST_POISON1;
+	n->pprev = LIST_POISON2;
+}
+
+static inline void hlist_del_init(struct hlist_node *n)
+{
+	if (n->pprev)  {
+		__hlist_del(n);
+		INIT_HLIST_NODE(n);
+	}
+}
+
+static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+{
+	struct hlist_node *first = h->first;
+	n->next = first;
+	if (first)
+		first->pprev = &n->next;
+	h->first = n;
+	n->pprev = &h->first;
+}
+
+/* next must be != NULL */
+static inline void hlist_add_before(struct hlist_node *n,
+					struct hlist_node *next)
+{
+	n->pprev = next->pprev;
+	n->next = next;
+	next->pprev = &n->next;
+	*(n->pprev) = n;
+}
+
+static inline void hlist_add_after(struct hlist_node *n,
+					struct hlist_node *next)
+{
+	next->next = n->next;
+	n->next = next;
+	next->pprev = &n->next;
+
+	if(next->next)
+		next->next->pprev  = &next->next;
+}
+
+#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
+
+#define hlist_for_each(pos, head) \
+	for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
+	     pos = pos->next)
+
+#define hlist_for_each_safe(pos, n, head) \
+	for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
+	     pos = n)
+
+/**
+ * hlist_for_each_entry	- iterate over list of given type
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry(tpos, pos, head, member)			 \
+	for (pos = (head)->first;					 \
+	     pos && ({ prefetch(pos->next); 1;}) &&			 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = pos->next)
+
+/**
+ * hlist_for_each_entry_continue - iterate over a hlist continuing after existing point
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_continue(tpos, pos, member)		 \
+	for (pos = (pos)->next;						 \
+	     pos && ({ prefetch(pos->next); 1;}) &&			 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = pos->next)
+
+/**
+ * hlist_for_each_entry_from - iterate over a hlist continuing from existing point
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_from(tpos, pos, member)			 \
+	for (; pos && ({ prefetch(pos->next); 1;}) &&			 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = pos->next)
+
+/**
+ * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @n:		another &struct hlist_node to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_safe(tpos, pos, n, head, member) 		 \
+	for (pos = (head)->first;					 \
+	     pos && ({ n = pos->next; 1; }) && 				 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = n)
+
+#endif

daemons/clogd/local.c

@@ -0,0 +1,379 @@
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/poll.h>
+#include <linux/connector.h>
+#include <linux/netlink.h>
+
+#include "linux/dm-clog-tfr.h"
+#include "functions.h"
+#include "cluster.h"
+#include "common.h"
+#include "logging.h"
+#include "link_mon.h"
+#include "local.h"
+
+static int cn_fd;  /* Connector (netlink) socket fd */
+static char recv_buf[2048];
+
+
+/* FIXME: merge this function with kernel_send_helper */
+static int kernel_ack(uint32_t seq, int error)
+{
+	int r;
+	unsigned char buf[sizeof(struct nlmsghdr) + sizeof(struct cn_msg)];
+	struct nlmsghdr *nlh = (struct nlmsghdr *)buf;
+	struct cn_msg *msg = NLMSG_DATA(nlh);
+
+	if (error < 0) {
+		LOG_ERROR("Programmer error: error codes must be positive");
+		return -EINVAL;
+	}
+
+	memset(buf, 0, sizeof(buf));
+
+	nlh->nlmsg_seq = 0;
+	nlh->nlmsg_pid = getpid();
+	nlh->nlmsg_type = NLMSG_DONE;
+	nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct cn_msg));
+	nlh->nlmsg_flags = 0;
+
+	msg->len = 0;
+	msg->id.idx = 0x4;
+	msg->id.val = 0x1;
+	msg->seq = seq;
+	msg->ack = error;
+
+	r = send(cn_fd, nlh, NLMSG_LENGTH(sizeof(struct cn_msg)), 0);
+	/* FIXME: do better error processing */
+	if (r <= 0)
+		return -EBADE;
+
+	return 0;
+}
+
+
+/*
+ * kernel_recv
+ * @tfr: the newly allocated request from kernel
+ *
+ * Read requests from the kernel and allocate space for the new request.
+ * If there is no request from the kernel, *tfr is NULL.
+ *
+ * This function is not thread safe due to returned stack pointer.  In fact,
+ * the returned pointer must not be in-use when this function is called again.
+ *
+ * Returns: 0 on success, -EXXX on error
+ */
+static int kernel_recv(struct clog_tfr **tfr)
+{
+	int r = 0;
+	int len;
+	struct cn_msg *msg;
+
+	*tfr = NULL;
+	memset(recv_buf, 0, sizeof(recv_buf));
+
+	len = recv(cn_fd, recv_buf, sizeof(recv_buf), 0);
+	if (len < 0) {
+		LOG_ERROR("Failed to recv message from kernel");
+		r = -errno;
+		goto fail;
+	}
+
+	switch (((struct nlmsghdr *)recv_buf)->nlmsg_type) {
+	case NLMSG_ERROR:
+		LOG_ERROR("Unable to recv message from kernel: NLMSG_ERROR");
+		r = -EBADE;
+		goto fail;
+	case NLMSG_DONE:
+		msg = (struct cn_msg *)NLMSG_DATA((struct nlmsghdr *)recv_buf);
+		len -= sizeof(struct nlmsghdr);
+
+		if (len < sizeof(struct cn_msg)) {
+			LOG_ERROR("Incomplete request from kernel received");
+			r = -EBADE;
+			goto fail;
+		}
+
+		if (msg->len > DM_CLOG_TFR_SIZE) {
+			LOG_ERROR("Not enough space to receive kernel request (%d/%d)",
+				  msg->len, DM_CLOG_TFR_SIZE);
+			r = -EBADE;
+			goto fail;
+		}
+
+		if (!msg->len)
+			LOG_ERROR("Zero length message received");
+
+		len -= sizeof(struct cn_msg);
+
+		if (len < msg->len)
+			LOG_ERROR("len = %d, msg->len = %d", len, msg->len);
+
+		msg->data[msg->len] = '\0'; /* Cleaner way to ensure this? */
+		*tfr = (struct clog_tfr *)msg->data;
+
+		if (!(*tfr)->request_type) {
+			LOG_DBG("Bad transmission, requesting resend [%u]", msg->seq);
+			r = -EAGAIN;
+
+			if (kernel_ack(msg->seq, EAGAIN)) {
+				LOG_ERROR("Failed to NACK kernel transmission [%u]",
+					  msg->seq);
+				r = -EBADE;
+			}
+		}
+		break;
+	default:
+		LOG_ERROR("Unknown nlmsg_type");
+		r = -EBADE;
+	}
+
+fail:
+	if (r)
+		*tfr = NULL;
+
+	return (r == -EAGAIN) ? 0 : r;
+}
+
+static int kernel_send_helper(void *data, int out_size)
+{
+	int r;
+	struct nlmsghdr *nlh;
+	struct cn_msg *msg;
+	unsigned char buf[2048];
+
+	memset(buf, 0, sizeof(buf));
+
+	nlh = (struct nlmsghdr *)buf;
+	nlh->nlmsg_seq = 0;  /* FIXME: Is this used? */
+	nlh->nlmsg_pid = getpid();
+	nlh->nlmsg_type = NLMSG_DONE;
+	nlh->nlmsg_len = NLMSG_LENGTH(out_size + sizeof(struct cn_msg));
+	nlh->nlmsg_flags = 0;
+
+	msg = NLMSG_DATA(nlh);
+	memcpy(msg->data, data, out_size);
+	msg->len = out_size;
+	msg->id.idx = 0x4;
+	msg->id.val = 0x1;
+	msg->seq = 0;
+
+	r = send(cn_fd, nlh, NLMSG_LENGTH(out_size + sizeof(struct cn_msg)), 0);
+	/* FIXME: do better error processing */
+	if (r <= 0)
+		return -EBADE;
+
+	return 0;
+}
+
+/*
+ * do_local_work
+ *
+ * Any processing errors are placed in the 'tfr'
+ * structure to be reported back to the kernel.
+ * It may be pointless for this function to
+ * return an int.
+ *
+ * Returns: 0 on success, -EXXX on failure
+ */
+static int do_local_work(void *data)
+{
+	int r;
+	struct clog_tfr *tfr = NULL;
+
+	r = kernel_recv(&tfr);
+	if (r)
+		return r;
+
+	if (!tfr)
+		return 0;
+
+	LOG_DBG("[%s]  Request from kernel received: [%s/%u]",
+		SHORT_UUID(tfr->uuid), RQ_TYPE(tfr->request_type),
+		tfr->seq);
+	switch (tfr->request_type) {
+	case DM_CLOG_CTR:
+	case DM_CLOG_DTR:
+	case DM_CLOG_IN_SYNC:
+	case DM_CLOG_GET_SYNC_COUNT:
+	case DM_CLOG_STATUS_INFO:
+	case DM_CLOG_STATUS_TABLE:
+	case DM_CLOG_PRESUSPEND:
+		/* We do not specify ourselves as server here */
+		r = do_request(tfr, 0);
+		if (r)
+			LOG_DBG("Returning failed request to kernel [%s]",
+				RQ_TYPE(tfr->request_type));
+		r = kernel_send(tfr);
+		if (r)
+			LOG_ERROR("Failed to respond to kernel [%s]",
+				  RQ_TYPE(tfr->request_type));
+			
+		break;
+	case DM_CLOG_RESUME:
+		/*
+		 * Resume is a special case that requires a local
+		 * component to join the CPG, and a cluster component
+		 * to handle the request.
+		 */
+		r = local_resume(tfr);
+		if (r) {
+			LOG_DBG("Returning failed request to kernel [%s]",
+				RQ_TYPE(tfr->request_type));
+			r = kernel_send(tfr);
+			if (r)
+				LOG_ERROR("Failed to respond to kernel [%s]",
+					  RQ_TYPE(tfr->request_type));
+			break;
+		}
+		/* ELSE, fall through */
+	case DM_CLOG_IS_CLEAN:
+	case DM_CLOG_FLUSH:
+	case DM_CLOG_MARK_REGION:
+	case DM_CLOG_GET_RESYNC_WORK:
+	case DM_CLOG_SET_REGION_SYNC:
+	case DM_CLOG_IS_REMOTE_RECOVERING:
+	case DM_CLOG_POSTSUSPEND:
+		r = cluster_send(tfr);
+		if (r) {
+			tfr->data_size = 0;
+			tfr->error = r;
+			kernel_send(tfr);
+		}
+
+		break;
+	case DM_CLOG_CLEAR_REGION:
+		r = kernel_ack(tfr->seq, 0);
+
+		r = cluster_send(tfr);
+		if (r) {
+			/*
+			 * FIXME: store error for delivery on flush
+			 *        This would allow us to optimize MARK_REGION
+			 *        too.
+			 */
+		}
+
+		break;
+	case DM_CLOG_GET_REGION_SIZE:
+	default:
+		LOG_ERROR("Invalid log request received, ignoring.");
+		return 0;
+	}
+
+	if (r && !tfr->error)
+		tfr->error = r;
+
+	return r;
+}
+
+/*
+ * kernel_send
+ * @tfr: result to pass back to kernel
+ *
+ * This function returns the tfr structure
+ * (containing the results) to the kernel.
+ * It then frees the structure.
+ *
+ * WARNING: should the structure be freed if
+ * there is an error?  I vote 'yes'.  If the
+ * kernel doesn't get the response, it should
+ * resend the request.
+ *
+ * Returns: 0 on success, -EXXX on failure
+ */
+int kernel_send(struct clog_tfr *tfr)
+{
+	int r;
+	int size;
+
+	if (!tfr)
+		return -EINVAL;
+
+	size = sizeof(struct clog_tfr) + tfr->data_size;
+
+	if (!tfr->data_size && !tfr->error) {
+		/* An ACK is all that is needed */
+
+		/* FIXME: add ACK code */
+	} else if (size > DM_CLOG_TFR_SIZE) {
+		/*
+		 * If we gotten here, we've already overrun
+		 * our allotted space somewhere.
+		 *
+		 * We must do something, because the kernel
+		 * is waiting for a response.
+		 */
+		LOG_ERROR("Not enough space to respond to server");
+		tfr->error = -ENOSPC;
+		size = sizeof(struct clog_tfr);
+	}
+
+	r = kernel_send_helper(tfr, size);
+	if (r)
+		LOG_ERROR("Failed to send msg to kernel.");
+
+	return r;
+}
+
+/*
+ * init_local
+ *
+ * Initialize kernel communication socket (netlink)
+ *
+ * Returns: 0 on success, values from common.h on failure
+ */
+int init_local(void)
+{
+	int r = 0;
+	int opt;
+	struct sockaddr_nl addr;
+
+	cn_fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
+	if (cn_fd < 0)
+		return EXIT_KERNEL_TFR_SOCKET;
+
+	/* memset to fix valgrind complaint */
+	memset(&addr, 0, sizeof(struct sockaddr_nl));
+
+	addr.nl_family = AF_NETLINK;
+	addr.nl_groups = 0x4;
+	addr.nl_pid = 0;
+
+	r = bind(cn_fd, (struct sockaddr *) &addr, sizeof(addr));
+	if (r < 0) {
+		close(cn_fd);
+		return EXIT_KERNEL_TFR_BIND;
+	}
+
+	opt = addr.nl_groups;
+	r = setsockopt(cn_fd, 270, NETLINK_ADD_MEMBERSHIP, &opt, sizeof(opt));
+	if (r) {
+		close(cn_fd);
+		return EXIT_KERNEL_TFR_SETSOCKOPT;
+	}
+
+	/*
+	r = fcntl(cn_fd, F_SETFL, FNDELAY);
+	*/
+
+	links_register(cn_fd, "local", do_local_work, NULL);
+
+	return 0;
+}
+
+/*
+ * cleanup_local
+ *
+ * Clean up before exiting
+ */
+void cleanup_local(void)
+{
+	links_unregister(cn_fd);
+	close(cn_fd);
+}

daemons/clogd/local.h

@@ -0,0 +1,9 @@
+#ifndef __CLUSTER_LOG_LOCAL_DOT_H__
+#define __CLUSTER_LOG_LOCAL_DOT_H__
+
+int init_local(void);
+void cleanup_local(void);
+
+int kernel_send(struct clog_tfr *tfr);
+
+#endif /* __CLUSTER_LOG_LOCAL_DOT_H__ */

daemons/clogd/logging.c

@@ -0,0 +1,25 @@
+#include <syslog.h>
+
+int log_tabbing = 0;
+int log_is_open = 0;
+
+/*
+ * Variables for various conditional logging
+ */
+#ifdef MEMB
+int log_membership_change = 1;
+#else
+int log_membership_change = 0;
+#endif
+
+#ifdef CKPT
+int log_checkpoint = 1;
+#else
+int log_checkpoint = 0;
+#endif
+
+#ifdef RESEND
+int log_resend_requests = 1;
+#else
+int log_resend_requests = 0;
+#endif

daemons/clogd/logging.h

@@ -0,0 +1,81 @@
+#ifndef __CLUSTER_LOG_LOGGING_DOT_H__
+#define __CLUSTER_LOG_LOGGING_DOT_H__
+
+#include <stdio.h>
+#include <syslog.h>
+
+#if (BITS_PER_LONG == 64)
+#define PRIu64 "lu"
+#define PRId64 "ld"
+#define PRIo64 "lo"
+#define PRIx64 "lx"
+#define PRIX64 "lX"
+#define SCNu64 "lu"
+#define SCNd64 "ld"
+#define SCNo64 "lo"
+#define SCNx64 "lx"
+#define SCNX64 "lX"
+#else
+#define PRIu64 "Lu"
+#define PRId64 "Ld"
+#define PRIo64 "Lo"
+#define PRIx64 "Lx"
+#define PRIX64 "LX"
+#define SCNu64 "Lu"
+#define SCNd64 "Ld"
+#define SCNo64 "Lo"
+#define SCNx64 "Lx"
+#define SCNX64 "LX"
+#endif
+
+/* SHORT_UUID - print last 8 chars of a string */
+#define SHORT_UUID(x) (strlen(x) > 8) ? ((x) + (strlen(x) - 8)) : (x)
+
+extern int log_tabbing;
+extern int log_is_open;
+extern int log_membership_change;
+extern int log_checkpoint;
+extern int log_resend_requests;
+
+#define LOG_OPEN(ident, option, facility) do { \
+		openlog(ident, option, facility); \
+		log_is_open = 1;		  \
+	} while (0)
+
+#define LOG_CLOSE(void) do { \
+		log_is_open = 0; \
+		closelog();	 \
+	} while (0)
+
+#define LOG_OUTPUT(level, f, arg...) do {				\
+		int __i;						\
+		char __buffer[16];					\
+		FILE *fp = (level > LOG_NOTICE) ? stderr : stdout;	\
+		if (log_is_open) {					\
+			for (__i = 0; (__i < log_tabbing) && (__i < 15); __i++) \
+				__buffer[__i] = '\t';			\
+			__buffer[__i] = '\0';				\
+			syslog(level, "%s" f "\n", __buffer, ## arg);	\
+		} else {						\
+			for (__i = 0; __i < log_tabbing; __i++)		\
+				fprintf(fp, "\t");			\
+			fprintf(fp, f "\n", ## arg);			\
+		}							\
+	} while (0)
+
+
+#ifdef DEBUG
+#define LOG_DBG(f, arg...) LOG_OUTPUT(LOG_DEBUG, f, ## arg)
+#else /* DEBUG */
+#define LOG_DBG(f, arg...)
+#endif /* DEBUG */
+
+#define LOG_COND(__X, f, arg...) do {\
+		if (__X) { 	     \
+			LOG_OUTPUT(LOG_NOTICE, f, ## arg); \
+		} \
+	} while (0)
+#define LOG_PRINT(f, arg...) LOG_OUTPUT(LOG_NOTICE, f, ## arg)
+#define LOG_ERROR(f, arg...) LOG_OUTPUT(LOG_ERR, f, ## arg)
+
+#endif /* __CLUSTER_LOG_LOGGING_DOT_H__ */

daemons/clvmd/Makefile.in

@@ -15,30 +15,40 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 
+QUORUM_LIBS = @QUORUM_LIBS@
+QUORUM_CFLAGS = @QUORUM_CFLAGS@
+CONFDB_LIBS = @CONFDB_LIBS@
+CONFDB_CFLAGS = @CONFDB_CFLAGS@
+CPG_LIBS = @CPG_LIBS@
+CPG_CFLAGS = @CPG_CFLAGS@
+
 SOURCES = \
 	clvmd-command.c  \
 	clvmd.c          \
 	lvm-functions.c  \
 	refresh_clvmd.c
 
-ifeq ("@CLVMD@", "gulm")
+ifneq (,$(findstring gulm,, "@CLVMD@,"))
 	GULM = yes
 endif
 
-ifeq ("@CLVMD@", "cman")
+ifneq (,$(findstring cman,, "@CLVMD@,"))
 	CMAN = yes
 endif
 
-ifeq ("@CLVMD@", "openais")
+ifneq (,$(findstring openais,, "@CLVMD@,"))
 	OPENAIS = yes
-	GULM = no
-	CMAN = no
 endif
 
-ifeq ("@CLVMD@", "all")
+ifneq (,$(findstring corosync,, "@CLVMD@,"))
+	COROSYNC = yes
+endif
+
+ifneq (,$(findstring all,, "@CLVMD@,"))
 	GULM = yes
 	CMAN = yes
-	OPENAIS = no
+	OPENAIS = yes
+	COROSYNC = yes
 endif
 
 ifeq ("@DEBUG@", "yes")
@@ -63,10 +73,18 @@ ifeq ("$(OPENAIS)", "yes")
 	DEFS += -DUSE_OPENAIS
 endif
 
+ifeq ("$(COROSYNC)", "yes")
+	SOURCES += clvmd-corosync.c
+	LMLIBS += $(QUORUM_LIBS) $(CONFDB_LIBS) $(CPG_LIBS) -ldlm
+	CFLAGS += $(QUORUM_CFLAGS) $(CONFDB_CFLAGS) $(CPG_CFLAGS)
+	DEFS += -DUSE_COROSYNC
+endif
+
+
 TARGETS = \
 	clvmd
 
-LVMLIBS = -llvm -lpthread
+LVMLIBS = -llvm-internal -lpthread
 
 ifeq ("@DMEVENTD@", "yes")
 	LVMLIBS += -ldevmapper-event
@@ -82,7 +100,7 @@ include $(top_srcdir)/make.tmpl
 INSTALL_TARGETS = \
 	install_clvmd
 
-clvmd: $(OBJECTS) $(top_srcdir)/lib/liblvm.a
+clvmd: $(OBJECTS) $(top_srcdir)/lib/liblvm-internal.a
 	$(CC) -o clvmd $(OBJECTS) $(CFLAGS) $(LDFLAGS) \
 		$(LVMLIBS) $(LMLIBS) $(LIBS)
 
@@ -90,7 +108,7 @@ clvmd: $(OBJECTS) $(top_srcdir)/lib/liblvm.a
 
 install_clvmd: $(TARGETS)
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) clvmd \
-		$(sbindir)/clvmd
+		$(usrsbindir)/clvmd
 
 install: $(INSTALL_TARGETS)
 

daemons/clvmd/clvm.h

@@ -62,6 +62,7 @@ static const char CLVMD_SOCKNAME[] = "\0clvmd";
 /* Lock/Unlock commands */
 #define CLVMD_CMD_LOCK_LV           50
 #define CLVMD_CMD_LOCK_VG           51
+#define CLVMD_CMD_LOCK_QUERY	    52
 
 /* Misc functions */
 #define CLVMD_CMD_REFRESH	    40

daemons/clvmd/clvmd-cman.c

@@ -17,6 +17,10 @@
  * CMAN communication layer for clvmd.
  */
 
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <configure.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -41,7 +45,7 @@
 
 #include "clvmd-comms.h"
 #include "clvm.h"
-#include "log.h"
+#include "lvm-logging.h"
 #include "clvmd.h"
 #include "lvm-functions.h"
 
@@ -106,8 +110,13 @@ static int _init_cluster(void)
 	/* Create a lockspace for LV & VG locks to live in */
 	lockspace = dlm_create_lockspace(LOCKSPACE_NAME, 0600);
 	if (!lockspace) {
-		syslog(LOG_ERR, "Unable to create lockspace for CLVM: %m");
-		return -1;
+		if (errno == EEXIST) {
+			lockspace = dlm_open_lockspace(LOCKSPACE_NAME);
+		}
+		if (!lockspace) {
+			syslog(LOG_ERR, "Unable to create lockspace for CLVM: %m");
+			return -1;
+		}
 	}
 	dlm_ls_pthread_init(lockspace);
 	DEBUGLOG("DLM initialisation complete\n");
@@ -254,7 +263,7 @@ static void _add_up_node(const char *csid)
 
 static void _cluster_closedown()
 {
-	unlock_all();
+	destroy_lvhash();
 	dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
 	cman_finish(c_handle);
 }

daemons/clvmd/clvmd-command.c

@@ -50,6 +50,10 @@
 
 */
 
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <configure.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
@@ -67,9 +71,8 @@
 #include <libdevmapper.h>
 #include <libdlm.h>
 
-#include "list.h"
 #include "locking.h"
-#include "log.h"
+#include "lvm-logging.h"
 #include "lvm-functions.h"
 #include "clvmd-comms.h"
 #include "clvm.h"
@@ -87,6 +90,7 @@ int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
 	int arglen = msglen - sizeof(struct clvm_header) - strlen(msg->node);
 	int status = 0;
 	char *lockname;
+	const char *locktype;
 	struct utsname nodeinfo;
 	unsigned char lock_cmd;
 	unsigned char lock_flags;
@@ -141,6 +145,14 @@ int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
 		}
 		break;
 
+	case CLVMD_CMD_LOCK_QUERY:
+		lockname = &args[2];
+		if (buflen < 3)
+			return EIO;
+		if ((locktype = do_lock_query(lockname)))
+			*retlen = 1 + snprintf(*buf, buflen, "%s", locktype);
+		break;
+
 	case CLVMD_CMD_REFRESH:
 		do_refresh_cache();
 		break;
@@ -156,7 +168,11 @@ int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
 		break;
 
 	case CLVMD_CMD_VG_BACKUP:
-		lvm_do_backup(&args[2]);
+		/*
+		 * Do not run backup on local node, caller should do that.
+		 */
+		if (!client)
+			lvm_do_backup(&args[2]);
 		break;
 
 	default:
@@ -271,6 +287,7 @@ int do_pre_command(struct local_client *client)
 	case CLVMD_CMD_GET_CLUSTERNAME:
 	case CLVMD_CMD_SET_DEBUG:
 	case CLVMD_CMD_VG_BACKUP:
+	case CLVMD_CMD_LOCK_QUERY:
 		break;
 
 	default:
@@ -301,6 +318,7 @@ int do_post_command(struct local_client *client)
 
 	case CLVMD_CMD_LOCK_VG:
 	case CLVMD_CMD_VG_BACKUP:
+	case CLVMD_CMD_LOCK_QUERY:
 		/* Nothing to do here */
 		break;
 

daemons/clvmd/clvmd-comms.h

@@ -93,5 +93,22 @@ struct cluster_ops *init_cman_cluster(void);
 struct cluster_ops *init_openais_cluster(void);
 #endif
 
+#ifdef USE_COROSYNC
+#  include <corosync/corotypes.h>
+#  define COROSYNC_CSID_LEN (sizeof(int))
+#  define COROSYNC_MAX_CLUSTER_MESSAGE         65535
+#  define COROSYNC_MAX_CLUSTER_MEMBER_NAME_LEN CS_MAX_NAME_LENGTH
+#  ifndef MAX_CLUSTER_MEMBER_NAME_LEN
+#    define MAX_CLUSTER_MEMBER_NAME_LEN       CS_MAX_NAME_LENGTH
+#  endif
+#  ifndef CMAN_MAX_CLUSTER_MESSAGE
+#    define CMAN_MAX_CLUSTER_MESSAGE          65535
+#  endif
+#  ifndef MAX_CSID_LEN
+#    define MAX_CSID_LEN sizeof(int)
+#  endif
+struct cluster_ops *init_corosync_cluster(void);
+#endif
+
 
 #endif

daemons/clvmd/clvmd-corosync.c

@@ -0,0 +1,643 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) 2009 Red Hat, Inc. All rights reserved.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* This provides the interface between clvmd and corosync/DLM as the cluster
+ * and lock manager.
+ *
+ */
+
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <configure.h>
+#include <pthread.h>
+#include <sys/types.h>
+#include <sys/utsname.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <errno.h>
+#include <utmpx.h>
+#include <syslog.h>
+#include <assert.h>
+#include <libdevmapper.h>
+
+#include <corosync/corotypes.h>
+#include <corosync/cpg.h>
+#include <corosync/quorum.h>
+#include <corosync/confdb.h>
+#include <libdlm.h>
+
+#include "locking.h"
+#include "lvm-logging.h"
+#include "clvm.h"
+#include "clvmd-comms.h"
+#include "lvm-functions.h"
+#include "clvmd.h"
+
+/* Timeout value for several corosync calls */
+#define LOCKSPACE_NAME "clvmd"
+
+static void cpg_deliver_callback (cpg_handle_t handle,
+				  const struct cpg_name *groupName,
+				  uint32_t nodeid,
+				  uint32_t pid,
+				  void *msg,
+				  size_t msg_len);
+static void cpg_confchg_callback(cpg_handle_t handle,
+				 const struct cpg_name *groupName,
+				 const struct cpg_address *member_list, size_t member_list_entries,
+				 const struct cpg_address *left_list, size_t left_list_entries,
+				 const struct cpg_address *joined_list, size_t joined_list_entries);
+static void _cluster_closedown(void);
+
+/* Hash list of nodes in the cluster */
+static struct dm_hash_table *node_hash;
+
+/* Number of active nodes */
+static int num_nodes;
+static unsigned int our_nodeid;
+
+static struct local_client *cluster_client;
+
+/* Corosync handles */
+static cpg_handle_t cpg_handle;
+static quorum_handle_t quorum_handle;
+
+/* DLM Handle */
+static dlm_lshandle_t *lockspace;
+
+static struct cpg_name cpg_group_name;
+
+/* Corosync callback structs */
+cpg_callbacks_t cpg_callbacks = {
+	.cpg_deliver_fn =            cpg_deliver_callback,
+	.cpg_confchg_fn =            cpg_confchg_callback,
+};
+
+quorum_callbacks_t quorum_callbacks = {
+	.quorum_notify_fn = NULL,
+};
+
+struct node_info
+{
+	enum {NODE_UNKNOWN, NODE_DOWN, NODE_UP, NODE_CLVMD} state;
+	int nodeid;
+};
+
+
+/* Set errno to something approximating the right value and return 0 or -1 */
+static int cs_to_errno(cs_error_t err)
+{
+	switch(err)
+	{
+	case CS_OK:
+		return 0;
+        case CS_ERR_LIBRARY:
+		errno = EINVAL;
+		break;
+        case CS_ERR_VERSION:
+		errno = EINVAL;
+		break;
+        case CS_ERR_INIT:
+		errno = EINVAL;
+		break;
+        case CS_ERR_TIMEOUT:
+		errno = ETIME;
+		break;
+        case CS_ERR_TRY_AGAIN:
+		errno = EAGAIN;
+		break;
+        case CS_ERR_INVALID_PARAM:
+		errno = EINVAL;
+		break;
+        case CS_ERR_NO_MEMORY:
+		errno = ENOMEM;
+		break;
+        case CS_ERR_BAD_HANDLE:
+		errno = EINVAL;
+		break;
+        case CS_ERR_BUSY:
+		errno = EBUSY;
+		break;
+        case CS_ERR_ACCESS:
+		errno = EPERM;
+		break;
+        case CS_ERR_NOT_EXIST:
+		errno = ENOENT;
+		break;
+        case CS_ERR_NAME_TOO_LONG:
+		errno = ENAMETOOLONG;
+		break;
+        case CS_ERR_EXIST:
+		errno = EEXIST;
+		break;
+        case CS_ERR_NO_SPACE:
+		errno = ENOSPC;
+		break;
+        case CS_ERR_INTERRUPT:
+		errno = EINTR;
+		break;
+	case CS_ERR_NAME_NOT_FOUND:
+		errno = ENOENT;
+		break;
+        case CS_ERR_NO_RESOURCES:
+		errno = ENOMEM;
+		break;
+        case CS_ERR_NOT_SUPPORTED:
+		errno = EOPNOTSUPP;
+		break;
+        case CS_ERR_BAD_OPERATION:
+		errno = EINVAL;
+		break;
+        case CS_ERR_FAILED_OPERATION:
+		errno = EIO;
+		break;
+        case CS_ERR_MESSAGE_ERROR:
+		errno = EIO;
+		break;
+        case CS_ERR_QUEUE_FULL:
+		errno = EXFULL;
+		break;
+        case CS_ERR_QUEUE_NOT_AVAILABLE:
+		errno = EINVAL;
+		break;
+        case CS_ERR_BAD_FLAGS:
+		errno = EINVAL;
+		break;
+        case CS_ERR_TOO_BIG:
+		errno = E2BIG;
+		break;
+        case CS_ERR_NO_SECTIONS:
+		errno = ENOMEM;
+		break;
+	default:
+		errno = EINVAL;
+		break;
+	}
+	return -1;
+}
+
+static char *print_corosync_csid(const char *csid)
+{
+	static char buf[128];
+	int id;
+
+	memcpy(&id, csid, sizeof(int));
+	sprintf(buf, "%d", id);
+	return buf;
+}
+
+static void cpg_deliver_callback (cpg_handle_t handle,
+				  const struct cpg_name *groupName,
+				  uint32_t nodeid,
+				  uint32_t pid,
+				  void *msg,
+				  size_t msg_len)
+{
+	int target_nodeid;
+
+	memcpy(&target_nodeid, msg, COROSYNC_CSID_LEN);
+
+	DEBUGLOG("%u got message from nodeid %d for %d. len %zd\n",
+		 our_nodeid, nodeid, target_nodeid, msg_len-4);
+
+	if (nodeid != our_nodeid)
+		if (target_nodeid == our_nodeid || target_nodeid == 0)
+			process_message(cluster_client, (char *)msg+COROSYNC_CSID_LEN,
+					msg_len-COROSYNC_CSID_LEN, (char*)&nodeid);
+}
+
+static void cpg_confchg_callback(cpg_handle_t handle,
+				 const struct cpg_name *groupName,
+				 const struct cpg_address *member_list, size_t member_list_entries,
+				 const struct cpg_address *left_list, size_t left_list_entries,
+				 const struct cpg_address *joined_list, size_t joined_list_entries)
+{
+	int i;
+	struct node_info *ninfo;
+
+	DEBUGLOG("confchg callback. %zd joined, %zd left, %zd members\n",
+		 joined_list_entries, left_list_entries, member_list_entries);
+
+	for (i=0; i<joined_list_entries; i++) {
+		ninfo = dm_hash_lookup_binary(node_hash,
+					      (char *)&joined_list[i].nodeid,
+					      COROSYNC_CSID_LEN);
+		if (!ninfo) {
+			ninfo = malloc(sizeof(struct node_info));
+			if (!ninfo) {
+				break;
+			}
+			else {
+				ninfo->nodeid = joined_list[i].nodeid;
+				dm_hash_insert_binary(node_hash,
+						      (char *)&ninfo->nodeid,
+						      COROSYNC_CSID_LEN, ninfo);
+			}
+		}
+		ninfo->state = NODE_CLVMD;
+	}
+
+	for (i=0; i<left_list_entries; i++) {
+		ninfo = dm_hash_lookup_binary(node_hash,
+					      (char *)&left_list[i].nodeid,
+					      COROSYNC_CSID_LEN);
+		if (ninfo)
+			ninfo->state = NODE_DOWN;
+	}
+
+	for (i=0; i<member_list_entries; i++) {
+		if (member_list[i].nodeid == 0) continue;
+		ninfo = dm_hash_lookup_binary(node_hash,
+				(char *)&member_list[i].nodeid,
+				COROSYNC_CSID_LEN);
+		if (!ninfo) {
+			ninfo = malloc(sizeof(struct node_info));
+			if (!ninfo) {
+				break;
+			}
+			else {
+				ninfo->nodeid = member_list[i].nodeid;
+				dm_hash_insert_binary(node_hash,
+						(char *)&ninfo->nodeid,
+						COROSYNC_CSID_LEN, ninfo);
+			}
+		}
+		ninfo->state = NODE_CLVMD;
+	}
+
+	num_nodes = member_list_entries;
+}
+
+static int _init_cluster(void)
+{
+	cs_error_t err;
+
+	node_hash = dm_hash_create(100);
+
+	err = cpg_initialize(&cpg_handle,
+			     &cpg_callbacks);
+	if (err != CS_OK) {
+		syslog(LOG_ERR, "Cannot initialise Corosync CPG service: %d",
+		       err);
+		DEBUGLOG("Cannot initialise Corosync CPG service: %d", err);
+		return cs_to_errno(err);
+	}
+
+	err = quorum_initialize(&quorum_handle,
+				&quorum_callbacks);
+	if (err != CS_OK) {
+		syslog(LOG_ERR, "Cannot initialise Corosync quorum service: %d",
+		       err);
+		DEBUGLOG("Cannot initialise Corosync quorum service: %d", err);
+		return cs_to_errno(err);
+	}
+
+
+	/* Create a lockspace for LV & VG locks to live in */
+	lockspace = dlm_create_lockspace(LOCKSPACE_NAME, 0600);
+	if (!lockspace) {
+		if (errno == EEXIST) {
+			lockspace = dlm_open_lockspace(LOCKSPACE_NAME);
+		}
+		if (!lockspace) {
+			syslog(LOG_ERR, "Unable to create lockspace for CLVM: %m");
+			quorum_finalize(quorum_handle);
+			return -1;
+		}
+	}
+	dlm_ls_pthread_init(lockspace);
+	DEBUGLOG("DLM initialisation complete\n");
+
+	/* Connect to the clvmd group */
+	strcpy((char *)cpg_group_name.value, "clvmd");
+	cpg_group_name.length = strlen((char *)cpg_group_name.value);
+	err = cpg_join(cpg_handle, &cpg_group_name);
+	if (err != CS_OK) {
+		cpg_finalize(cpg_handle);
+		quorum_finalize(quorum_handle);
+		dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
+		syslog(LOG_ERR, "Cannot join clvmd process group");
+		DEBUGLOG("Cannot join clvmd process group: %d\n", err);
+		return cs_to_errno(err);
+	}
+
+	err = cpg_local_get(cpg_handle,
+			    &our_nodeid);
+	if (err != CS_OK) {
+		cpg_finalize(cpg_handle);
+		quorum_finalize(quorum_handle);
+		dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
+		syslog(LOG_ERR, "Cannot get local node id\n");
+		return cs_to_errno(err);
+	}
+	DEBUGLOG("Our local node id is %d\n", our_nodeid);
+
+	DEBUGLOG("Connected to Corosync\n");
+
+	return 0;
+}
+
+static void _cluster_closedown(void)
+{
+	DEBUGLOG("cluster_closedown\n");
+	destroy_lvhash();
+
+	dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
+	cpg_finalize(cpg_handle);
+	quorum_finalize(quorum_handle);
+}
+
+static void _get_our_csid(char *csid)
+{
+	memcpy(csid, &our_nodeid, sizeof(int));
+}
+
+/* Corosync doesn't really have nmode names so we
+   just use the node ID in hex instead */
+static int _csid_from_name(char *csid, const char *name)
+{
+	int nodeid;
+	struct node_info *ninfo;
+
+	if (sscanf(name, "%x", &nodeid) == 1) {
+		ninfo = dm_hash_lookup_binary(node_hash, csid, COROSYNC_CSID_LEN);
+		if (ninfo)
+			return nodeid;
+	}
+	return -1;
+}
+
+static int _name_from_csid(const char *csid, char *name)
+{
+	struct node_info *ninfo;
+
+	ninfo = dm_hash_lookup_binary(node_hash, csid, COROSYNC_CSID_LEN);
+	if (!ninfo)
+	{
+		sprintf(name, "UNKNOWN %s", print_corosync_csid(csid));
+		return -1;
+	}
+
+	sprintf(name, "%x", ninfo->nodeid);
+	return 0;
+}
+
+static int _get_num_nodes()
+{
+	DEBUGLOG("num_nodes = %d\n", num_nodes);
+	return num_nodes;
+}
+
+/* Node is now known to be running a clvmd */
+static void _add_up_node(const char *csid)
+{
+	struct node_info *ninfo;
+
+	ninfo = dm_hash_lookup_binary(node_hash, csid, COROSYNC_CSID_LEN);
+	if (!ninfo) {
+		DEBUGLOG("corosync_add_up_node no node_hash entry for csid %s\n",
+			 print_corosync_csid(csid));
+		return;
+	}
+
+	DEBUGLOG("corosync_add_up_node %d\n", ninfo->nodeid);
+
+	ninfo->state = NODE_CLVMD;
+
+	return;
+}
+
+/* Call a callback for each node, so the caller knows whether it's up or down */
+static int _cluster_do_node_callback(struct local_client *master_client,
+				     void (*callback)(struct local_client *,
+						      const char *csid, int node_up))
+{
+	struct dm_hash_node *hn;
+	struct node_info *ninfo;
+	int somedown = 0;
+
+	dm_hash_iterate(hn, node_hash)
+	{
+		char csid[COROSYNC_CSID_LEN];
+
+		ninfo = dm_hash_get_data(node_hash, hn);
+		memcpy(csid, dm_hash_get_key(node_hash, hn), COROSYNC_CSID_LEN);
+
+		DEBUGLOG("down_callback. node %d, state = %d\n", ninfo->nodeid,
+			 ninfo->state);
+
+		if (ninfo->state != NODE_DOWN)
+			callback(master_client, csid, ninfo->state == NODE_CLVMD);
+		if (ninfo->state != NODE_CLVMD)
+			somedown = -1;
+	}
+	return somedown;
+}
+
+/* Real locking */
+static int _lock_resource(const char *resource, int mode, int flags, int *lockid)
+{
+	struct dlm_lksb lksb;
+	int err;
+
+	DEBUGLOG("lock_resource '%s', flags=%d, mode=%d\n", resource, flags, mode);
+
+	if (flags & LKF_CONVERT)
+		lksb.sb_lkid = *lockid;
+
+	err = dlm_ls_lock_wait(lockspace,
+			       mode,
+			       &lksb,
+			       flags,
+			       resource,
+			       strlen(resource),
+			       0,
+			       NULL, NULL, NULL);
+
+	if (err != 0)
+	{
+		DEBUGLOG("dlm_ls_lock returned %d\n", errno);
+		return err;
+	}
+	if (lksb.sb_status != 0)
+	{
+		DEBUGLOG("dlm_ls_lock returns lksb.sb_status %d\n", lksb.sb_status);
+		errno = lksb.sb_status;
+		return -1;
+	}
+
+	DEBUGLOG("lock_resource returning %d, lock_id=%x\n", err, lksb.sb_lkid);
+
+	*lockid = lksb.sb_lkid;
+
+	return 0;
+}
+
+
+static int _unlock_resource(const char *resource, int lockid)
+{
+	struct dlm_lksb lksb;
+	int err;
+
+	DEBUGLOG("unlock_resource: %s lockid: %x\n", resource, lockid);
+	lksb.sb_lkid = lockid;
+
+	err = dlm_ls_unlock_wait(lockspace,
+				 lockid,
+				 0,
+				 &lksb);
+	if (err != 0)
+	{
+		DEBUGLOG("Unlock returned %d\n", err);
+		return err;
+	}
+	if (lksb.sb_status != EUNLOCK)
+	{
+		DEBUGLOG("dlm_ls_unlock_wait returns lksb.sb_status: %d\n", lksb.sb_status);
+		errno = lksb.sb_status;
+		return -1;
+	}   
+
+
+	return 0;
+}
+
+static int _is_quorate()
+{
+	int quorate;
+	if (quorum_getquorate(quorum_handle, &quorate) == CS_OK)
+		return quorate;
+	else
+		return 0;
+}
+
+static int _get_main_cluster_fd(void)
+{
+	int select_fd;
+
+	cpg_fd_get(cpg_handle, &select_fd);
+	return select_fd;
+}
+
+static int _cluster_fd_callback(struct local_client *fd, char *buf, int len,
+				const char *csid,
+				struct local_client **new_client)
+{
+	cluster_client = fd;
+	*new_client = NULL;
+	cpg_dispatch(cpg_handle, CS_DISPATCH_ONE);
+	return 1;
+}
+
+static int _cluster_send_message(const void *buf, int msglen, const char *csid,
+				 const char *errtext)
+{
+	struct iovec iov[2];
+	cs_error_t err;
+	int target_node;
+
+	if (csid)
+		memcpy(&target_node, csid, COROSYNC_CSID_LEN);
+	else
+		target_node = 0;
+
+	iov[0].iov_base = &target_node;
+	iov[0].iov_len = sizeof(int);
+	iov[1].iov_base = (char *)buf;
+	iov[1].iov_len = msglen;
+
+	err = cpg_mcast_joined(cpg_handle, CPG_TYPE_AGREED, iov, 2);
+	return cs_to_errno(err);
+}
+
+/*
+ * We are not necessarily connected to a Red Hat Cluster system,
+ * but if we are, this returns the cluster name from cluster.conf.
+ * I've used confdb rather than ccs to reduce the inter-package
+ * dependancies as well as to allow people to set a cluster name
+ * for themselves even if they are not running on RH cluster.
+ */
+static int _get_cluster_name(char *buf, int buflen)
+{
+	confdb_handle_t handle;
+	int result;
+	size_t namelen = buflen;
+	hdb_handle_t cluster_handle;
+	confdb_callbacks_t callbacks = {
+		.confdb_key_change_notify_fn = NULL,
+		.confdb_object_create_change_notify_fn = NULL,
+		.confdb_object_delete_change_notify_fn = NULL
+	};
+
+	/* This is a default in case everything else fails */
+	strncpy(buf, "Corosync", buflen);
+
+	/* Look for a cluster name in confdb */
+	result = confdb_initialize (&handle, &callbacks);
+        if (result != CS_OK)
+		return 0;
+
+        result = confdb_object_find_start(handle, OBJECT_PARENT_HANDLE);
+	if (result != CS_OK)
+		goto out;
+
+        result = confdb_object_find(handle, OBJECT_PARENT_HANDLE, (void *)"cluster", strlen("cluster"), &cluster_handle);
+        if (result != CS_OK)
+		goto out;
+
+        result = confdb_key_get(handle, cluster_handle, (void *)"name", strlen("name"), buf, &namelen);
+        if (result != CS_OK)
+		goto out;
+
+	buf[namelen] = '\0';
+
+out:
+	confdb_finalize(handle);
+	return 0;
+}
+
+static struct cluster_ops _cluster_corosync_ops = {
+	.cluster_init_completed   = NULL,
+	.cluster_send_message     = _cluster_send_message,
+	.name_from_csid           = _name_from_csid,
+	.csid_from_name           = _csid_from_name,
+	.get_num_nodes            = _get_num_nodes,
+	.cluster_fd_callback      = _cluster_fd_callback,
+	.get_main_cluster_fd      = _get_main_cluster_fd,
+	.cluster_do_node_callback = _cluster_do_node_callback,
+	.is_quorate               = _is_quorate,
+	.get_our_csid             = _get_our_csid,
+	.add_up_node              = _add_up_node,
+	.reread_config            = NULL,
+	.cluster_closedown        = _cluster_closedown,
+	.get_cluster_name         = _get_cluster_name,
+	.sync_lock                = _lock_resource,
+	.sync_unlock              = _unlock_resource,
+};
+
+struct cluster_ops *init_corosync_cluster(void)
+{
+	if (!_init_cluster())
+		return &_cluster_corosync_ops;
+	else
+		return NULL;
+}

daemons/clvmd/clvmd-gulm.c

@@ -44,9 +44,8 @@
 #include <ccs.h>
 #include <libgulm.h>
 
-#include "list.h"
 #include "locking.h"
-#include "log.h"
+#include "lvm-logging.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
 #include "lvm-functions.h"
@@ -249,7 +248,7 @@ static void _cluster_closedown(void)
 {
     DEBUGLOG("cluster_closedown\n");
     in_shutdown = 1;
-    unlock_all();
+    destroy_lvhash();
     lg_lock_logout(gulm_if);
     lg_core_logout(gulm_if);
     lg_release(gulm_if);

daemons/clvmd/clvmd-openais.c

@@ -11,6 +11,10 @@
  *
  */
 
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <configure.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
@@ -39,9 +43,8 @@
 #include <openais/saLck.h>
 #include <openais/cpg.h>
 
-#include "list.h"
 #include "locking.h"
-#include "log.h"
+#include "lvm-logging.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
 #include "lvm-functions.h"
@@ -192,7 +195,7 @@ static int ais_to_errno(SaAisErrorT err)
 	return -1;
 }
 
-static char *print_csid(const char *csid)
+static char *print_openais_csid(const char *csid)
 {
 	static char buf[128];
 	int id;
@@ -379,7 +382,7 @@ static int _init_cluster(void)
 static void _cluster_closedown(void)
 {
 	DEBUGLOG("cluster_closedown\n");
-	unlock_all();
+	destroy_lvhash();
 
 	saLckFinalize(lck_handle);
 	cpg_finalize(cpg_handle);
@@ -412,7 +415,7 @@ static int _name_from_csid(const char *csid, char *name)
 	ninfo = dm_hash_lookup_binary(node_hash, csid, OPENAIS_CSID_LEN);
 	if (!ninfo)
 	{
-		sprintf(name, "UNKNOWN %s", print_csid(csid));
+		sprintf(name, "UNKNOWN %s", print_openais_csid(csid));
 		return -1;
 	}
 
@@ -434,7 +437,7 @@ static void _add_up_node(const char *csid)
 	ninfo = dm_hash_lookup_binary(node_hash, csid, OPENAIS_CSID_LEN);
 	if (!ninfo) {
 		DEBUGLOG("openais_add_up_node no node_hash entry for csid %s\n",
-			 print_csid(csid));
+			 print_openais_csid(csid));
 		return;
 	}
 

daemons/clvmd/clvmd.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -17,6 +17,12 @@
  * CLVMD: Cluster LVM daemon
  */
 
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <configure.h>
+#include <libdevmapper.h>
+
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -43,11 +49,10 @@
 #include "clvmd-comms.h"
 #include "lvm-functions.h"
 #include "clvm.h"
-#include "version.h"
+#include "lvm-version.h"
 #include "clvmd.h"
 #include "refresh_clvmd.h"
-#include "list.h"
-#include "log.h"
+#include "lvm-logging.h"
 
 #ifndef TRUE
 #define TRUE 1
@@ -75,7 +80,7 @@ static unsigned max_cluster_member_name_len;
 
 /* Structure of items on the LVM thread list */
 struct lvm_thread_cmd {
-	struct list list;
+	struct dm_list list;
 
 	struct local_client *client;
 	struct clvm_header *msg;
@@ -90,7 +95,7 @@ static pthread_t lvm_thread;
 static pthread_mutex_t lvm_thread_mutex;
 static pthread_cond_t lvm_thread_cond;
 static pthread_mutex_t lvm_start_mutex;
-static struct list lvm_cmd_head;
+static struct dm_list lvm_cmd_head;
 static volatile sig_atomic_t quit = 0;
 static volatile sig_atomic_t reread_config = 0;
 static int child_pipe[2];
@@ -103,6 +108,8 @@ static int child_pipe[2];
 #define DFAIL_TIMEOUT    5
 #define SUCCESS          0
 
+typedef enum {IF_AUTO, IF_CMAN, IF_GULM, IF_OPENAIS, IF_COROSYNC} if_type_t;
+
 /* Prototypes for code further down */
 static void sigusr2_handler(int sig);
 static void sighup_handler(int sig);
@@ -139,6 +146,7 @@ static void hton_clvm(struct clvm_header *hdr);
 static void ntoh_clvm(struct clvm_header *hdr);
 static void add_reply_to_list(struct local_client *client, int status,
 			      const char *csid, const char *buf, int len);
+static if_type_t parse_cluster_interface(char *ifname);
 
 static void usage(char *prog, FILE *file)
 {
@@ -153,6 +161,20 @@ static void usage(char *prog, FILE *file)
 	fprintf(file, "   -C       Sets debug level (from -d) on all clvmd instances clusterwide\n");
 	fprintf(file, "   -t<secs> Command timeout (default 60 seconds)\n");
 	fprintf(file, "   -T<secs> Startup timeout (default none)\n");
+	fprintf(file, "   -I<cmgr> Cluster manager (default: auto)\n");
+	fprintf(file, "            Available cluster managers: ");
+#ifdef USE_COROSYNC
+	fprintf(file, "corosync ");
+#endif
+#ifdef USE_CMAN
+	fprintf(file, "cman ");
+#endif
+#ifdef USE_OPENAIS
+	fprintf(file, "openais ");
+#endif
+#ifdef USE_GULM
+	fprintf(file, "gulm ");
+#endif
 	fprintf(file, "\n");
 }
 
@@ -199,44 +221,47 @@ static const char *decode_cmd(unsigned char cmdl)
 	const char *command;
 
 	switch (cmdl) {
-	case CLVMD_CMD_TEST:		
-		command = "TEST";	
+	case CLVMD_CMD_TEST:
+		command = "TEST";
 		break;
-	case CLVMD_CMD_LOCK_VG:		
-		command = "LOCK_VG";	
+	case CLVMD_CMD_LOCK_VG:
+		command = "LOCK_VG";
 		break;
-	case CLVMD_CMD_LOCK_LV:		
-		command = "LOCK_LV";	
+	case CLVMD_CMD_LOCK_LV:
+		command = "LOCK_LV";
 		break;
-	case CLVMD_CMD_REFRESH:		
-		command = "REFRESH";	
+	case CLVMD_CMD_REFRESH:
+		command = "REFRESH";
 		break;
-	case CLVMD_CMD_SET_DEBUG:	
-		command = "SET_DEBUG";	
+	case CLVMD_CMD_SET_DEBUG:
+		command = "SET_DEBUG";
 		break;
-	case CLVMD_CMD_GET_CLUSTERNAME:	
+	case CLVMD_CMD_GET_CLUSTERNAME:
 		command = "GET_CLUSTERNAME";
 		break;
-	case CLVMD_CMD_VG_BACKUP:	
-		command = "VG_BACKUP";	
+	case CLVMD_CMD_VG_BACKUP:
+		command = "VG_BACKUP";
 		break;
-	case CLVMD_CMD_REPLY:		
-		command = "REPLY";	
+	case CLVMD_CMD_REPLY:
+		command = "REPLY";
 		break;
-	case CLVMD_CMD_VERSION:		
-		command = "VERSION";	
+	case CLVMD_CMD_VERSION:
+		command = "VERSION";
 		break;
-	case CLVMD_CMD_GOAWAY:		
-		command = "GOAWAY";	
+	case CLVMD_CMD_GOAWAY:
+		command = "GOAWAY";
 		break;
-	case CLVMD_CMD_LOCK:		
-		command = "LOCK";	
+	case CLVMD_CMD_LOCK:
+		command = "LOCK";
 		break;
-	case CLVMD_CMD_UNLOCK:		
-		command = "UNLOCK";	
+	case CLVMD_CMD_UNLOCK:
+		command = "UNLOCK";
 		break;
-	default:			
-		command = "unknown";    
+	case CLVMD_CMD_LOCK_QUERY:
+		command = "LOCK_QUERY";
+		break;
+	default:
+		command = "unknown";
 		break;
 	}
 
@@ -253,6 +278,7 @@ int main(int argc, char *argv[])
 	signed char opt;
 	int cmd_timeout = DEFAULT_CMD_TIMEOUT;
 	int start_timeout = 0;
+	if_type_t cluster_iface = IF_AUTO;
 	sigset_t ss;
 	int using_gulm = 0;
 	int debug_opt = 0;
@@ -261,7 +287,7 @@ int main(int argc, char *argv[])
 	/* Deal with command-line arguments */
 	opterr = 0;
 	optind = 0;
-	while ((opt = getopt(argc, argv, "?vVhd::t:RT:C")) != EOF) {
+	while ((opt = getopt(argc, argv, "?vVhd::t:RT:CI:")) != EOF) {
 		switch (opt) {
 		case 'h':
 			usage(argv[0], stdout);
@@ -294,6 +320,9 @@ int main(int argc, char *argv[])
 				exit(1);
 			}
 			break;
+		case 'I':
+			cluster_iface = parse_cluster_interface(optarg);
+			break;
 		case 'T':
 			start_timeout = atoi(optarg);
 			if (start_timeout <= 0) {
@@ -346,13 +375,15 @@ int main(int argc, char *argv[])
 	signal(SIGHUP,  sighup_handler);
 	signal(SIGPIPE, SIG_IGN);
 
-	/* Block SIGUSR2 in the main process */
+	/* Block SIGUSR2/SIGINT/SIGTERM in process */
 	sigemptyset(&ss);
 	sigaddset(&ss, SIGUSR2);
+	sigaddset(&ss, SIGINT);
+	sigaddset(&ss, SIGTERM);
 	sigprocmask(SIG_BLOCK, &ss, NULL);
 
 	/* Initialise the LVM thread variables */
-	list_init(&lvm_cmd_head);
+	dm_list_init(&lvm_cmd_head);
 	pthread_mutex_init(&lvm_thread_mutex, NULL);
 	pthread_cond_init(&lvm_thread_cond, NULL);
 	pthread_mutex_init(&lvm_start_mutex, NULL);
@@ -360,7 +391,7 @@ int main(int argc, char *argv[])
 
 	/* Start the cluster interface */
 #ifdef USE_CMAN
-	if ((clops = init_cman_cluster())) {
+	if ((cluster_iface == IF_AUTO || cluster_iface == IF_CMAN) && (clops = init_cman_cluster())) {
 		max_csid_len = CMAN_MAX_CSID_LEN;
 		max_cluster_message = CMAN_MAX_CLUSTER_MESSAGE;
 		max_cluster_member_name_len = CMAN_MAX_NODENAME_LEN;
@@ -369,7 +400,7 @@ int main(int argc, char *argv[])
 #endif
 #ifdef USE_GULM
 	if (!clops)
-		if ((clops = init_gulm_cluster())) {
+		if ((cluster_iface == IF_AUTO || cluster_iface == IF_GULM) && (clops = init_gulm_cluster())) {
 			max_csid_len = GULM_MAX_CSID_LEN;
 			max_cluster_message = GULM_MAX_CLUSTER_MESSAGE;
 			max_cluster_member_name_len = GULM_MAX_CLUSTER_MEMBER_NAME_LEN;
@@ -377,9 +408,18 @@ int main(int argc, char *argv[])
 			syslog(LOG_NOTICE, "Cluster LVM daemon started - connected to GULM");
 		}
 #endif
+#ifdef USE_COROSYNC
+	if (!clops)
+		if (((cluster_iface == IF_AUTO || cluster_iface == IF_COROSYNC) && (clops = init_corosync_cluster()))) {
+			max_csid_len = COROSYNC_CSID_LEN;
+			max_cluster_message = COROSYNC_MAX_CLUSTER_MESSAGE;
+			max_cluster_member_name_len = COROSYNC_MAX_CLUSTER_MEMBER_NAME_LEN;
+			syslog(LOG_NOTICE, "Cluster LVM daemon started - connected to Corosync");
+		}
+#endif
 #ifdef USE_OPENAIS
 	if (!clops)
-		if ((clops = init_openais_cluster())) {
+		if ((cluster_iface == IF_AUTO || cluster_iface == IF_OPENAIS) && (clops = init_openais_cluster())) {
 			max_csid_len = OPENAIS_CSID_LEN;
 			max_cluster_message = OPENAIS_MAX_CLUSTER_MESSAGE;
 			max_cluster_member_name_len = OPENAIS_MAX_CLUSTER_MEMBER_NAME_LEN;
@@ -418,6 +458,9 @@ int main(int argc, char *argv[])
 	/* This needs to be started after cluster initialisation
 	   as it may need to take out locks */
 	DEBUGLOG("starting LVM thread\n");
+
+	/* Don't let anyone else to do work until we are started */
+	pthread_mutex_lock(&lvm_start_mutex);
 	pthread_create(&lvm_thread, NULL, lvm_thread_fn,
 			(void *)(long)using_gulm);
 
@@ -438,6 +481,8 @@ int main(int argc, char *argv[])
 	/* Do some work */
 	main_loop(local_sock, cmd_timeout);
 
+	destroy_lvm();
+
 	return 0;
 }
 
@@ -631,6 +676,11 @@ static void main_loop(int local_sock, int cmd_timeout)
 {
 	DEBUGLOG("Using timeout of %d seconds\n", cmd_timeout);
 
+	sigset_t ss;
+	sigemptyset(&ss);
+	sigaddset(&ss, SIGINT);
+	sigaddset(&ss, SIGTERM);
+	pthread_sigmask(SIG_UNBLOCK, &ss, NULL);
 	/* Main loop */
 	while (!quit) {
 		fd_set in;
@@ -1749,13 +1799,10 @@ static int process_work_item(struct lvm_thread_cmd *cmd)
  */
 static __attribute__ ((noreturn)) void *lvm_thread_fn(void *arg)
 {
-	struct list *cmdl, *tmp;
+	struct dm_list *cmdl, *tmp;
 	sigset_t ss;
 	int using_gulm = (int)(long)arg;
 
-	/* Don't let anyone else to do work until we are started */
-	pthread_mutex_lock(&lvm_start_mutex);
-
 	DEBUGLOG("LVM thread function started\n");
 
 	/* Ignore SIGUSR1 & 2 */
@@ -1775,15 +1822,15 @@ static __attribute__ ((noreturn)) void *lvm_thread_fn(void *arg)
 		DEBUGLOG("LVM thread waiting for work\n");
 
 		pthread_mutex_lock(&lvm_thread_mutex);
-		if (list_empty(&lvm_cmd_head))
+		if (dm_list_empty(&lvm_cmd_head))
 			pthread_cond_wait(&lvm_thread_cond, &lvm_thread_mutex);
 
-		list_iterate_safe(cmdl, tmp, &lvm_cmd_head) {
+		dm_list_iterate_safe(cmdl, tmp, &lvm_cmd_head) {
 			struct lvm_thread_cmd *cmd;
 
 			cmd =
-			    list_struct_base(cmdl, struct lvm_thread_cmd, list);
-			list_del(&cmd->list);
+			    dm_list_struct_base(cmdl, struct lvm_thread_cmd, list);
+			dm_list_del(&cmd->list);
 			pthread_mutex_unlock(&lvm_thread_mutex);
 
 			process_work_item(cmd);
@@ -1833,7 +1880,7 @@ static int add_to_lvmqueue(struct local_client *client, struct clvm_header *msg,
 	    ("add_to_lvmqueue: cmd=%p. client=%p, msg=%p, len=%d, csid=%p, xid=%d\n",
 	     cmd, client, msg, msglen, csid, cmd->xid);
 	pthread_mutex_lock(&lvm_thread_mutex);
-	list_add(&lvm_cmd_head, &cmd->list);
+	dm_list_add(&lvm_cmd_head, &cmd->list);
 	pthread_cond_signal(&lvm_thread_cond);
 	pthread_mutex_unlock(&lvm_thread_mutex);
 
@@ -1994,3 +2041,20 @@ int sync_unlock(const char *resource, int lockid)
 	return clops->sync_unlock(resource, lockid);
 }
 
+static if_type_t parse_cluster_interface(char *ifname)
+{
+	if_type_t iface = IF_AUTO;
+
+	if (!strcmp(ifname, "auto"))
+		iface = IF_AUTO;
+	if (!strcmp(ifname, "cman"))
+		iface = IF_CMAN;
+	if (!strcmp(ifname, "gulm"))
+		iface = IF_GULM;
+	if (!strcmp(ifname, "openais"))
+		iface = IF_OPENAIS;
+	if (!strcmp(ifname, "corosync"))
+		iface = IF_COROSYNC;
+
+	return iface;
+}

daemons/clvmd/lvm-functions.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -13,6 +13,10 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <configure.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
@@ -33,7 +37,6 @@
 #include <libdevmapper.h>
 #include <libdlm.h>
 
-#include "list.h"
 #include "lvm-types.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
@@ -43,7 +46,8 @@
 /* LVM2 headers */
 #include "toolcontext.h"
 #include "lvmcache.h"
-#include "log.h"
+#include "lvm-logging.h"
+#include "lvm-globals.h"
 #include "activate.h"
 #include "locking.h"
 #include "archiver.h"
@@ -142,7 +146,7 @@ static const char *decode_flags(unsigned char flags)
 	static char buf[128];
 
 	sprintf(buf, "0x%x (%s%s%s)", flags,
-		flags & LCK_PARTIAL_MODE	  ? "PARTIAL " : "",
+		flags & LCK_PARTIAL_MODE	  ? "PARTIAL_MODE " : "",
 		flags & LCK_MIRROR_NOSYNC_MODE	  ? "MIRROR_NOSYNC " : "",
 		flags & LCK_DMEVENTD_MONITOR_MODE ? "DMEVENTD_MONITOR " : "");
 
@@ -154,32 +158,79 @@ char *get_last_lvm_error()
 	return last_error;
 }
 
-/* Return the mode a lock is currently held at (or -1 if not held) */
-static int get_current_lock(char *resource)
+/*
+ * Hash lock info helpers
+ */
+static struct lv_info *lookup_info(const char *resource)
 {
 	struct lv_info *lvi;
 
 	pthread_mutex_lock(&lv_hash_lock);
 	lvi = dm_hash_lookup(lv_hash, resource);
 	pthread_mutex_unlock(&lv_hash_lock);
-	if (lvi) {
+
+	return lvi;
+}
+
+static void insert_info(const char *resource, struct lv_info *lvi)
+{
+	pthread_mutex_lock(&lv_hash_lock);
+	dm_hash_insert(lv_hash, resource, lvi);
+	pthread_mutex_unlock(&lv_hash_lock);
+}
+
+static void remove_info(const char *resource)
+{
+	pthread_mutex_lock(&lv_hash_lock);
+	dm_hash_remove(lv_hash, resource);
+	pthread_mutex_unlock(&lv_hash_lock);
+}
+
+/*
+ * Return the mode a lock is currently held at (or -1 if not held)
+ */
+static int get_current_lock(char *resource)
+{
+	struct lv_info *lvi;
+
+	if ((lvi = lookup_info(resource)))
 		return lvi->lock_mode;
-	} else {
-		return -1;
-	}
+
+	return -1;
+}
+
+
+void init_lvhash()
+{
+	/* Create hash table for keeping LV locks & status */
+	lv_hash = dm_hash_create(100);
+	pthread_mutex_init(&lv_hash_lock, NULL);
+	pthread_mutex_init(&lvm_lock, NULL);
 }
 
 /* Called at shutdown to tidy the lockspace */
-void unlock_all()
+void destroy_lvhash()
 {
 	struct dm_hash_node *v;
+	struct lv_info *lvi;
+	char *resource;
+	int status;
 
 	pthread_mutex_lock(&lv_hash_lock);
-	dm_hash_iterate(v, lv_hash) {
-		struct lv_info *lvi = dm_hash_get_data(lv_hash, v);
 
-		sync_unlock(dm_hash_get_key(lv_hash, v), lvi->lock_id);
+	dm_hash_iterate(v, lv_hash) {
+		lvi = dm_hash_get_data(lv_hash, v);
+		resource = dm_hash_get_key(lv_hash, v);
+
+		if ((status = sync_unlock(resource, lvi->lock_id)))
+			DEBUGLOG("unlock_all. unlock failed(%d): %s\n",
+				 status,  strerror(errno));
+		free(lvi);
 	}
+
+	dm_hash_destroy(lv_hash);
+	lv_hash = NULL;
+
 	pthread_mutex_unlock(&lv_hash_lock);
 }
 
@@ -192,10 +243,7 @@ int hold_lock(char *resource, int mode, int flags)
 
 	flags &= LKF_NOQUEUE;	/* Only LKF_NOQUEUE is valid here */
 
-	pthread_mutex_lock(&lv_hash_lock);
-	lvi = dm_hash_lookup(lv_hash, resource);
-	pthread_mutex_unlock(&lv_hash_lock);
-	if (lvi) {
+	if ((lvi = lookup_info(resource))) {
 		/* Already exists - convert it */
 		status =
 		    sync_lock(resource, mode, LKF_CONVERT | flags,
@@ -221,11 +269,9 @@ int hold_lock(char *resource, int mode, int flags)
 			free(lvi);
 			DEBUGLOG("hold_lock. lock at %d failed: %s\n", mode,
 				 strerror(errno));
-		} else {
-		        pthread_mutex_lock(&lv_hash_lock);
-			dm_hash_insert(lv_hash, resource, lvi);
-			pthread_mutex_unlock(&lv_hash_lock);
-		}
+		} else
+			insert_info(resource, lvi);
+
 		errno = saved_errno;
 	}
 	return status;
@@ -238,10 +284,7 @@ int hold_unlock(char *resource)
 	int status;
 	int saved_errno;
 
-	pthread_mutex_lock(&lv_hash_lock);
-	lvi = dm_hash_lookup(lv_hash, resource);
-	pthread_mutex_unlock(&lv_hash_lock);
-	if (!lvi) {
+	if (!(lvi = lookup_info(resource))) {
 		DEBUGLOG("hold_unlock, lock not already held\n");
 		return 0;
 	}
@@ -249,9 +292,7 @@ int hold_unlock(char *resource)
 	status = sync_unlock(resource, lvi->lock_id);
 	saved_errno = errno;
 	if (!status) {
-	    	pthread_mutex_lock(&lv_hash_lock);
-		dm_hash_remove(lv_hash, resource);
-		pthread_mutex_unlock(&lv_hash_lock);
+		remove_info(resource);
 		free(lvi);
 	} else {
 		DEBUGLOG("hold_unlock. unlock failed(%d): %s\n", status,
@@ -394,6 +435,26 @@ static int do_deactivate_lv(char *resource, unsigned char lock_flags)
 	return 0;
 }
 
+const char *do_lock_query(char *resource)
+{
+	int mode;
+	const char *type = NULL;
+
+	mode = get_current_lock(resource);
+	switch (mode) {
+		case LKM_NLMODE: type = "NL"; break;
+		case LKM_CRMODE: type = "CR"; break;
+		case LKM_CWMODE: type = "CW"; break;
+		case LKM_PRMODE: type = "PR"; break;
+		case LKM_PWMODE: type = "PW"; break;
+		case LKM_EXMODE: type = "EX"; break;
+	}
+
+	DEBUGLOG("do_lock_query: resource '%s', mode %i (%s)\n", resource, mode, type ?: "?");
+
+	return type;
+}
+
 /* This is the LOCK_LV part that happens on all nodes in the cluster -
    it is responsible for the interaction with device-mapper and LVM */
 int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
@@ -403,25 +464,23 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 	DEBUGLOG("do_lock_lv: resource '%s', cmd = %s, flags = %s\n",
 		 resource, decode_locking_cmd(command), decode_flags(lock_flags));
 
-	pthread_mutex_lock(&lvm_lock);
 	if (!cmd->config_valid || config_files_changed(cmd)) {
 		/* Reinitialise various settings inc. logging, filters */
 		if (do_refresh_cache()) {
 			log_error("Updated config file invalid. Aborting.");
-			pthread_mutex_unlock(&lvm_lock);
 			return EINVAL;
 		}
 	}
 
-	if (lock_flags & LCK_PARTIAL_MODE)
-		init_partial(1);
-
+	pthread_mutex_lock(&lvm_lock);
 	if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
 		init_mirror_in_sync(1);
 
 	if (!(lock_flags & LCK_DMEVENTD_MONITOR_MODE))
 		init_dmeventd_monitor(0);
 
+	cmd->partial_activation = (lock_flags & LCK_PARTIAL_MODE) ? 1 : 0;
+
 	switch (command) {
 	case LCK_LV_EXCLUSIVE:
 		status = do_activate_lv(resource, lock_flags, LKM_EXMODE);
@@ -454,15 +513,14 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 		break;
 	}
 
-	if (lock_flags & LCK_PARTIAL_MODE)
-		init_partial(0);
-
 	if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
 		init_mirror_in_sync(0);
 
 	if (!(lock_flags & LCK_DMEVENTD_MONITOR_MODE))
 		init_dmeventd_monitor(DEFAULT_DMEVENTD_MONITOR);
 
+	cmd->partial_activation = 0;
+
 	/* clean the pool for another command */
 	dm_pool_empty(cmd->mem);
 	pthread_mutex_unlock(&lvm_lock);
@@ -541,9 +599,14 @@ int do_refresh_cache()
 	DEBUGLOG("Refreshing context\n");
 	log_notice("Refreshing context");
 
+	pthread_mutex_lock(&lvm_lock);
+
 	ret = refresh_toolcontext(cmd);
 	init_full_scan_done(0);
 	lvmcache_label_scan(cmd, 2);
+	dm_pool_empty(cmd->mem);
+
+	pthread_mutex_unlock(&lvm_lock);
 
 	return ret==1?0:-1;
 }
@@ -698,14 +761,6 @@ static void check_config()
 	log_error("locking_type not set correctly in lvm.conf, cluster operations will not work.");
 }
 
-void init_lvhash()
-{
-	/* Create hash table for keeping LV locks & status */
-	lv_hash = dm_hash_create(100);
-	pthread_mutex_init(&lv_hash_lock, NULL);
-	pthread_mutex_init(&lvm_lock, NULL);
-}
-
 /* Backups up the LVM metadata if it's changed */
 void lvm_do_backup(const char *vgname)
 {
@@ -714,20 +769,25 @@ void lvm_do_backup(const char *vgname)
 
 	DEBUGLOG("Triggering backup of VG metadata for %s. suspended=%d\n", vgname, suspended);
 
-	vg = vg_read(cmd, vgname, NULL /*vgid*/, &consistent);
-	if (vg) {
-		if (consistent)
-			check_current_backup(vg);
-	}
-	else {
+	pthread_mutex_lock(&lvm_lock);
+
+	vg = vg_read_internal(cmd, vgname, NULL /*vgid*/, &consistent);
+
+	if (vg && consistent)
+		check_current_backup(vg);
+	else
 		log_error("Error backing up metadata, can't find VG for group %s", vgname);
-	}
+
+	vg_release(vg);
+	dm_pool_empty(cmd->mem);
+
+	pthread_mutex_unlock(&lvm_lock);
 }
 
 /* Called to initialise the LVM context of the daemon */
 int init_lvm(int using_gulm)
 {
-	if (!(cmd = create_toolcontext(NULL, 0, 1))) {
+	if (!(cmd = create_toolcontext(1, NULL))) {
 		log_error("Failed to allocate command context");
 		return 0;
 	}
@@ -735,12 +795,7 @@ int init_lvm(int using_gulm)
 	/* Use LOG_DAEMON for syslog messages instead of LOG_USER */
 	init_syslog(LOG_DAEMON);
 	openlog("clvmd", LOG_PID, LOG_DAEMON);
-	init_debug(cmd->current_settings.debug);
-	init_verbose(cmd->current_settings.verbose + VERBOSE_BASE_LEVEL);
-	set_activation(cmd->current_settings.activation);
-	archive_enable(cmd, cmd->current_settings.archive);
-	backup_enable(cmd, cmd->current_settings.backup);
-	cmd->cmd_line = (char *)"clvmd";
+	cmd->cmd_line = "clvmd";
 
 	/* Check lvm.conf is setup for cluster-LVM */
 	check_config();
@@ -756,3 +811,10 @@ int init_lvm(int using_gulm)
 
 	return 1;
 }
+
+void destroy_lvm(void)
+{
+	if (cmd)
+		destroy_toolcontext(cmd);
+	cmd = NULL;
+}

daemons/clvmd/lvm-functions.h

@@ -22,16 +22,18 @@ extern int pre_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
 		       char *resource);
 extern int do_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
 		      char *resource);
+extern const char *do_lock_query(char *resource);
 extern int post_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
 			char *resource);
 extern int do_check_lvm1(const char *vgname);
 extern int do_refresh_cache(void);
 extern int init_lvm(int using_gulm);
+extern void destroy_lvm(void);
 extern void init_lvhash(void);
+extern void destroy_lvhash(void);
 extern void lvm_do_backup(const char *vgname);
 extern int hold_unlock(char *resource);
 extern int hold_lock(char *resource, int mode, int flags);
-extern void unlock_all(void);
 extern char *get_last_lvm_error(void);
 extern void drop_metadata(const char *vgname);
 

daemons/clvmd/refresh_clvmd.c

@@ -18,6 +18,10 @@
  *
  */
 
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <configure.h>
 #include <stddef.h>
 #include <sys/socket.h>
 #include <sys/un.h>

daemons/clvmd/tcp-comms.c

@@ -13,7 +13,10 @@
    It can also make outgoing connnections to the other clvmd nodes.
 */
 
+#define _GNU_SOURCE
+#define _FILE_OFFSET_BITS 64
 
+#include <configure.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <sys/utsname.h>

daemons/dmeventd/Makefile.in

@@ -17,7 +17,10 @@ VPATH = @srcdir@
 
 SOURCES = libdevmapper-event.c
 
+ifeq ("@STATIC_LINK@", "yes")
 LIB_STATIC = libdevmapper-event.a
+endif
+LIB_VERSION = $(LIB_VERSION_DM)
 
 ifeq ("@LIB_SUFFIX@","dylib")
   LIB_SHARED = libdevmapper-event.dylib
@@ -29,7 +32,14 @@ endif
 TARGETS = dmeventd
 CLEAN_TARGETS = dmeventd.o
 
-include ../make.tmpl
+ifneq ($(MAKECMDGOALS),device-mapper)
+  SUBDIRS+=plugins
+endif
+
+include $(top_srcdir)/make.tmpl
+
+all: dmeventd
+device-mapper: dmeventd $(LIB_STATIC)
 
 LDFLAGS += -ldl -ldevmapper -lpthread
 CLDFLAGS += -ldl -ldevmapper -lpthread
@@ -53,6 +63,8 @@ endif
 
 install: $(INSTALL_TYPE) install_include install_dmeventd
 
+install_device-mapper: $(INSTALL_TYPE) install_include install_dmeventd
+
 install_include:
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 444 libdevmapper-event.h \
 		$(includedir)/libdevmapper-event.h

daemons/dmeventd/dmeventd.c

@@ -22,10 +22,9 @@
 #include "configure.h"
 #include "libdevmapper.h"
 #include "libdevmapper-event.h"
-#include "list.h"
 #include "dmeventd.h"
 //#include "libmultilog.h"
-#include "log.h"
+#include "dm-logging.h"
 
 #include <dlfcn.h>
 #include <errno.h>
@@ -58,11 +57,11 @@ static volatile sig_atomic_t _thread_registries_empty = 1;	/* registries are emp
 static int _debug = 0;
 
 /* List (un)link macros. */
-#define	LINK(x, head)		list_add(head, &(x)->list)
+#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)		list_del(&(x)->list)
+#define	UNLINK(x)		dm_list_del(&(x)->list)
 #define	UNLINK_DSO(x)		UNLINK(x)
 #define	UNLINK_THREAD(x)	UNLINK(x)
 
@@ -101,7 +100,7 @@ static pthread_mutex_t _global_mutex;
 
 /* Data kept about a DSO. */
 struct dso_data {
-	struct list list;
+	struct dm_list list;
 
 	char *dso_name;		/* DSO name (eg, "evms", "dmraid", "lvm2"). */
 
@@ -143,7 +142,7 @@ struct dso_data {
 	int (*unregister_device)(const char *device, const char *uuid,
 				 int major, int minor, void **user);
 };
-static LIST_INIT(_dso_registry);
+static DM_LIST_INIT(_dso_registry);
 
 /* Structure to keep parsed register variables from client message. */
 struct message_data {
@@ -168,7 +167,7 @@ struct message_data {
  * occurs and the event processing function of the DSO gets called.
  */
 struct thread_status {
-	struct list list;
+	struct dm_list list;
 
 	pthread_t thread;
 
@@ -189,14 +188,14 @@ struct thread_status {
 	struct dm_task *current_task;
 	time_t next_time;
 	uint32_t timeout;
-	struct list timeout_list;
+	struct dm_list timeout_list;
 	void *dso_private; /* dso per-thread status variable */
 };
-static LIST_INIT(_thread_registry);
-static LIST_INIT(_thread_registry_unused);
+static DM_LIST_INIT(_thread_registry);
+static DM_LIST_INIT(_thread_registry_unused);
 
 static int _timeout_running;
-static LIST_INIT(_timeout_registry);
+static DM_LIST_INIT(_timeout_registry);
 static pthread_mutex_t _timeout_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t _timeout_cond = PTHREAD_COND_INITIALIZER;
 
@@ -239,7 +238,7 @@ static struct thread_status *_alloc_thread_status(struct message_data *data,
 	ret->dso_data = dso_data;
 	ret->events = data->events.field;
 	ret->timeout = data->timeout.secs;
-	list_init(&ret->timeout_list);
+	dm_list_init(&ret->timeout_list);
 
 	return ret;
 }
@@ -459,7 +458,7 @@ static struct thread_status *_lookup_thread_status(struct message_data *data)
 {
 	struct thread_status *thread;
 
-	list_iterate_items(thread, &_thread_registry)
+	dm_list_iterate_items(thread, &_thread_registry)
 	    if (!strcmp(data->device_uuid, thread->device.uuid))
 		return thread;
 
@@ -489,13 +488,13 @@ static void *_timeout_thread(void *unused __attribute((unused)))
 	pthread_cleanup_push(_exit_timeout, NULL);
 	pthread_mutex_lock(&_timeout_mutex);
 
-	while (!list_empty(&_timeout_registry)) {
+	while (!dm_list_empty(&_timeout_registry)) {
 		struct thread_status *thread;
 
 		timeout.tv_sec = 0;
 		curr_time = time(NULL);
 
-		list_iterate_items_gen(thread, &_timeout_registry, timeout_list) {
+		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);
@@ -522,8 +521,8 @@ static int _register_for_timeout(struct thread_status *thread)
 
 	thread->next_time = time(NULL) + thread->timeout;
 
-	if (list_empty(&thread->timeout_list)) {
-		list_add(&_timeout_registry, &thread->timeout_list);
+	if (dm_list_empty(&thread->timeout_list)) {
+		dm_list_add(&_timeout_registry, &thread->timeout_list);
 		if (_timeout_running)
 			pthread_cond_signal(&_timeout_cond);
 	}
@@ -543,9 +542,9 @@ static int _register_for_timeout(struct thread_status *thread)
 static void _unregister_for_timeout(struct thread_status *thread)
 {
 	pthread_mutex_lock(&_timeout_mutex);
-	if (!list_empty(&thread->timeout_list)) {
-		list_del(&thread->timeout_list);
-		list_init(&thread->timeout_list);
+	if (!dm_list_empty(&thread->timeout_list)) {
+		dm_list_del(&thread->timeout_list);
+		dm_list_init(&thread->timeout_list);
 	}
 	pthread_mutex_unlock(&_timeout_mutex);
 }
@@ -698,7 +697,7 @@ static void _monitor_unregister(void *arg)
 	}
 	/* we may have been relinked to unused registry since we were
 	   called, so check that */
-	list_iterate_items(thread_iter, &_thread_registry_unused)
+	dm_list_iterate_items(thread_iter, &_thread_registry_unused)
 		if (thread_iter == thread) {
 			thread->status = DM_THREAD_DONE;
 			_unlock_mutex();
@@ -839,7 +838,7 @@ static struct dso_data *_lookup_dso(struct message_data *data)
 {
 	struct dso_data *dso_data, *ret = NULL;
 
-	list_iterate_items(dso_data, &_dso_registry)
+	dm_list_iterate_items(dso_data, &_dso_registry)
 	    if (!strcmp(data->dso_name, dso_data->dso_name)) {
 		_lib_get(dso_data);
 		ret = dso_data;
@@ -1110,7 +1109,7 @@ static int _get_registered_dev(struct message_data *message_data, int next)
 	_lock_mutex();
 
 	/* Iterate list of threads checking if we want a particular one. */
-	list_iterate_items(thread, &_thread_registry)
+	dm_list_iterate_items(thread, &_thread_registry)
 		if (_want_registered_device(message_data->dso_name,
 					    message_data->device_uuid,
 					    thread)) {
@@ -1133,10 +1132,10 @@ static int _get_registered_dev(struct message_data *message_data, int next)
 	thread = hit;
 
 	while (1) {
-		if (list_end(&_thread_registry, &thread->list))
+		if (dm_list_end(&_thread_registry, &thread->list))
 			goto out;
 
-		thread = list_item(thread->list.n, struct thread_status);
+		thread = dm_list_item(thread->list.n, struct thread_status);
 		if (_want_registered_device(message_data->dso_name, NULL, thread)) {
 			hit = thread;
 			break;
@@ -1440,12 +1439,12 @@ static void _process_request(struct dm_event_fifos *fifos)
 static void _cleanup_unused_threads(void)
 {
 	int ret;
-	struct list *l;
+	struct dm_list *l;
 	struct thread_status *thread;
 
 	_lock_mutex();
-	while ((l = list_first(&_thread_registry_unused))) {
-		thread = list_item(l, struct thread_status);
+	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 */
 
@@ -1470,7 +1469,7 @@ static void _cleanup_unused_threads(void)
 				break;
 			}
 
-			list_del(l);
+			dm_list_del(l);
 			syslog(LOG_ERR,
 			       "thread can't be on unused list unless !thread->events");
 			thread->status = DM_THREAD_RUNNING;
@@ -1480,7 +1479,7 @@ static void _cleanup_unused_threads(void)
 		}
 
 		if (thread->status == DM_THREAD_DONE) {
-			list_del(l);
+			dm_list_del(l);
 			pthread_join(thread->thread, NULL);
 			_lib_put(thread->dso_data);
 			_free_thread_status(thread);
@@ -1741,8 +1740,8 @@ int main(int argc, char *argv[])
 	while (!_exit_now) {
 		_process_request(&fifos);
 		_cleanup_unused_threads();
-		if (!list_empty(&_thread_registry)
-		    || !list_empty(&_thread_registry_unused))
+		if (!dm_list_empty(&_thread_registry)
+		    || !dm_list_empty(&_thread_registry_unused))
 			_thread_registries_empty = 0;
 		else
 			_thread_registries_empty = 1;

daemons/dmeventd/libdevmapper-event.c

@@ -12,7 +12,7 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "lib.h"
+#include "dmlib.h"
 #include "libdevmapper-event.h"
 //#include "libmultilog.h"
 #include "dmeventd.h"
@@ -425,6 +425,12 @@ static int _start_daemon(struct dm_event_fifos *fifos)
 
       start_server:
 	/* server is not running */
+
+	if (!strncmp(DMEVENTD_PATH, "/", 1) && stat(DMEVENTD_PATH, &statbuf)) {
+		log_error("Unable to find dmeventd.");
+		return_0;
+	}
+
 	pid = fork();
 
 	if (pid < 0)
@@ -432,7 +438,7 @@ static int _start_daemon(struct dm_event_fifos *fifos)
 
 	else if (!pid) {
 		execvp(DMEVENTD_PATH, NULL);
-		exit(EXIT_FAILURE);
+		_exit(EXIT_FAILURE);
 	} else {
 		if (waitpid(pid, &status, 0) < 0)
 			log_error("Unable to start dmeventd: %s",

daemons/dmeventd/plugins/mirror/Makefile.in

@@ -27,9 +27,13 @@ else
   LIB_SHARED = libdevmapper-event-lvm2mirror.so
 endif
 
+LIB_VERSION = $(LIB_VERSION_LVM)
+
 include $(top_srcdir)/make.tmpl
 
-install: libdevmapper-event-lvm2mirror.$(LIB_SUFFIX)
+install_lvm2: libdevmapper-event-lvm2mirror.$(LIB_SUFFIX)
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
 		$(libdir)/$<.$(LIB_VERSION)
 	$(LN_S) -f $<.$(LIB_VERSION) $(libdir)/$<
+
+install: install_lvm2

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -13,6 +13,7 @@
  */
 
 #include "lvm2cmd.h"
+#include "errors.h"
 
 #include <libdevmapper.h>
 #include <libdevmapper-event.h>
@@ -152,7 +153,7 @@ static int _remove_failed_devices(const char *device)
 	}
 
 	/* FIXME Is any sanity-checking required on %s? */
-	if (CMD_SIZE <= snprintf(cmd_str, CMD_SIZE, "vgreduce --config devices{ignore_suspended_devices=1} --removemissing %s", vg)) {
+	if (CMD_SIZE <= snprintf(cmd_str, CMD_SIZE, "lvconvert --config devices{ignore_suspended_devices=1} --repair --use-policies %s/%s", vg, lv)) {
 		/* this error should be caught above, but doesn't hurt to check again */
 		syslog(LOG_ERR, "Unable to form LVM command: Device name too long");
 		dm_pool_empty(_mem_pool);  /* FIXME: not safe with multiple threads */
@@ -161,8 +162,14 @@ static int _remove_failed_devices(const char *device)
 
 	r = lvm2_run(_lvm_handle, cmd_str);
 
+	if (r == ECMD_PROCESSED) {
+		snprintf(cmd_str, CMD_SIZE, "vgreduce --removemissing %s", vg);
+		if (lvm2_run(_lvm_handle, cmd_str) != 1)
+			syslog(LOG_ERR, "Unable to remove failed PVs from VG %s", vg);
+	}
+
 	dm_pool_empty(_mem_pool);  /* FIXME: not safe with multiple threads */
-	return (r == 1) ? 0 : -1;
+	return (r == ECMD_PROCESSED) ? 0 : -1;
 }
 
 void process_event(struct dm_task *dmt,

daemons/dmeventd/plugins/snapshot/Makefile.in

@@ -27,9 +27,13 @@ else
   LIB_SHARED = libdevmapper-event-lvm2snapshot.so
 endif
 
+LIB_VERSION = $(LIB_VERSION_LVM)
+
 include $(top_srcdir)/make.tmpl
 
-install: libdevmapper-event-lvm2snapshot.$(LIB_SUFFIX)
+install_lvm2: libdevmapper-event-lvm2snapshot.$(LIB_SUFFIX)
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
 		$(libdir)/$<.$(LIB_VERSION)
 	$(LN_S) -f $<.$(LIB_VERSION) $(libdir)/$<
+
+install: install_lvm2

daemons/dmeventd/plugins/snapshot/dmeventd_snapshot.c

@@ -99,24 +99,6 @@ static void _parse_snapshot_params(char *params, struct snap_status *stat)
 	stat->max = atoi(p);
 }
 
-/* send unregister command to itself */
-static void _unregister_self(struct dm_task *dmt)
-{
-	const char *name = dm_task_get_name(dmt);
-	struct dm_event_handler *dmevh;
-
-	if (!(dmevh = dm_event_handler_create()))
-		return;
-
-	if (dm_event_handler_set_dev_name(dmevh, name))
-		goto fail;
-
-	dm_event_handler_set_event_mask(dmevh, DM_EVENT_ALL_ERRORS|DM_EVENT_TIMEOUT);
-	dm_event_unregister_handler(dmevh);
-fail:
-	dm_event_handler_destroy(dmevh);
-}
-
 void process_event(struct dm_task *dmt,
 		   enum dm_event_mask event __attribute((unused)),
 		   void **private)
@@ -149,7 +131,6 @@ void process_event(struct dm_task *dmt,
 	 */
 	if (stat.invalid || !stat.max) {
 		syslog(LOG_ERR, "Snapshot %s changed state to: %s\n", device, params);
-		_unregister_self(dmt);
 		*percent_warning = 0;
 		goto out;
 	}

debian/README.Debian

@@ -1,6 +0,0 @@
-LVM2 requires the device-mapper kernel module (dm-mod).  This is
-available as a kernel patch for 2.4 (in kernel-patch-device-mapper), and
-is distributed with linux 2.5 and above.  The LVM1 kernel module (lvm-mod)
-will not work with lvm2 packages.  dm-mod and lvm-mod may both be loaded
-in the kernel at the same time with no problems.  Without dm-mod, this
-package is pretty useless.

debian/changelog

@@ -1,82 +0,0 @@
-lvm2 (1.95.15-1) unstable; urgency=low
-  
-  * New upstream release.
-  * Remove undocumented manpage symlinks.
-  * Update description to be more informative.  (Closes: #173499)
-  * Add kernel-patch-device-mapper suggestion.
-  * Update standards version.
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Sun, 16 Feb 2002 04:21:26 -0400
-
-lvm2 (1.95.11-1) unstable; urgency=low
-
-  * New upstream release.  (Closes: #171436)
-  * Removed TODO and INTRO from debian/docs; added WHATS_NEW.
-  * Remove vgcfgrestore.8 undocumented symlink.
-  * Added a README.Debian, mentioning the device-mapper kernel module
-    requirement that lvm2 has.  (Closes: #171674, #163020)
-  * Get rid of debian/conffiles (debhelper's smart enough to figure that out).
-  * debian/copyright fix to appease lintian.
-  * Fix typo in tools/commands.h that caused /usr/sbin/; to be created.
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Mon,  9 Dec 2002 02:51:02 -0400
-
-lvm2 (1.95.10-2) unstable; urgency=low
-
-  * Fix software raid problems by ensuring lvm init script runs after
-    raidtools init script.  (Closes: #152569)
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Tue,  3 Sep 2002 04:05:43 -0400
-
-lvm2 (1.95.10-1) unstable; urgency=low
-
-  * New upstream release (Beta 3.2).
-  * Change all references to /dev/device-mapper/control to
-    /dev/mapper/control.
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Sun,  1 Sep 2002 18:55:12 -0400
-
-lvm2 (0.95.05-3) unstable; urgency=low
-
-  * Get rid of awk dependency in init script.  (Closes: #146257)
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Sun, 12 May 2002 04:39:06 -0500
-
-lvm2 (0.95.05-2) unstable; urgency=low
-
-  * Use ${shlibs:Depends} in Depends.
-  * Get rid of postinst/postrm scripts, use debhelper's init script instead.
-  * Add Conflicts against lvm10, lvm-common.
-  * Fix endian issues on big-endian machines.
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Thu,  2 May 2002 23:53:53 -0500
-
-lvm2 (0.95.05-1) unstable; urgency=low
-
-  * New release (Beta2).
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Thu, 25 Apr 2002 00:37:41 -0500
-
-lvm2 (0.95.04cvs20020306-1) unstable; urgency=low
-
-  * CVS updated.
-  * Convert from debian native package.
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Wed,  6 Mar 2002 00:43:21 -0500
-
-lvm2 (0.95.04cvs20020304) unstable; urgency=low
-
-  * CVS updated.
-  * Enhance init script; create devmapper control device, etc.
-  * Add dmsetup as a suggestion.
-  * Add /etc/lvm/lvm.conf conffile.
-  * Add undocumented(7) for the commands missing manpages.
-  
- -- Andres Salomon <dilinger@mp3revolution.net>  Mon,  4 Mar 2002 04:51:26 -0500
-
-lvm2 (0.95.02cvs20020220) unstable; urgency=low
-
-  * Initial Release.
-
- -- Andres Salomon <dilinger@mp3revolution.net>  Wed, 20 Feb 2002 03:17:25 -0500
-

debian/control

@@ -1,24 +0,0 @@
-Source: lvm2
-Section: admin
-Priority: optional
-Maintainer: Andres Salomon <dilinger@mp3revolution.net>
-Build-Depends: debhelper (>> 3.0.0), libdevmapper-dev (>= 0.96.04), libreadline4-dev
-Standards-Version: 3.5.8.0
-
-Package: lvm2
-Architecture: any
-Depends: ${shlibs:Depends}
-Conflicts: lvm10, lvm-common
-Replaces: lvm10, lvm-common
-Provides: lvm-binaries
-Suggests: dmsetup, kernel-patch-device-mapper
-Description: The Linux Logical Volume Manager
- This is LVM2, the rewrite of The Linux Logical Volume Manager.  LVM
- supports enterprise level volume management of disk and disk subsystems
- by grouping arbitrary disks into volume groups. The total capacity of
- volume groups can be allocated to logical volumes, which are accessed as
- regular block devices.
- .
- LVM2 is currently stable, but has some unimplemented features (most notably,
- pvmove and e2fsadm).  It is not yet recommended for production use.  It is
- backwards-compatible with LVM1 (lvm10), and requires Linux kernel 2.4.

debian/copyright

@@ -1,25 +0,0 @@
-This package was debianized by Andres Salomon <dilinger@mp3revolution.net> on
-Wed, 20 Feb 2002 03:17:25 -0500.
-
-It was downloaded from http://www.sistina.com/products_lvm.htm
-
-Upstream Author: LVM Development Team
-
-Copyright (c) 2001-2002 LVM Development Team
-
-LVM2 is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-LVM2 is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
-
-On Debian systems, the full text of the GPL can be found in
-/usr/share/common-licenses/GPL

debian/dirs

@@ -1,4 +0,0 @@
-etc/lvm
-usr/share/man/man5
-usr/share/man/man8
-sbin

debian/docs

@@ -1,5 +0,0 @@
-BUGS
-README
-VERSION
-WHATS_NEW
-doc/*

debian/init.d

@@ -1,64 +0,0 @@
-#! /bin/sh
-#
-# lvm2		This script handles LVM2 initialization/shutdown.
-#
-#		Written by Andres Salomon <dilinger@mp3revolution.net>.
-#
-
-PATH=/sbin:/bin:/usr/sbin:/usr/bin
-NAME=lvm2
-DESC=LVM
-
-test -x /sbin/vgchange || exit 0
-modprobe dm-mod >/dev/null 2>&1
-
-# Create necessary files in /dev for device-mapper
-create_devfiles() {
-	DIR="/dev/mapper"
-	FILE="$DIR/control"
-	major=$(grep "[0-9] misc$" /proc/devices | sed 's/[ ]\+misc//')
-	minor=$(grep "[0-9] device-mapper$" /proc/misc | sed 's/[ ]\+device-mapper//')
-
-	if test ! -d $DIR; then
-		mkdir --mode=755 $DIR >/dev/null 2>&1
-	fi
-
-	if test ! -c $FILE -a ! -z "$minor"; then
-		mknod --mode=600 $FILE c $major $minor >/dev/null 2>&1
-	fi
-}
-
-case "$1" in
-  start)
-	echo -n "Initializing $DESC: "
-	create_devfiles
-	vgchange -a y
-
-#	# Mount all LVM devices
-#	for vg in $( vgchange -a y 2>/dev/null | grep active | awk -F\" '{print $2}' ); do
-#		MTPT=$( grep $vg /etc/fstab | awk '{print $2}' )
-#		mount $MTPT
-#	done
-	echo "$NAME."
-	;;
-  stop)
-	echo -n "Shutting down $DESC: "
-	# We don't really try all that hard to shut it down; far too many
-	# things that can keep it from successfully shutting down.
-	vgchange -a n
-	echo "$NAME."
-	;;
-  restart|force-reload)
-	echo -n "Restarting $DESC: "
-	vgchange -a n
-	sleep 1
-	vgchange -a y
-	echo "$NAME."
-	;;
-  *)
-	echo "Usage: /etc/init.d/$NAME {start|stop|restart|force-reload}" >&2
-	exit 1
-	;;
-esac
-
-exit 0

debian/manpages

@@ -1,26 +0,0 @@
-debian/lvm2/usr/share/man/man5/lvm.conf.5
-debian/lvm2/usr/share/man/man8/lvchange.8
-debian/lvm2/usr/share/man/man8/lvcreate.8
-debian/lvm2/usr/share/man/man8/lvdisplay.8
-debian/lvm2/usr/share/man/man8/lvextend.8
-debian/lvm2/usr/share/man/man8/lvm.8
-debian/lvm2/usr/share/man/man8/lvmchange.8
-debian/lvm2/usr/share/man/man8/lvreduce.8
-debian/lvm2/usr/share/man/man8/lvremove.8
-debian/lvm2/usr/share/man/man8/lvrename.8
-debian/lvm2/usr/share/man/man8/lvscan.8
-debian/lvm2/usr/share/man/man8/pvchange.8
-debian/lvm2/usr/share/man/man8/pvcreate.8
-debian/lvm2/usr/share/man/man8/pvdisplay.8
-debian/lvm2/usr/share/man/man8/pvscan.8
-debian/lvm2/usr/share/man/man8/vgcfgbackup.8
-debian/lvm2/usr/share/man/man8/vgchange.8
-debian/lvm2/usr/share/man/man8/vgck.8
-debian/lvm2/usr/share/man/man8/vgcreate.8
-debian/lvm2/usr/share/man/man8/vgdisplay.8
-debian/lvm2/usr/share/man/man8/vgextend.8
-debian/lvm2/usr/share/man/man8/vgmerge.8
-debian/lvm2/usr/share/man/man8/vgreduce.8
-debian/lvm2/usr/share/man/man8/vgremove.8
-debian/lvm2/usr/share/man/man8/vgrename.8
-debian/lvm2/usr/share/man/man8/vgscan.8

debian/rules

@@ -1,119 +0,0 @@
-#!/usr/bin/make -f
-# Sample debian/rules that uses debhelper. 
-# GNU copyright 1997 by Joey Hess.
-#
-# This version is for a hypothetical package that builds an
-# architecture-dependant package, as well as an architecture-independent
-# package.
-
-# Uncomment this to turn on verbose mode. 
-#export DH_VERBOSE=1
-
-# This is the debhelper compatibility version to use.
-export DH_COMPAT=3
-
-# These are used for cross-compiling and for saving the configure script
-# from having to guess our platform (since we know it already)
-DEB_HOST_GNU_TYPE   ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
-DEB_BUILD_GNU_TYPE  ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)
-
-ifneq (,$(findstring debug,$(DEB_BUILD_OPTIONS)))
-	CFLAGS += -g
-endif
-ifeq (,$(findstring nostrip,$(DEB_BUILD_OPTIONS)))
-	INSTALL_PROGRAM += -s
-endif
-
-configure: configure-stamp
-configure-stamp:
-	dh_testdir
-	# Add here commands to configure the package.
-	./configure --host=$(DEB_HOST_GNU_TYPE) --build=$(DEB_BUILD_GNU_TYPE) --prefix=/ --mandir=\$${prefix}/usr/share/man --infodir=\$${prefix}/usr/share/info
-
-	touch configure-stamp
-
-build-arch: configure-stamp build-arch-stamp
-build-arch-stamp:
-	dh_testdir
-
-	# Add here command to compile/build the package.
-	$(MAKE)
-
-	touch build-arch-stamp
-
-build-indep: configure-stamp build-indep-stamp
-build-indep-stamp:
-	dh_testdir
-
-	# Add here command to compile/build the arch indep package.
-	# It's ok not to do anything here, if you don't need to build
-	#  anything for this package.
-	#/usr/bin/docbook-to-man debian/lvm2.sgml > lvm2.1
-
-	touch build-indep-stamp
-
-build: build-arch build-indep
-
-clean:
-	dh_testdir
-	dh_testroot
-	rm -f build-stamp configure-stamp
-
-	# Add here commands to clean up after the build process.
-	-$(MAKE) distclean
-	-test -r /usr/share/misc/config.sub && \
-	  cp -f /usr/share/misc/config.sub config.sub
-	-test -r /usr/share/misc/config.guess && \
-	  cp -f /usr/share/misc/config.guess config.guess
-
-
-	dh_clean
-
-install: DH_OPTIONS=
-install: build
-	dh_testdir
-	dh_testroot
-	dh_clean -k
-	dh_installdirs
-
-	# Add here commands to install the package into debian/lvm2.
-	$(MAKE) install prefix=$(CURDIR)/debian/lvm2
-	install -m 0644 doc/example.conf debian/lvm2/etc/lvm/lvm.conf
-
-
-# Build architecture-independent files here.
-# Pass -i to all debhelper commands in this target to reduce clutter.
-binary-indep: build install
-# nada.
-
-# Build architecture-dependent files here.
-binary-arch: build install
-	dh_testdir
-	dh_testroot
-
-#	dh_installdebconf
-	dh_installdocs
-	dh_installexamples
-#	dh_installlogrotate -a
-#	dh_installemacsen -a
-#	dh_installpam -a
-#	dh_installmime -a
-	dh_installinit --update-rcd-params="start 26 S . start 50 0 6 ."
-	dh_installcron
-	dh_installman
-	dh_installinfo 
-	dh_installchangelogs
-	dh_strip
-	dh_link
-	dh_compress
-	dh_fixperms
-	dh_makeshlibs
-	dh_installdeb
-#	dh_perl -a
-	dh_shlibdeps
-	dh_gencontrol
-	dh_md5sums
-	dh_builddeb
-
-binary: binary-indep binary-arch
-.PHONY: build clean binary-indep binary-arch binary install configure

dmeventd/mirror/.exported_symbols

@@ -1,3 +0,0 @@
-process_event
-register_device
-unregister_device

dmeventd/mirror/Makefile.in

@@ -1,35 +0,0 @@
-#
-# Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
-# Copyright (C) 2004-2005, 2008 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 General Public License v.2.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software Foundation,
-# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-srcdir = @srcdir@
-top_srcdir = @top_srcdir@
-VPATH = @srcdir@
-
-INCLUDES += -I${top_srcdir}/tools
-CLDFLAGS += -L${top_srcdir}/tools -ldevmapper @LVM2CMD_LIB@
-
-SOURCES = dmeventd_mirror.c
-
-ifeq ("@LIB_SUFFIX@","dylib")
-  LIB_SHARED = libdevmapper-event-lvm2mirror.dylib
-else
-  LIB_SHARED = libdevmapper-event-lvm2mirror.so
-endif
-
-include $(top_srcdir)/make.tmpl
-
-install: libdevmapper-event-lvm2mirror.$(LIB_SUFFIX)
-	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
-		$(libdir)/$<.$(LIB_VERSION)
-	$(LN_S) -f $<.$(LIB_VERSION) $(libdir)/$<

dmeventd/mirror/dmeventd_mirror.c

@@ -1,289 +0,0 @@
-/*
- * Copyright (C) 2005 Red Hat, Inc. All rights reserved.
- *
- * This file is part of LVM2.
- *
- * This copyrighted material is made available to anyone wishing to use,
- * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU Lesser General Public License v.2.1.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include "lvm2cmd.h"
-
-#include <libdevmapper.h>
-#include <libdevmapper-event.h>
-#include <errno.h>
-#include <signal.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <unistd.h>
-
-#include <syslog.h> /* FIXME Replace syslog with multilog */
-/* FIXME Missing openlog? */
-
-#define ME_IGNORE    0
-#define ME_INSYNC    1
-#define ME_FAILURE   2
-
-/*
- * register_device() is called first and performs initialisation.
- * Only one device may be registered or unregistered at a time.
- */
-static pthread_mutex_t _register_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-/*
- * Number of active registrations.
- */
-static int _register_count = 0;
-
-static struct dm_pool *_mem_pool = NULL;
-static void *_lvm_handle = NULL;
-
-/*
- * Currently only one event can be processed at a time.
- */
-static pthread_mutex_t _event_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static int _get_mirror_event(char *params)
-{
-	int i, r = ME_INSYNC;
-	char **args = NULL;
-	char *dev_status_str;
-	char *log_status_str;
-	char *sync_str;
-	char *p = NULL;
-	int log_argc, num_devs;
-
-	/*
-	 * dm core parms:	     0 409600 mirror
-	 * Mirror core parms:	     2 253:4 253:5 400/400
-	 * New-style failure params: 1 AA
-	 * New-style log params:     3 cluster 253:3 A
-	 *			 or  3 disk 253:3 A
-	 *			 or  1 core
-	 */
-
-	/* number of devices */
-	if (!dm_split_words(params, 1, 0, &p))
-		goto out_parse;
-
-	if (!(num_devs = atoi(p)))
-		goto out_parse;
-	p += strlen(p) + 1;
-
-	/* devices names + "400/400" + "1 AA" + 1 or 3 log parms + NULL */
-	args = dm_malloc((num_devs + 7) * sizeof(char *));
-	if (!args || dm_split_words(p, num_devs + 7, 0, args) < num_devs + 5)
-		goto out_parse;
-
-	dev_status_str = args[2 + num_devs];
-	log_argc = atoi(args[3 + num_devs]);
-	log_status_str = args[3 + num_devs + log_argc];
-	sync_str = args[num_devs];
-
-	/* Check for bad mirror devices */
-	for (i = 0; i < num_devs; i++)
-		if (dev_status_str[i] == 'D') {
-			syslog(LOG_ERR, "Mirror device, %s, has failed.\n", args[i]);
-			r = ME_FAILURE;
-		}
-
-	/* Check for bad disk log device */
-	if (log_argc > 1 && log_status_str[0] == 'D') {
-		syslog(LOG_ERR, "Log device, %s, has failed.\n",
-		       args[2 + num_devs + log_argc]);
-		r = ME_FAILURE;
-	}
-
-	if (r == ME_FAILURE)
-		goto out;
-
-	p = strstr(sync_str, "/");
-	if (p) {
-		p[0] = '\0';
-		if (strcmp(sync_str, p+1))
-			r = ME_IGNORE;
-		p[0] = '/';
-	} else
-		goto out_parse;
-
-out:
-	if (args)
-		dm_free(args);
-	return r;
-	
-out_parse:
-	if (args)
-		dm_free(args);
-	syslog(LOG_ERR, "Unable to parse mirror status string.");
-	return ME_IGNORE;
-}
-
-static void _temporary_log_fn(int level, const char *file __attribute((unused)),
-			      int line __attribute((unused)),
-			      const char *format)
-{
-	if (!strncmp(format, "WARNING: ", 9) && (level < 5))
-		syslog(LOG_CRIT, "%s", format);
-	else
-		syslog(LOG_DEBUG, "%s", format);
-}
-
-static int _remove_failed_devices(const char *device)
-{
-	int r;
-#define CMD_SIZE 256	/* FIXME Use system restriction */
-	char cmd_str[CMD_SIZE];
-	char *vg = NULL, *lv = NULL, *layer = NULL;
-
-	if (strlen(device) > 200)  /* FIXME Use real restriction */
-		return -ENAMETOOLONG;	/* FIXME These return code distinctions are not used so remove them! */
-
-	if (!dm_split_lvm_name(_mem_pool, device, &vg, &lv, &layer)) {
-		syslog(LOG_ERR, "Unable to determine VG name from %s",
-		       device);
-		return -ENOMEM;	/* FIXME Replace with generic error return - reason for failure has already got logged */
-	}
-
-	/* FIXME Is any sanity-checking required on %s? */
-	if (CMD_SIZE <= snprintf(cmd_str, CMD_SIZE, "vgreduce --config devices{ignore_suspended_devices=1} --removemissing %s", vg)) {
-		/* this error should be caught above, but doesn't hurt to check again */
-		syslog(LOG_ERR, "Unable to form LVM command: Device name too long");
-		dm_pool_empty(_mem_pool);  /* FIXME: not safe with multiple threads */
-		return -ENAMETOOLONG; /* FIXME Replace with generic error return - reason for failure has already got logged */
-	}
-
-	r = lvm2_run(_lvm_handle, cmd_str);
-
-	dm_pool_empty(_mem_pool);  /* FIXME: not safe with multiple threads */
-	return (r == 1) ? 0 : -1;
-}
-
-void process_event(struct dm_task *dmt,
-		   enum dm_event_mask event __attribute((unused)),
-		   void **unused __attribute((unused)))
-{
-	void *next = NULL;
-	uint64_t start, length;
-	char *target_type = NULL;
-	char *params;
-	const char *device = dm_task_get_name(dmt);
-
-	if (pthread_mutex_trylock(&_event_mutex)) {
-		syslog(LOG_NOTICE, "Another thread is handling an event.  Waiting...");
-		pthread_mutex_lock(&_event_mutex);
-	}
-	do {
-		next = dm_get_next_target(dmt, next, &start, &length,
-					  &target_type, &params);
-
-		if (!target_type) {
-			syslog(LOG_INFO, "%s mapping lost.\n", device);
-			continue;
-		}
-
-		if (strcmp(target_type, "mirror")) {
-			syslog(LOG_INFO, "%s has unmirrored portion.\n", device);
-			continue;
-		}
-
-		switch(_get_mirror_event(params)) {
-		case ME_INSYNC:
-			/* FIXME: all we really know is that this
-			   _part_ of the device is in sync
-			   Also, this is not an error
-			*/
-			syslog(LOG_NOTICE, "%s is now in-sync\n", device);
-			break;
-		case ME_FAILURE:
-			syslog(LOG_ERR, "Device failure in %s\n", device);
-			if (_remove_failed_devices(device))
-				/* FIXME Why are all the error return codes unused? Get rid of them? */
-				syslog(LOG_ERR, "Failed to remove faulty devices in %s\n",
-				       device);
-			/* Should check before warning user that device is now linear
-			else
-				syslog(LOG_NOTICE, "%s is now a linear device.\n",
-					device);
-			*/
-			break;
-		case ME_IGNORE:
-			break;
-		default:
-			/* FIXME Provide value then! */
-			syslog(LOG_INFO, "Unknown event received.\n");
-		}
-	} while (next);
-
-	pthread_mutex_unlock(&_event_mutex);
-}
-
-int register_device(const char *device,
-		    const char *uuid __attribute((unused)),
-		    int major __attribute((unused)),
-		    int minor __attribute((unused)),
-		    void **unused __attribute((unused)))
-{
-	int r = 0;
-
-	pthread_mutex_lock(&_register_mutex);
-
-	syslog(LOG_INFO, "Monitoring mirror device %s for events\n", device);
-
-	/*
-	 * Need some space for allocations.  1024 should be more
-	 * than enough for what we need (device mapper name splitting)
-	 */
-	if (!_mem_pool && !(_mem_pool = dm_pool_create("mirror_dso", 1024)))
-		goto out;
-
-	if (!_lvm_handle) {
-		lvm2_log_fn(_temporary_log_fn);
-		if (!(_lvm_handle = lvm2_init())) {
-			dm_pool_destroy(_mem_pool);
-			_mem_pool = NULL;
-			goto out;
-		}
-		lvm2_log_level(_lvm_handle, LVM2_LOG_SUPPRESS);
-		/* FIXME Temporary: move to dmeventd core */
-		lvm2_run(_lvm_handle, "_memlock_inc");
-	}
-
-	_register_count++;
-	r = 1;
-
-out:
-	pthread_mutex_unlock(&_register_mutex);
-
-	return r;
-}
-
-int unregister_device(const char *device,
-		      const char *uuid __attribute((unused)),
-		      int major __attribute((unused)),
-		      int minor __attribute((unused)),
-		      void **unused __attribute((unused)))
-{
-	pthread_mutex_lock(&_register_mutex);
-
-	syslog(LOG_INFO, "No longer monitoring mirror device %s for events\n",
-	       device);
-
-	if (!--_register_count) {
-		dm_pool_destroy(_mem_pool);
-		_mem_pool = NULL;
-		lvm2_run(_lvm_handle, "_memlock_dec");
-		lvm2_exit(_lvm_handle);
-		_lvm_handle = NULL;
-	}
-
-	pthread_mutex_unlock(&_register_mutex);
-
-	return 1;
-}

dmeventd/snapshot/.exported_symbols

@@ -1,3 +0,0 @@
-process_event
-register_device
-unregister_device

dmeventd/snapshot/dmeventd_snapshot.c

@@ -1,232 +0,0 @@
-/*
- * Copyright (C) 2007-2008 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 "libdevmapper.h"
-#include "libdevmapper-event.h"
-#include "lvm2cmd.h"
-#include "lvm-string.h"
-
-#include <errno.h>
-#include <signal.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <unistd.h>
-
-#include <syslog.h> /* FIXME Replace syslog with multilog */
-/* FIXME Missing openlog? */
-
-/* First warning when snapshot is 80% full. */
-#define WARNING_THRESH 80
-/* Further warnings at 85%, 90% and 95% fullness. */
-#define WARNING_STEP 5
-
-static pthread_mutex_t _register_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-/*
- * Number of active registrations.
- */
-static int _register_count = 0;
-
-static struct dm_pool *_mem_pool = NULL;
-static void *_lvm_handle = NULL;
-
-struct snap_status {
-	int invalid;
-	int used;
-	int max;
-};
-
-/*
- * Currently only one event can be processed at a time.
- */
-static pthread_mutex_t _event_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static void _temporary_log_fn(int level,
-			      const char *file __attribute((unused)),
-			      int line __attribute((unused)),
-			      const char *format)
-{
-	if (!strncmp(format, "WARNING: ", 9) && (level < 5))
-		syslog(LOG_CRIT, "%s", format);
-	else
-		syslog(LOG_DEBUG, "%s", format);
-}
-
-/* FIXME possibly reconcile this with target_percent when we gain
-   access to regular LVM library here. */
-static void _parse_snapshot_params(char *params, struct snap_status *stat)
-{
-	char *p;
-	/*
-	 * xx/xx	-- fractions used/max
-	 * Invalid	-- snapshot invalidated
-	 * Unknown	-- status unknown
-	 */
-	stat->used = stat->max = 0;
-
-	if (!strncmp(params, "Invalid", 7)) {
-		stat->invalid = 1;
-		return;
-	}
-
-	/*
-	 * When we return without setting non-zero max, the parent is
-	 * responsible for reporting errors.
-	 */
-	if (!strncmp(params, "Unknown", 7))
-		return;
-
-	if (!(p = strstr(params, "/")))
-		return;
-
-	*p = '\0';
-	p++;
-
-	stat->used = atoi(params);
-	stat->max = atoi(p);
-}
-
-/* send unregister command to itself */
-static void _unregister_self(struct dm_task *dmt)
-{
-	const char *name = dm_task_get_name(dmt);
-	struct dm_event_handler *dmevh;
-
-	if (!(dmevh = dm_event_handler_create()))
-		return;
-
-	if (dm_event_handler_set_dev_name(dmevh, name))
-		goto fail;
-
-	dm_event_handler_set_event_mask(dmevh, DM_EVENT_ALL_ERRORS|DM_EVENT_TIMEOUT);
-	dm_event_unregister_handler(dmevh);
-fail:
-	dm_event_handler_destroy(dmevh);
-}
-
-void process_event(struct dm_task *dmt,
-		   enum dm_event_mask event __attribute((unused)),
-		   void **private)
-{
-	void *next = NULL;
-	uint64_t start, length;
-	char *target_type = NULL;
-	char *params;
-	struct snap_status stat = { 0 };
-	const char *device = dm_task_get_name(dmt);
-	int percent, *percent_warning = (int*)private;
-
-	/* No longer monitoring, waiting for remove */
-	if (!*percent_warning)
-		return;
-
-	if (pthread_mutex_trylock(&_event_mutex)) {
-		syslog(LOG_NOTICE, "Another thread is handling an event.  Waiting...");
-		pthread_mutex_lock(&_event_mutex);
-	}
-
-	dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
-	if (!target_type)
-		goto out;
-
-	_parse_snapshot_params(params, &stat);
-	/*
-	 * If the snapshot has been invalidated or we failed to parse
-	 * the status string. Report the full status string to syslog.
-	 */
-	if (stat.invalid || !stat.max) {
-		syslog(LOG_ERR, "Snapshot %s changed state to: %s\n", device, params);
-		_unregister_self(dmt);
-		*percent_warning = 0;
-		goto out;
-	}
-
-	percent = 100 * stat.used / stat.max;
-	if (percent >= *percent_warning) {
-		syslog(LOG_WARNING, "Snapshot %s is now %i%% full.\n", device, percent);
-		/* Print warning on the next multiple of WARNING_STEP. */
-		*percent_warning = (percent / WARNING_STEP) * WARNING_STEP + WARNING_STEP;
-	}
-out:
-	pthread_mutex_unlock(&_event_mutex);
-}
-
-int register_device(const char *device,
-		    const char *uuid __attribute((unused)),
-		    int major __attribute((unused)),
-		    int minor __attribute((unused)),
-		    void **private)
-{
-	int r = 0;
-	int *percent_warning = (int*)private;
-
-	pthread_mutex_lock(&_register_mutex);
-
-	/*
-	 * Need some space for allocations.  1024 should be more
-	 * than enough for what we need (device mapper name splitting)
-	 */
-	if (!_mem_pool && !(_mem_pool = dm_pool_create("snapshot_dso", 1024)))
-		goto out;
-
-	*percent_warning = WARNING_THRESH; /* Print warning if snapshot is full */
-
-	if (!_lvm_handle) {
-		lvm2_log_fn(_temporary_log_fn);
-		if (!(_lvm_handle = lvm2_init())) {
-			dm_pool_destroy(_mem_pool);
-			_mem_pool = NULL;
-			goto out;
-		}
-		lvm2_log_level(_lvm_handle, LVM2_LOG_SUPPRESS);
-		/* FIXME Temporary: move to dmeventd core */
-		lvm2_run(_lvm_handle, "_memlock_inc");
-	}
-
-	syslog(LOG_INFO, "Monitoring snapshot %s\n", device);
-
-	_register_count++;
-	r = 1;
-
-out:
-	pthread_mutex_unlock(&_register_mutex);
-
-	return r;
-}
-
-int unregister_device(const char *device,
-		      const char *uuid __attribute((unused)),
-		      int major __attribute((unused)),
-		      int minor __attribute((unused)),
-		      void **unused __attribute((unused)))
-{
-	pthread_mutex_lock(&_register_mutex);
-
-	syslog(LOG_INFO, "No longer monitoring snapshot %s\n",
-	       device);
-
-	if (!--_register_count) {
-		dm_pool_destroy(_mem_pool);
-		_mem_pool = NULL;
-		lvm2_run(_lvm_handle, "_memlock_dec");
-		lvm2_exit(_lvm_handle);
-		_lvm_handle = NULL;
-	}
-
-	pthread_mutex_unlock(&_register_mutex);
-
-	return 1;
-}

doc/Makefile.in

@@ -20,10 +20,11 @@ CONFDEST=lvm.conf
 
 include $(top_srcdir)/make.tmpl
 
-install:
+install_lvm2:
 	@if [ ! -e $(confdir)/$(CONFDEST) ]; then \
 		echo "Installing $(CONFSRC) as $(confdir)/$(CONFDEST)"; \
 		@INSTALL@ -D $(OWNER) $(GROUP) -m 644 $(CONFSRC) \
 			$(confdir)/$(CONFDEST); \
 	fi
 
+install: install_lvm2

doc/example.conf

@@ -86,13 +86,24 @@ devices {
     # 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	
+    sysfs_scan = 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
+
+    # Alignment (in KB) of start of data area when creating a new PV.
+    # If a PV is placed directly upon an md device and md_chunk_alignment is
+    # enabled this parameter is ignored.
+    # Set to 0 for the default alignment of 64KB or page size, if larger.
+    data_alignment = 0
+
     # 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
@@ -124,7 +135,7 @@ log {
     # 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
@@ -170,7 +181,7 @@ backup {
     # Where should archived files go ?
     # Remember to back up this directory regularly!
     archive_dir = "/etc/lvm/archive"
-    
+
     # What is the minimum number of archive files you wish to keep ?
     retain_min = 10
 
@@ -188,7 +199,7 @@ shell {
 
 # 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
@@ -266,11 +277,13 @@ global {
 }
 
 activation {
-    # Device used in place of missing stripes if activating incomplete volume.
-    # For now, you need to set this up yourself first (e.g. with 'dmsetup')
-    # For example, you could make it return I/O errors using the 'error' 
-    # target or make it return zeros.
-    missing_stripe_filler = "/dev/ioerror"
+    # 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"
 
     # How much stack (in KB) to reserve for use while devices suspended
     reserved_stack = 256
@@ -304,8 +317,10 @@ activation {
     # 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:
+    # 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
@@ -325,20 +340,13 @@ activation {
     #            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.
-    #            Currently this is not implemented properly and behaves
-    #            similarly to:
     #
-    # "allocate_anywhere" - Operates like "allocate", but it does not
-    #            require that the new space being allocated be on a
-    #            device is not part of the mirror.  For a log device
-    #            failure, this could mean that the log is allocated on
-    #            the same device as a mirror device.  For a mirror
-    #            device, this could mean that the mirror device is
-    #            allocated on the same device as another mirror device.
-    #            This policy would not be wise for mirror devices
-    #            because 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.
+    # "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_device_fault_policy = "remove"

include/.symlinks

@@ -1,4 +1,6 @@
 ../daemons/clvmd/clvm.h
+../daemons/dmeventd/libdevmapper-event.h
+../liblvm/lvm.h
 ../lib/activate/activate.h
 ../lib/activate/targets.h
 ../lib/cache/lvmcache.h
@@ -7,7 +9,6 @@
 ../lib/config/config.h
 ../lib/config/defaults.h
 ../lib/datastruct/btree.h
-../lib/datastruct/list.h
 ../lib/datastruct/lvm-types.h
 ../lib/datastruct/str_list.h
 ../lib/device/dev-cache.h
@@ -28,6 +29,7 @@
 ../lib/label/label.h
 ../lib/locking/locking.h
 ../lib/log/log.h
+../lib/log/lvm-logging.h
 ../lib/metadata/lv_alloc.h
 ../lib/metadata/metadata.h
 ../lib/metadata/metadata-exported.h
@@ -43,10 +45,16 @@
 ../lib/misc/lib.h
 ../lib/misc/lvm-exec.h
 ../lib/misc/lvm-file.h
+../lib/misc/lvm-globals.h
 ../lib/misc/lvm-string.h
+../lib/misc/lvm-version.h
 ../lib/misc/lvm-wrappers.h
 ../lib/misc/sharedlib.h
 ../lib/report/report.h
 ../lib/uuid/uuid.h
+../libdm/libdevmapper.h
+../libdm/misc/dm-ioctl.h
+../libdm/misc/dm-logging.h
+../libdm/misc/dmlib.h
+../libdm/misc/kdev_t.h
 ../po/pogen.h
-../tools/version.h

include/Makefile.in

@@ -20,7 +20,7 @@ VPATH = @srcdir@
 
 LN_S = @LN_S@
 
-.PHONY: clean distclean all install pofile install_cluster
+.PHONY: clean distclean all install pofile install_cluster install_device-mapper
 
 all: .symlinks_created
 
@@ -35,11 +35,17 @@ distclean:
 
 pofile: all
 
+device-mapper: all
+
 clean:
 
 install:
 
 install_cluster:
 
+install_device-mapper:
+
+install_lvm2:
+
 cflow:
 

lib/Makefile.in

@@ -1,6 +1,6 @@
 #
 # Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
-# Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+# Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
 #
 # This file is part of LVM2.
 #
@@ -38,11 +38,11 @@ SOURCES =\
 	commands/toolcontext.c \
 	config/config.c \
 	datastruct/btree.c \
-	datastruct/list.c \
 	datastruct/str_list.c \
 	device/dev-cache.c \
 	device/dev-io.c \
 	device/dev-md.c \
+	device/dev-swap.c \
 	device/device.c \
 	display/display.c \
 	error/errseg.c \
@@ -78,6 +78,7 @@ SOURCES =\
 	misc/crc.c \
 	misc/lvm-exec.c \
 	misc/lvm-file.c \
+	misc/lvm-globals.c \
 	misc/lvm-string.c \
 	misc/lvm-wrappers.c \
 	misc/timestamp.c \
@@ -139,18 +140,19 @@ ifeq ("@DMEVENTD@", "yes")
   CLDFLAGS += -ldevmapper-event
 endif
 
-LIB_STATIC = liblvm.a
+LIB_NAME = liblvm-internal
+LIB_STATIC = $(LIB_NAME).a
 
-$(SUBDIRS): $(LIB_STATIC)
-
-CLEAN_TARGETS += liblvm.cflow
+CLEAN_TARGETS += $(LIB_NAME).cflow
 
 include $(top_srcdir)/make.tmpl
 
-liblvm.cflow: $(SOURCES)
+$(SUBDIRS): $(LIB_STATIC)
+
+$(LIB_NAME).cflow: $(SOURCES)
 	set -e; (echo -n "SOURCES += "; \
 		 echo $(SOURCES) | \
 		 sed "s/^/ /;s/ / $(top_srcdir)\/lib\//g;s/$$//"; \
 		 ) > $@
 
-cflow: liblvm.cflow
+cflow: $(LIB_NAME).cflow

lib/activate/activate.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -52,11 +52,11 @@ int lvm1_present(struct cmd_context *cmd)
 }
 
 int list_segment_modules(struct dm_pool *mem, const struct lv_segment *seg,
-			 struct list *modules)
+			 struct dm_list *modules)
 {
 	unsigned int s;
 	struct lv_segment *seg2, *snap_seg;
-	struct list *snh;
+	struct dm_list *snh;
 
 	if (seg->segtype->ops->modules_needed &&
 	    !seg->segtype->ops->modules_needed(mem, seg, modules)) {
@@ -65,9 +65,9 @@ int list_segment_modules(struct dm_pool *mem, const struct lv_segment *seg,
 	}
 
 	if (lv_is_origin(seg->lv))
-		list_iterate(snh, &seg->lv->snapshot_segs)
+		dm_list_iterate(snh, &seg->lv->snapshot_segs)
 			if (!list_lv_modules(mem,
-					     list_struct_base(snh,
+					     dm_list_struct_base(snh,
 							      struct lv_segment,
 							      origin_list)->cow,
 					     modules))
@@ -100,11 +100,11 @@ int list_segment_modules(struct dm_pool *mem, const struct lv_segment *seg,
 }
 
 int list_lv_modules(struct dm_pool *mem, const struct logical_volume *lv,
-		    struct list *modules)
+		    struct dm_list *modules)
 {
 	struct lv_segment *seg;
 
-	list_iterate_items(seg, &lv->segments)
+	dm_list_iterate_items(seg, &lv->segments)
 		if (!list_segment_modules(mem, seg, modules))
 			return_0;
 
@@ -141,7 +141,8 @@ int target_version(const char *target_name, uint32_t *maj,
 {
 	return 0;
 }
-int target_present(const char *target_name, int use_modprobe)
+int target_present(struct cmd_context *cmd, const char *target_name,
+		   int use_modprobe)
 {
 	return 0;
 }
@@ -264,7 +265,7 @@ static int _passes_activation_filter(struct cmd_context *cmd,
 
 	if (!(cn = find_config_tree_node(cmd, "activation/volume_list"))) {
 		/* If no host tags defined, activate */
-		if (list_empty(&cmd->tags))
+		if (dm_list_empty(&cmd->tags))
 			return 1;
 
 		/* If any host tag matches any LV or VG tag, activate */
@@ -391,11 +392,12 @@ int target_version(const char *target_name, uint32_t *maj,
 	return r;
 }
 
-int module_present(const char *target_name)
+int module_present(struct cmd_context *cmd, const char *target_name)
 {
 	int ret = 0;
 #ifdef MODPROBE_CMD
 	char module[128];
+	const char *argv[3];
 
 	if (dm_snprintf(module, sizeof(module), "dm-%s", target_name) < 0) {
 		log_error("module_present module name too long: %s",
@@ -403,12 +405,17 @@ int module_present(const char *target_name)
 		return 0;
 	}
 
-	ret = exec_cmd(MODPROBE_CMD, module, "", "");
+	argv[0] = MODPROBE_CMD;
+	argv[1] = module;
+	argv[2] = NULL;
+
+	ret = exec_cmd(cmd, argv);
 #endif
 	return ret;
 }
 
-int target_present(const char *target_name, int use_modprobe)
+int target_present(struct cmd_context *cmd, const char *target_name,
+		   int use_modprobe)
 {
 	uint32_t maj, min, patchlevel;
 
@@ -420,7 +427,7 @@ int target_present(const char *target_name, int use_modprobe)
 		if (target_version(target_name, &maj, &min, &patchlevel))
 			return 1;
 
-		if (!module_present(target_name))
+		if (!module_present(cmd, target_name))
 			return_0;
 	}
 #endif
@@ -517,7 +524,7 @@ int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv,
 
 	/* If mirrored LV is temporarily shrinked to 1 area (= linear),
 	 * it should be considered in-sync. */
-	if (list_size(&lv->segments) == 1 && first_seg(lv)->area_count == 1) {
+	if (dm_list_size(&lv->segments) == 1 && first_seg(lv)->area_count == 1) {
 		*percent = 100.0;
 		return 1;
 	}
@@ -582,7 +589,7 @@ static int _lv_activate_lv(struct logical_volume *lv)
 	return r;
 }
 
-static int _lv_preload(struct logical_volume *lv)
+static int _lv_preload(struct logical_volume *lv, int *flush_required)
 {
 	int r;
 	struct dev_manager *dm;
@@ -590,7 +597,7 @@ static int _lv_preload(struct logical_volume *lv)
 	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
 		return_0;
 
-	if (!(r = dev_manager_preload(dm, lv)))
+	if (!(r = dev_manager_preload(dm, lv, flush_required)))
 		stack;
 
 	dev_manager_destroy(dm);
@@ -612,7 +619,7 @@ static int _lv_deactivate(struct logical_volume *lv)
 	return r;
 }
 
-static int _lv_suspend_lv(struct logical_volume *lv, int lockfs)
+static int _lv_suspend_lv(struct logical_volume *lv, int lockfs, int flush_required)
 {
 	int r;
 	struct dev_manager *dm;
@@ -620,7 +627,7 @@ static int _lv_suspend_lv(struct logical_volume *lv, int lockfs)
 	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
 		return_0;
 
-	if (!(r = dev_manager_suspend(dm, lv, lockfs)))
+	if (!(r = dev_manager_suspend(dm, lv, lockfs, flush_required)))
 		stack;
 
 	dev_manager_destroy(dm);
@@ -639,8 +646,8 @@ static int _lvs_in_vg_activated(struct volume_group *vg, unsigned by_uuid_only)
 	if (!activation())
 		return 0;
 
-	list_iterate_items(lvl, &vg->lvs) {
-		if (lvl->lv->status & VISIBLE_LV)
+	dm_list_iterate_items(lvl, &vg->lvs) {
+		if (lv_is_visible(lvl->lv))
 			count += (_lv_active(vg->cmd, lvl->lv, by_uuid_only) == 1);
 	}
 
@@ -665,8 +672,8 @@ int lvs_in_vg_opened(const struct volume_group *vg)
 	if (!activation())
 		return 0;
 
-	list_iterate_items(lvl, &vg->lvs) {
-		if (lvl->lv->status & VISIBLE_LV)
+	dm_list_iterate_items(lvl, &vg->lvs) {
+		if (lv_is_visible(lvl->lv))
 			count += (_lv_open_count(vg->cmd, lvl->lv) > 0);
 	}
 
@@ -682,17 +689,20 @@ int lvs_in_vg_opened(const struct volume_group *vg)
  */
 int lv_is_active(struct logical_volume *lv)
 {
+	int ret;
+
 	if (_lv_active(lv->vg->cmd, lv, 0))
 		return 1;
 
 	if (!vg_is_clustered(lv->vg))
 		return 0;
 
+	if ((ret = remote_lock_held(lv->lvid.s)) >= 0)
+		return ret;
+
 	/*
-	 * FIXME: Cluster does not report per-node LV activation status.
-	 * Currently the best we can do is try exclusive local activation.
-	 * If that succeeds, we know the LV is not active elsewhere in the
-	 * cluster.
+	 * Old compatibility code if locking doesn't support lock query
+	 * FIXME: check status to not deactivate already activate device
 	 */
 	if (activate_lv_excl(lv->vg->cmd, lv)) {
 		deactivate_lv(lv->vg->cmd, lv);
@@ -715,7 +725,7 @@ int monitor_dev_for_events(struct cmd_context *cmd,
 #ifdef DMEVENTD
 	int i, pending = 0, monitored;
 	int r = 1;
-	struct list *tmp, *snh, *snht;
+	struct dm_list *tmp, *snh, *snht;
 	struct lv_segment *seg;
 	int (*monitor_fn) (struct lv_segment *s, int e);
 	uint32_t s;
@@ -745,15 +755,15 @@ int monitor_dev_for_events(struct cmd_context *cmd,
 	 * TODO: This may change when snapshots of mirrors are allowed.
 	 */
 	if (lv_is_origin(lv)) {
-		list_iterate_safe(snh, snht, &lv->snapshot_segs)
-			if (!monitor_dev_for_events(cmd, list_struct_base(snh,
+		dm_list_iterate_safe(snh, snht, &lv->snapshot_segs)
+			if (!monitor_dev_for_events(cmd, dm_list_struct_base(snh,
 				    struct lv_segment, origin_list)->cow, monitor))
 				r = 0;
 		return r;
 	}
 
-	list_iterate(tmp, &lv->segments) {
-		seg = list_item(tmp, struct lv_segment);
+	dm_list_iterate(tmp, &lv->segments) {
+		seg = dm_list_item(tmp, struct lv_segment);
 
 		/* Recurse for AREA_LV */
 		for (s = 0; s < seg->area_count; s++) {
@@ -836,36 +846,41 @@ int monitor_dev_for_events(struct cmd_context *cmd,
 static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 		       int error_if_not_suspended)
 {
-	struct logical_volume *lv, *lv_pre;
+	struct logical_volume *lv = NULL, *lv_pre = NULL;
 	struct lvinfo info;
-	int lockfs = 0;
+	int r = 0, lockfs = 0, flush_required = 0;
 
 	if (!activation())
 		return 1;
 
 	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
-		return_0;
+		goto_out;
 
 	/* Use precommitted metadata if present */
 	if (!(lv_pre = lv_from_lvid(cmd, lvid_s, 1)))
-		return_0;
+		goto_out;
 
 	if (test_mode()) {
 		_skip("Suspending '%s'.", lv->name);
-		return 1;
+		r = 1;
+		goto out;
 	}
 
 	if (!lv_info(cmd, lv, &info, 0, 0))
-		return_0;
+		goto_out;
 
-	if (!info.exists || info.suspended)
-		return error_if_not_suspended ? 0 : 1;
+	if (!info.exists || info.suspended) {
+		r = error_if_not_suspended ? 0 : 1;
+		goto out;
+	}
+
+	lv_calculate_readahead(lv, NULL);
 
 	/* If VG was precommitted, preload devices for the LV */
 	if ((lv_pre->vg->status & PRECOMMITTED)) {
-		if (!_lv_preload(lv_pre)) {
+		if (!_lv_preload(lv_pre, &flush_required)) {
 			/* FIXME Revert preloading */
-			return_0;
+			goto_out;
 		}
 	}
 
@@ -878,13 +893,20 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 	if (lv_is_origin(lv_pre) || lv_is_cow(lv_pre))
 		lockfs = 1;
 
-	if (!_lv_suspend_lv(lv, lockfs)) {
+	if (!_lv_suspend_lv(lv, lockfs, flush_required)) {
 		memlock_dec();
 		fs_unlock();
-		return 0;
+		goto out;
 	}
 
-	return 1;
+	r = 1;
+out:
+	if (lv_pre)
+		vg_release(lv_pre->vg);
+	if (lv)
+		vg_release(lv->vg);
+
+	return r;
 }
 
 /* Returns success if the device is not active */
@@ -903,26 +925,30 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 {
 	struct logical_volume *lv;
 	struct lvinfo info;
+	int r = 0;
 
 	if (!activation())
 		return 1;
 
 	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
-		return 0;
+		goto out;
 
 	if (test_mode()) {
 		_skip("Resuming '%s'.", lv->name);
-		return 1;
+		r = 1;
+		goto out;
 	}
 
 	if (!lv_info(cmd, lv, &info, 0, 0))
-		return_0;
+		goto_out;
 
-	if (!info.exists || !info.suspended)
-		return error_if_not_active ? 0 : 1;
+	if (!info.exists || !info.suspended) {
+		r = error_if_not_active ? 0 : 1;
+		goto out;
+	}
 
 	if (!_lv_activate_lv(lv))
-		return 0;
+		goto out;
 
 	memlock_dec();
 	fs_unlock();
@@ -930,7 +956,12 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 	if (!monitor_dev_for_events(cmd, lv, 1))
 		stack;
 
-	return 1;
+	r = 1;
+out:
+	if (lv)
+		vg_release(lv->vg);
+
+	return r;
 }
 
 /* Returns success if the device is not active */
@@ -948,31 +979,36 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
 {
 	struct logical_volume *lv;
 	struct lvinfo info;
-	int r;
+	int r = 0;
 
 	if (!activation())
 		return 1;
 
 	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
-		return 0;
+		goto out;
 
 	if (test_mode()) {
 		_skip("Deactivating '%s'.", lv->name);
-		return 1;
+		r = 1;
+		goto out;
 	}
 
 	if (!lv_info(cmd, lv, &info, 1, 0))
-		return_0;
+		goto_out;
 
-	if (!info.exists)
-		return 1;
+	if (!info.exists) {
+		r = 1;
+		goto out;
+	}
 
-	if (info.open_count && (lv->status & VISIBLE_LV)) {
+	if (info.open_count && lv_is_visible(lv)) {
 		log_error("LV %s/%s in use: not deactivating", lv->vg->name,
 			  lv->name);
-		return 0;
+		goto out;
 	}
 
+	lv_calculate_readahead(lv, NULL);
+
 	if (!monitor_dev_for_events(cmd, lv, 0))
 		stack;
 
@@ -981,6 +1017,10 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
 	memlock_dec();
 	fs_unlock();
 
+out:
+	if (lv)
+		vg_release(lv->vg);
+
 	return r;
 }
 
@@ -989,23 +1029,28 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
 			 int *activate_lv)
 {
 	struct logical_volume *lv;
+	int r = 0;
 
-	if (!activation())
-		goto activate;
+	if (!activation()) {
+		*activate_lv = 1;
+		return 1;
+	}
 
 	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
-		return 0;
+		goto out;
 
 	if (!_passes_activation_filter(cmd, lv)) {
 		log_verbose("Not activating %s/%s due to config file settings",
 			    lv->vg->name, lv->name);
 		*activate_lv = 0;
-		return 1;
-	}
+	} else
+		*activate_lv = 1;
+	r = 1;
+out:
+	if (lv)
+		vg_release(lv->vg);
 
-      activate:
-	*activate_lv = 1;
-	return 1;
+	return r;
 }
 
 static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
@@ -1013,30 +1058,41 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
 {
 	struct logical_volume *lv;
 	struct lvinfo info;
-	int r;
+	int r = 0;
 
 	if (!activation())
 		return 1;
 
 	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
-		return 0;
+		goto out;
 
 	if (filter && !_passes_activation_filter(cmd, lv)) {
 		log_verbose("Not activating %s/%s due to config file settings",
 			    lv->vg->name, lv->name);
-		return 0;
+		goto out;
+	}
+
+	if ((!lv->vg->cmd->partial_activation) && (lv->status & PARTIAL_LV)) {
+		log_error("Refusing activation of partial LV %s. Use --partial to override.",
+			  lv->name);
+		goto_out;
 	}
 
 	if (test_mode()) {
 		_skip("Activating '%s'.", lv->name);
-		return 1;
+		r = 1;
+		goto out;
 	}
 
 	if (!lv_info(cmd, lv, &info, 0, 0))
-		return_0;
+		goto_out;
 
-	if (info.exists && !info.suspended && info.live_table)
-		return 1;
+	if (info.exists && !info.suspended && info.live_table) {
+		r = 1;
+		goto out;
+	}
+
+	lv_calculate_readahead(lv, NULL);
 
 	if (exclusive)
 		lv->status |= ACTIVATE_EXCL;
@@ -1049,6 +1105,10 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
 	if (r && !monitor_dev_for_events(cmd, lv, 1))
 		stack;
 
+out:
+	if (lv)
+		vg_release(lv->vg);
+
 	return r;
 }
 
@@ -1078,9 +1138,10 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
 	if (!_lv_info(cmd, lv, 1, &info, 0, 0, 0))
 		return_0;
 
-	if (info.exists)
-		r = dev_manager_lv_mknodes(lv);
-	else
+	if (info.exists) {
+		if (lv_is_visible(lv))
+			r = dev_manager_lv_mknodes(lv);
+	} else
 		r = dev_manager_lv_rmnodes(lv);
 
 	fs_unlock();

lib/activate/activate.h

@@ -40,14 +40,15 @@ int driver_version(char *version, size_t size);
 int library_version(char *version, size_t size);
 int lvm1_present(struct cmd_context *cmd);
 
-int module_present(const char *target_name);
-int target_present(const char *target_name, int use_modprobe);
+int module_present(struct cmd_context *cmd, const char *target_name);
+int target_present(struct cmd_context *cmd, const char *target_name,
+		   int use_modprobe);
 int target_version(const char *target_name, uint32_t *maj,
                    uint32_t *min, uint32_t *patchlevel);
 int list_segment_modules(struct dm_pool *mem, const struct lv_segment *seg,
-			 struct list *modules);
+			 struct dm_list *modules);
 int list_lv_modules(struct dm_pool *mem, const struct logical_volume *lv,
-		    struct list *modules);
+		    struct dm_list *modules);
 
 void activation_release(void);
 void activation_exit(void);

lib/activate/dev_manager.c

@@ -47,9 +47,9 @@ struct dev_manager {
 
 	struct cmd_context *cmd;
 
-	const char *stripe_filler;
 	void *target_state;
 	uint32_t pvmove_mirror_count;
+	int flush_required;
 
 	char *vg_name;
 };
@@ -59,8 +59,6 @@ struct lv_layer {
 	const char *old_name;
 };
 
-static const char *stripe_filler = NULL;
-
 static char *_build_dlid(struct dm_pool *mem, const char *lvid, const char *layer)
 {
 	char *dlid;
@@ -96,7 +94,8 @@ static int _read_only_lv(struct logical_volume *lv)
  * Low level device-layer operations.
  */
 static struct dm_task *_setup_task(const char *name, const char *uuid,
-				   uint32_t *event_nr, int task)
+				   uint32_t *event_nr, int task,
+				   uint32_t major, uint32_t minor)
 {
 	struct dm_task *dmt;
 
@@ -112,12 +111,15 @@ static struct dm_task *_setup_task(const char *name, const char *uuid,
 	if (event_nr)
 		dm_task_set_event_nr(dmt, *event_nr);
 
+	if (major)
+		dm_task_set_major_minor(dmt, major, minor, 1);
+
 	return dmt;
 }
 
 static int _info_run(const char *name, const char *dlid, struct dm_info *info,
 		     uint32_t *read_ahead, int mknodes, int with_open_count,
-		     int with_read_ahead)
+		     int with_read_ahead, uint32_t major, uint32_t minor)
 {
 	int r = 0;
 	struct dm_task *dmt;
@@ -125,7 +127,7 @@ static int _info_run(const char *name, const char *dlid, struct dm_info *info,
 
 	dmtask = mknodes ? DM_DEVICE_MKNODES : DM_DEVICE_INFO;
 
-	if (!(dmt = _setup_task(name, dlid, 0, dmtask)))
+	if (!(dmt = _setup_task(name, dlid, 0, dmtask, major, minor)))
 		return_0;
 
 	if (!with_open_count)
@@ -138,7 +140,7 @@ static int _info_run(const char *name, const char *dlid, struct dm_info *info,
 	if (!dm_task_get_info(dmt, info))
 		goto_out;
 
-	if (with_read_ahead) {
+	if (with_read_ahead && info->exists) {
 		if (!dm_task_get_read_ahead(dmt, read_ahead))
 			goto_out;
 	} else if (read_ahead)
@@ -167,7 +169,7 @@ int device_is_usable(dev_t dev)
 		return 0;
 	}
 
-	if (!dm_task_set_major(dmt, MAJOR(dev)) || !dm_task_set_minor(dmt, MINOR(dev)))
+	if (!dm_task_set_major_minor(dmt, MAJOR(dev), MINOR(dev), 1))
 		goto_out;
 
 	if (!dm_task_run(dmt)) {
@@ -209,23 +211,28 @@ static int _info(const char *name, const char *dlid, int mknodes,
 {
 	if (!mknodes && dlid && *dlid) {
 		if (_info_run(NULL, dlid, info, read_ahead, 0, with_open_count,
-			      with_read_ahead) &&
+			      with_read_ahead, 0, 0) &&
 	    	    info->exists)
 			return 1;
 		else if (_info_run(NULL, dlid + sizeof(UUID_PREFIX) - 1, info,
 				   read_ahead, 0, with_open_count,
-				   with_read_ahead) &&
+				   with_read_ahead, 0, 0) &&
 			 info->exists)
 			return 1;
 	}
 
 	if (name)
 		return _info_run(name, NULL, info, read_ahead, mknodes,
-				 with_open_count, with_read_ahead);
+				 with_open_count, with_read_ahead, 0, 0);
 
 	return 0;
 }
 
+static int _info_by_dev(uint32_t major, uint32_t minor, struct dm_info *info)
+{
+	return _info_run(NULL, NULL, info, NULL, 0, 0, 0, major, minor);
+}
+
 int dev_manager_info(struct dm_pool *mem, const char *name,
 		     const struct logical_volume *lv, int with_mknodes,
 		     int with_open_count, int with_read_ahead,
@@ -255,7 +262,7 @@ static int _status_run(const char *name, const char *uuid,
 	char *type = NULL;
 	char *params = NULL;
 
-	if (!(dmt = _setup_task(name, uuid, 0, DM_DEVICE_STATUS)))
+	if (!(dmt = _setup_task(name, uuid, 0, DM_DEVICE_STATUS, 0, 0)))
 		return_0;
 
 	if (!dm_task_no_open_count(dmt))
@@ -333,7 +340,7 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 	uint64_t start, length;
 	char *type = NULL;
 	char *params = NULL;
-	struct list *segh = &lv->segments;
+	struct dm_list *segh = &lv->segments;
 	struct lv_segment *seg = NULL;
 	struct segment_type *segtype;
 
@@ -342,7 +349,7 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 	*percent = -1;
 
 	if (!(dmt = _setup_task(name, dlid, event_nr,
-				wait ? DM_DEVICE_WAITEVENT : DM_DEVICE_STATUS)))
+				wait ? DM_DEVICE_WAITEVENT : DM_DEVICE_STATUS, 0, 0)))
 		return_0;
 
 	if (!dm_task_no_open_count(dmt))
@@ -361,12 +368,12 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 		next = dm_get_next_target(dmt, next, &start, &length, &type,
 					  &params);
 		if (lv) {
-			if (!(segh = list_next(&lv->segments, segh))) {
+			if (!(segh = dm_list_next(&lv->segments, segh))) {
 				log_error("Number of segments in active LV %s "
 					  "does not match metadata", lv->name);
 				goto out;
 			}
-			seg = list_item(segh, struct lv_segment);
+			seg = dm_list_item(segh, struct lv_segment);
 		}
 
 		if (!type || !params || strcmp(type, target_type))
@@ -384,7 +391,7 @@ static int _percent_run(struct dev_manager *dm, const char *name,
 
 	} while (next);
 
-	if (lv && (segh = list_next(&lv->segments, segh))) {
+	if (lv && (segh = dm_list_next(&lv->segments, segh))) {
 		log_error("Number of segments in active LV %s does not "
 			  "match metadata", lv->name);
 		goto out;
@@ -437,19 +444,12 @@ struct dev_manager *dev_manager_create(struct cmd_context *cmd,
 	if (!(mem = dm_pool_create("dev_manager", 16 * 1024)))
 		return_NULL;
 
-	if (!(dm = dm_pool_alloc(mem, sizeof(*dm))))
+	if (!(dm = dm_pool_zalloc(mem, sizeof(*dm))))
 		goto_bad;
 
 	dm->cmd = cmd;
 	dm->mem = mem;
 
-	if (!stripe_filler) {
-		stripe_filler = find_config_tree_str(cmd,
-						"activation/missing_stripe_filler",
-						DEFAULT_STRIPE_FILLER);
-	}
-	dm->stripe_filler = stripe_filler;
-
 	if (!(dm->vg_name = dm_pool_strdup(dm->mem, vg_name)))
 		goto_bad;
 
@@ -586,7 +586,7 @@ static int _belong_to_vg(const char *vgname, const char *name)
 	old_origin = snap_seg->origin;
 
 	/* Was this the last active snapshot with this origin? */
-	list_iterate_items(lvl, active_head) {
+	dm_list_iterate_items(lvl, active_head) {
 		active = lvl->lv;
 		if ((snap_seg = find_cow(active)) &&
 		    snap_seg->origin == old_origin) {
@@ -620,7 +620,7 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 			       struct logical_volume *lv, const char *layer)
 {
 	char *dlid, *name;
-	struct dm_info info;
+	struct dm_info info, info2;
 
 	if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, layer)))
 		return_0;
@@ -634,6 +634,30 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 		return 0;
 	}
 
+	/*
+	 * For top level volumes verify that existing device match
+	 * requested major/minor and that major/minor pair is available for use
+	 */
+	if (!layer && lv->major != -1 && lv->minor != -1) {
+		/*
+		 * FIXME compare info.major with lv->major if multiple major support
+		 */
+		if (info.exists && (info.minor != lv->minor)) {
+			log_error("Volume %s (%" PRIu32 ":%" PRIu32")"
+				  " differs from already active device "
+				  "(%" PRIu32 ":%" PRIu32")",
+				  lv->name, lv->major, lv->minor, info.major, info.minor);
+			return 0;
+		}
+		if (!info.exists && _info_by_dev(lv->major, lv->minor, &info2) &&
+		    info2.exists) {
+			log_error("The requested major:minor pair "
+				  "(%" PRIu32 ":%" PRIu32") is already used",
+				  lv->major, lv->minor);
+			return 0;
+		}
+	}
+
 	if (info.exists && !dm_tree_add_dev(dtree, info.major, info.minor)) {
 		log_error("Failed to add device (%" PRIu32 ":%" PRIu32") to dtree",
 			  info.major, info.minor);
@@ -667,7 +691,7 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, struc
 static struct dm_tree *_create_partial_dtree(struct dev_manager *dm, struct logical_volume *lv)
 {
 	struct dm_tree *dtree;
-	struct list *snh, *snht;
+	struct dm_list *snh, *snht;
 	struct lv_segment *seg;
 	uint32_t s;
 
@@ -680,12 +704,12 @@ static struct dm_tree *_create_partial_dtree(struct dev_manager *dm, struct logi
 		goto_bad;
 
 	/* Add any snapshots of this LV */
-	list_iterate_safe(snh, snht, &lv->snapshot_segs)
-		if (!_add_lv_to_dtree(dm, dtree, list_struct_base(snh, struct lv_segment, origin_list)->cow))
+	dm_list_iterate_safe(snh, snht, &lv->snapshot_segs)
+		if (!_add_lv_to_dtree(dm, dtree, dm_list_struct_base(snh, struct lv_segment, origin_list)->cow))
 			goto_bad;
 
 	/* Add any LVs used by segments in this LV */
-	list_iterate_items(seg, &lv->segments)
+	dm_list_iterate_items(seg, &lv->segments)
 		for (s = 0; s < seg->area_count; s++)
 			if (seg_type(seg, s) == AREA_LV && seg_lv(seg, s)) {
 				if (!_add_lv_to_dtree(dm, dtree, seg_lv(seg, s)))
@@ -699,6 +723,68 @@ bad:
 	return NULL;
 }
 
+static char *_add_error_device(struct dev_manager *dm, struct dm_tree *dtree,
+			       struct lv_segment *seg, int s)
+{
+	char *id, *name;
+	char errid[32];
+	struct dm_tree_node *node;
+	struct lv_segment *seg_i;
+	int segno = -1, i = 0;;
+	uint64_t size = seg->len * seg->lv->vg->extent_size;
+
+	dm_list_iterate_items(seg_i, &seg->lv->segments) {
+		if (seg == seg_i)
+			segno = i;
+		++i;
+	}
+
+	if (segno < 0) {
+		log_error("_add_error_device called with bad segment");
+		return_NULL;
+	}
+
+	sprintf(errid, "missing_%d_%d", segno, s);
+
+	if (!(id = build_dlid(dm, seg->lv->lvid.s, errid))) 
+		return_NULL;
+
+	if (!(name = build_dm_name(dm->mem, seg->lv->vg->name,
+				   seg->lv->name, errid)))
+		return_NULL;
+	if (!(node = dm_tree_add_new_dev(dtree, name, id, 0, 0, 0, 0, 0)))
+		return_NULL;
+	if (!dm_tree_node_add_error_target(node, size))
+		return_NULL;
+
+	return id;
+}
+
+static int _add_error_area(struct dev_manager *dm, struct dm_tree_node *node,
+			   struct lv_segment *seg, int s)
+{
+	char *dlid;
+	uint64_t extent_size = seg->lv->vg->extent_size;
+
+	if (!strcmp(dm->cmd->stripe_filler, "error")) {
+		/*
+		 * FIXME, the tree pointer is first field of dm_tree_node, but
+		 * we don't have the struct definition available.
+		 */
+		struct dm_tree **tree = (struct dm_tree **) node;
+		dlid = _add_error_device(dm, *tree, seg, s);
+		if (!dlid)
+			return_0;
+		dm_tree_node_add_target_area(node, NULL, dlid,
+					     extent_size * seg_le(seg, s));
+	} else
+		dm_tree_node_add_target_area(node,
+					     dm->cmd->stripe_filler,
+					     NULL, UINT64_C(0));
+
+	return 1;
+}
+
 int add_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 		   struct dm_tree_node *node, uint32_t start_area,
 		   uint32_t areas)
@@ -712,11 +798,10 @@ int add_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 		     (!seg_pvseg(seg, s) ||
 		      !seg_pv(seg, s) ||
 		      !seg_dev(seg, s))) ||
-		    (seg_type(seg, s) == AREA_LV && !seg_lv(seg, s)))
-			dm_tree_node_add_target_area(node,
-							dm->stripe_filler,
-							NULL, UINT64_C(0));
-		else if (seg_type(seg, s) == AREA_PV)
+		    (seg_type(seg, s) == AREA_LV && !seg_lv(seg, s))) {
+			if (!_add_error_area(dm, node, seg, s))
+				return_0;
+		} else if (seg_type(seg, s) == AREA_PV)
 			dm_tree_node_add_target_area(node,
 							dev_name(seg_dev(seg, s)),
 							NULL,
@@ -811,7 +896,7 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 				   const char *layer)
 {
 	uint32_t s;
-	struct list *snh;
+	struct dm_list *snh;
 	struct lv_segment *seg_present;
 
 	/* Ensure required device-mapper targets are loaded */
@@ -822,7 +907,8 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 		  layer ? "-" : "", layer ? : "");
 
 	if (seg_present->segtype->ops->target_present &&
-	    !seg_present->segtype->ops->target_present(seg_present, NULL)) {
+	    !seg_present->segtype->ops->target_present(seg_present->lv->vg->cmd,
+						       seg_present, NULL)) {
 		log_error("Can't expand LV %s: %s target support missing "
 			  "from kernel?", seg->lv->name, seg_present->segtype->name);
 		return 0;
@@ -864,8 +950,8 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 
 	if (lv_is_origin(seg->lv) && !layer)
 		/* Add any snapshots of this LV */
-		list_iterate(snh, &seg->lv->snapshot_segs)
-			if (!_add_new_lv_to_dtree(dm, dtree, list_struct_base(snh, struct lv_segment, origin_list)->cow, NULL))
+		dm_list_iterate(snh, &seg->lv->snapshot_segs)
+			if (!_add_new_lv_to_dtree(dm, dtree, dm_list_struct_base(snh, struct lv_segment, origin_list)->cow, NULL))
 				return_0;
 
 	return 1;
@@ -919,7 +1005,7 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 
 	/* Create table */
 	dm->pvmove_mirror_count = 0u;
-	list_iterate_items(seg, &lv->segments) {
+	dm_list_iterate_items(seg, &lv->segments) {
 		if (!_add_segment_to_dtree(dm, dtree, dnode, seg, layer))
 			return_0;
 		/* These aren't real segments in the LVM2 metadata */
@@ -934,6 +1020,8 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	if (read_ahead == DM_READ_AHEAD_AUTO) {
 		/* we need RA at least twice a whole stripe - see the comment in md/raid0.c */
 		read_ahead = max_stripe_size * 2;
+		if (!read_ahead)
+			lv_calculate_readahead(lv, &read_ahead);
 		read_ahead_flags = DM_READ_AHEAD_MINIMUM_FLAG;
 	}
 
@@ -954,7 +1042,8 @@ static int _create_lv_symlinks(struct dev_manager *dm, struct dm_tree_node *root
 	void *handle = NULL;
 	struct dm_tree_node *child;
 	struct lv_layer *lvlayer;
-	char *vgname, *lvname, *layer;
+	char *old_vgname, *old_lvname, *old_layer;
+	char *new_vgname, *new_lvname, *new_layer;
 	const char *name;
 	int r = 1;
 
@@ -966,12 +1055,24 @@ static int _create_lv_symlinks(struct dev_manager *dm, struct dm_tree_node *root
 		name = dm_tree_node_get_name(child);
 
 		if (name && lvlayer->old_name && *lvlayer->old_name && strcmp(name, lvlayer->old_name)) {
-			if (!dm_split_lvm_name(dm->mem, lvlayer->old_name, &vgname, &lvname, &layer)) {
+			if (!dm_split_lvm_name(dm->mem, lvlayer->old_name, &old_vgname, &old_lvname, &old_layer)) {
 				log_error("_create_lv_symlinks: Couldn't split up old device name %s", lvlayer->old_name);
 				return 0;
 			}
-			fs_rename_lv(lvlayer->lv, name, lvname);
-		} else if (!dev_manager_lv_mknodes(lvlayer->lv))
+			if (!dm_split_lvm_name(dm->mem, name, &new_vgname, &new_lvname, &new_layer)) {
+				log_error("_create_lv_symlinks: Couldn't split up new device name %s", name);
+				return 0;
+			}
+			if (!fs_rename_lv(lvlayer->lv, name, old_vgname, old_lvname))
+				r = 0;
+			continue;
+		}
+		if (lv_is_visible(lvlayer->lv)) {
+			if (!dev_manager_lv_mknodes(lvlayer->lv))
+				r = 0;
+			continue;
+		}
+		if (!dev_manager_lv_rmnodes(lvlayer->lv))
 			r = 0;
 	}
 
@@ -1071,7 +1172,7 @@ static int _tree_action(struct dev_manager *dm, struct logical_volume *lv, actio
 		break;
 	case SUSPEND:
 		dm_tree_skip_lockfs(root);
-		if ((lv->status & MIRRORED) && !(lv->status & PVMOVE))
+		if (!dm->flush_required && (lv->status & MIRRORED) && !(lv->status & PVMOVE))
 			dm_tree_use_no_flush_suspend(root);
 	case SUSPEND_WITH_LOCKFS:
 		if (!dm_tree_suspend_children(root, dlid, ID_LEN + sizeof(UUID_PREFIX) - 1))
@@ -1087,6 +1188,9 @@ static int _tree_action(struct dev_manager *dm, struct logical_volume *lv, actio
 		if (!dm_tree_preload_children(root, dlid, ID_LEN + sizeof(UUID_PREFIX) - 1))
 			goto_out;
 
+		if (dm_tree_node_size_changed(root))
+			dm->flush_required = 1;
+
 		if ((action == ACTIVATE) &&
 		    !dm_tree_activate_children(root, dlid, ID_LEN + sizeof(UUID_PREFIX) - 1))
 			goto_out;
@@ -1117,13 +1221,19 @@ int dev_manager_activate(struct dev_manager *dm, struct logical_volume *lv)
 	return _tree_action(dm, lv, CLEAN);
 }
 
-int dev_manager_preload(struct dev_manager *dm, struct logical_volume *lv)
+int dev_manager_preload(struct dev_manager *dm, struct logical_volume *lv,
+			int *flush_required)
 {
 	/* FIXME Update the pvmove implementation! */
 	if ((lv->status & PVMOVE) || (lv->status & LOCKED))
 		return 1;
 
-	return _tree_action(dm, lv, PRELOAD);
+	if (!_tree_action(dm, lv, PRELOAD))
+		return 0;
+
+	*flush_required = dm->flush_required;
+
+	return 1;
 }
 
 int dev_manager_deactivate(struct dev_manager *dm, struct logical_volume *lv)
@@ -1138,8 +1248,10 @@ int dev_manager_deactivate(struct dev_manager *dm, struct logical_volume *lv)
 }
 
 int dev_manager_suspend(struct dev_manager *dm, struct logical_volume *lv,
-			int lockfs)
+			int lockfs, int flush_required)
 {
+	dm->flush_required = flush_required;
+
 	return _tree_action(dm, lv, lockfs ? SUSPEND_WITH_LOCKFS : SUSPEND);
 }
 

lib/activate/dev_manager.h

@@ -49,9 +49,10 @@ int dev_manager_mirror_percent(struct dev_manager *dm,
 			       struct logical_volume *lv, int wait,
 			       float *percent, uint32_t *event_nr);
 int dev_manager_suspend(struct dev_manager *dm, struct logical_volume *lv,
-			int lockfs);
+			int lockfs, int flush_required);
 int dev_manager_activate(struct dev_manager *dm, struct logical_volume *lv);
-int dev_manager_preload(struct dev_manager *dm, struct logical_volume *lv);
+int dev_manager_preload(struct dev_manager *dm, struct logical_volume *lv,
+			int *flush_required);
 int dev_manager_deactivate(struct dev_manager *dm, struct logical_volume *lv);
 
 int dev_manager_lv_mknodes(const struct logical_volume *lv);

lib/activate/fs.c

@@ -243,10 +243,10 @@ static int _do_fs_op(fs_op_t type, const char *dev_dir, const char *vg_name,
 	return 1;
 }
 
-static LIST_INIT(_fs_ops);
+static DM_LIST_INIT(_fs_ops);
 
 struct fs_op_parms {
-	struct list list;
+	struct dm_list list;
 	fs_op_t type;
 	char *dev_dir;
 	char *vg_name;
@@ -286,21 +286,21 @@ static int _stack_fs_op(fs_op_t type, const char *dev_dir, const char *vg_name,
 	_store_str(&pos, &fsp->dev, dev);
 	_store_str(&pos, &fsp->old_lv_name, old_lv_name);
 
-	list_add(&_fs_ops, &fsp->list);
+	dm_list_add(&_fs_ops, &fsp->list);
 
 	return 1;
 }
 
 static void _pop_fs_ops(void)
 {
-	struct list *fsph, *fspht;
+	struct dm_list *fsph, *fspht;
 	struct fs_op_parms *fsp;
 
-	list_iterate_safe(fsph, fspht, &_fs_ops) {
-		fsp = list_item(fsph, struct fs_op_parms);
+	dm_list_iterate_safe(fsph, fspht, &_fs_ops) {
+		fsp = dm_list_item(fsph, struct fs_op_parms);
 		_do_fs_op(fsp->type, fsp->dev_dir, fsp->vg_name, fsp->lv_name,
 			  fsp->dev, fsp->old_lv_name);
-		list_del(&fsp->list);
+		dm_list_del(&fsp->list);
 		dm_free(fsp);
 	}
 }
@@ -335,11 +335,17 @@ int fs_del_lv_byname(const char *dev_dir, const char *vg_name, const char *lv_na
 	return _fs_op(FS_DEL, dev_dir, vg_name, lv_name, "", "");
 }
 
-int fs_rename_lv(struct logical_volume *lv,
-		 const char *dev, const char *old_name)
+int fs_rename_lv(struct logical_volume *lv, const char *dev, 
+		const char *old_vgname, const char *old_lvname)
 {
-	return _fs_op(FS_RENAME, lv->vg->cmd->dev_dir, lv->vg->name, lv->name,
-		      dev, old_name);
+	if (strcmp(old_vgname, lv->vg->name)) {
+		return
+			(_fs_op(FS_DEL, lv->vg->cmd->dev_dir, old_vgname, old_lvname, "", "") &&
+			 _fs_op(FS_ADD, lv->vg->cmd->dev_dir, lv->vg->name, lv->name, dev, ""));
+	}
+	else 
+		return _fs_op(FS_RENAME, lv->vg->cmd->dev_dir, lv->vg->name, lv->name,
+			      dev, old_lvname);
 }
 
 void fs_unlock(void)

lib/activate/fs.h

@@ -26,8 +26,8 @@
 int fs_add_lv(const struct logical_volume *lv, const char *dev);
 int fs_del_lv(const struct logical_volume *lv);
 int fs_del_lv_byname(const char *dev_dir, const char *vg_name, const char *lv_name);
-int fs_rename_lv(struct logical_volume *lv,
-		 const char *dev, const char *old_name);
+int fs_rename_lv(struct logical_volume *lv, const char *dev, 
+		const char *old_vgname, const char *old_lvname);
 void fs_unlock(void);
 
 #endif

lib/cache/lvmcache.c

@@ -30,7 +30,7 @@ static struct dm_hash_table *_pvid_hash = NULL;
 static struct dm_hash_table *_vgid_hash = NULL;
 static struct dm_hash_table *_vgname_hash = NULL;
 static struct dm_hash_table *_lock_hash = NULL;
-static struct list _vginfos;
+static struct dm_list _vginfos;
 static int _scanning_in_progress = 0;
 static int _has_scanned = 0;
 static int _vgs_locked = 0;
@@ -38,7 +38,7 @@ static int _vg_global_lock_held = 0;	/* Global lock held when cache wiped? */
 
 int lvmcache_init(void)
 {
-	list_init(&_vginfos);
+	dm_list_init(&_vginfos);
 
 	if (!(_vgname_hash = dm_hash_create(128)))
 		return 0;
@@ -71,11 +71,20 @@ static void _free_cached_vgmetadata(struct lvmcache_vginfo *vginfo)
 	log_debug("Metadata cache: VG %s wiped.", vginfo->vgname);
 }
 
-static void _store_metadata(struct lvmcache_vginfo *vginfo,
-			    struct volume_group *vg, unsigned precommitted)
+/*
+ * Cache VG metadata against the vginfo with matching vgid.
+ */
+static void _store_metadata(struct volume_group *vg, unsigned precommitted)
 {
+	char uuid[64] __attribute((aligned(8)));
+	struct lvmcache_vginfo *vginfo;
 	int size;
 
+	if (!(vginfo = vginfo_from_vgid((const char *)&vg->id))) {
+		stack;
+		return;
+	}
+
 	if (vginfo->vgmetadata)
 		_free_cached_vgmetadata(vginfo);
 
@@ -86,8 +95,14 @@ static void _store_metadata(struct lvmcache_vginfo *vginfo,
 
 	vginfo->precommitted = precommitted;
 
-	log_debug("Metadata cache: VG %s stored (%d bytes%s).", vginfo->vgname,
-		  size, precommitted ? ", precommitted" : "");
+	if (!id_write_format((const struct id *)vginfo->vgid, uuid, sizeof(uuid))) {
+		stack;
+		return;
+	}
+
+	log_debug("Metadata cache: VG %s (%s) stored (%d bytes%s).",
+		  vginfo->vgname, uuid, size,
+		  precommitted ? ", precommitted" : "");
 }
 
 static void _update_cache_info_lock_state(struct lvmcache_info *info,
@@ -117,7 +132,7 @@ static void _update_cache_vginfo_lock_state(struct lvmcache_vginfo *vginfo,
 	struct lvmcache_info *info;
 	int cached_vgmetadata_valid = 1;
 
-	list_iterate_items(info, &vginfo->infos)
+	dm_list_iterate_items(info, &vginfo->infos)
 		_update_cache_info_lock_state(info, locked,
 					      &cached_vgmetadata_valid);
 
@@ -151,7 +166,7 @@ static void _drop_metadata(const char *vgname)
 	 */
 
 	if (!vginfo->precommitted)
-		list_iterate_items(info, &vginfo->infos)
+		dm_list_iterate_items(info, &vginfo->infos)
 			info->status |= CACHE_INVALID;
 
 	_free_cached_vgmetadata(vginfo);
@@ -226,14 +241,14 @@ static void _vginfo_attach_info(struct lvmcache_vginfo *vginfo,
 		return;
 
 	info->vginfo = vginfo;
-	list_add(&vginfo->infos, &info->list);
+	dm_list_add(&vginfo->infos, &info->list);
 }
 
 static void _vginfo_detach_info(struct lvmcache_info *info)
 {
-	if (!list_empty(&info->list)) {
-		list_del(&info->list);
-		list_init(&info->list);
+	if (!dm_list_empty(&info->list)) {
+		dm_list_del(&info->list);
+		dm_list_init(&info->list);
 	}
 
 	info->vginfo = NULL;
@@ -267,8 +282,8 @@ const struct format_type *fmt_from_vgname(const char *vgname, const char *vgid)
 	struct lvmcache_vginfo *vginfo;
 	struct lvmcache_info *info;
 	struct label *label;
-	struct list *devh, *tmp;
-	struct list devs;
+	struct dm_list *devh, *tmp;
+	struct dm_list devs;
 	struct device_list *devl;
 	char vgid_found[ID_LEN + 1] __attribute((aligned(8)));
 
@@ -277,22 +292,22 @@ const struct format_type *fmt_from_vgname(const char *vgname, const char *vgid)
 
 	/* This function is normally called before reading metadata so
  	 * we check cached labels here. Unfortunately vginfo is volatile. */
-	list_init(&devs);
-	list_iterate_items(info, &vginfo->infos) {
+	dm_list_init(&devs);
+	dm_list_iterate_items(info, &vginfo->infos) {
 		if (!(devl = dm_malloc(sizeof(*devl)))) {
 			log_error("device_list element allocation failed");
 			return NULL;
 		}
 		devl->dev = info->dev;
-		list_add(&devs, &devl->list);
+		dm_list_add(&devs, &devl->list);
 	}
 
 	memcpy(vgid_found, vginfo->vgid, sizeof(vgid_found));
 
-	list_iterate_safe(devh, tmp, &devs) {
-		devl = list_item(devh, struct device_list);
+	dm_list_iterate_safe(devh, tmp, &devs) {
+		devl = dm_list_item(devh, struct device_list);
 		label_read(devl->dev, &label, UINT64_C(0));
-		list_del(&devl->list);
+		dm_list_del(&devl->list);
 		dm_free(devl);
 	}
 
@@ -362,7 +377,7 @@ static int _vginfo_is_valid(struct lvmcache_vginfo *vginfo)
 	struct lvmcache_info *info;
 
 	/* Invalid if any info is invalid */
-	list_iterate_items(info, &vginfo->infos)
+	dm_list_iterate_items(info, &vginfo->infos)
 		if (!_info_is_valid(info))
 			return 0;
 
@@ -374,7 +389,7 @@ static int _vginfo_is_invalid(struct lvmcache_vginfo *vginfo)
 {
 	struct lvmcache_info *info;
 
-	list_iterate_items(info, &vginfo->infos)
+	dm_list_iterate_items(info, &vginfo->infos)
 		if (_info_is_valid(info))
 			return 0;
 
@@ -458,7 +473,7 @@ int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)
 	_has_scanned = 1;
 
 	/* Perform any format-specific scanning e.g. text files */
-	list_iterate_items(fmt, &cmd->formats) {
+	dm_list_iterate_items(fmt, &cmd->formats) {
 		if (fmt->ops->scan && !fmt->ops->scan(fmt))
 			goto out;
 	}
@@ -507,6 +522,7 @@ struct volume_group *lvmcache_get_vg(const char *vgid, unsigned precommitted)
 	if (!(vg = import_vg_from_buffer(vginfo->vgmetadata, fid)) ||
 	    !vg_validate(vg)) {
 		_free_cached_vgmetadata(vginfo);
+		vg_release(vg);
 		return_NULL;
 	}
 
@@ -516,9 +532,9 @@ struct volume_group *lvmcache_get_vg(const char *vgid, unsigned precommitted)
 	return vg;
 }
 
-struct list *lvmcache_get_vgids(struct cmd_context *cmd, int full_scan)
+struct dm_list *lvmcache_get_vgids(struct cmd_context *cmd, int full_scan)
 {
-	struct list *vgids;
+	struct dm_list *vgids;
 	struct lvmcache_vginfo *vginfo;
 
 	lvmcache_label_scan(cmd, full_scan);
@@ -528,7 +544,7 @@ struct list *lvmcache_get_vgids(struct cmd_context *cmd, int full_scan)
 		return NULL;
 	}
 
-	list_iterate_items(vginfo, &_vginfos) {
+	dm_list_iterate_items(vginfo, &_vginfos) {
 		if (!str_list_add(cmd->mem, vgids,
 				  dm_pool_strdup(cmd->mem, vginfo->vgid))) {
 			log_error("strlist allocation failed");
@@ -539,9 +555,9 @@ struct list *lvmcache_get_vgids(struct cmd_context *cmd, int full_scan)
 	return vgids;
 }
 
-struct list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan)
+struct dm_list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan)
 {
-	struct list *vgnames;
+	struct dm_list *vgnames;
 	struct lvmcache_vginfo *vginfo;
 
 	lvmcache_label_scan(cmd, full_scan);
@@ -551,7 +567,7 @@ struct list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan)
 		return NULL;
 	}
 
-	list_iterate_items(vginfo, &_vginfos) {
+	dm_list_iterate_items(vginfo, &_vginfos) {
 		if (!str_list_add(cmd->mem, vgnames,
 				  dm_pool_strdup(cmd->mem, vginfo->vgname))) {
 			log_error("strlist allocation failed");
@@ -562,10 +578,10 @@ struct list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan)
 	return vgnames;
 }
 
-struct list *lvmcache_get_pvids(struct cmd_context *cmd, const char *vgname,
+struct dm_list *lvmcache_get_pvids(struct cmd_context *cmd, const char *vgname,
 				const char *vgid)
 {
-	struct list *pvids;
+	struct dm_list *pvids;
 	struct lvmcache_vginfo *vginfo;
 	struct lvmcache_info *info;
 
@@ -577,7 +593,7 @@ struct list *lvmcache_get_pvids(struct cmd_context *cmd, const char *vgname,
 	if (!(vginfo = vginfo_from_vgname(vgname, vgid)))
 		return pvids;
 
-	list_iterate_items(info, &vginfo->infos) {
+	dm_list_iterate_items(info, &vginfo->infos) {
 		if (!str_list_add(cmd->mem, pvids,
 				  dm_pool_strdup(cmd->mem, info->dev->pvid))) {
 			log_error("strlist allocation failed");
@@ -664,7 +680,7 @@ static int _free_vginfo(struct lvmcache_vginfo *vginfo)
 	    vginfo_from_vgid(vginfo->vgid) == vginfo)
 		dm_hash_remove(_vgid_hash, vginfo->vgid);
 
-	list_del(&vginfo->list);
+	dm_list_del(&vginfo->list);
 
 	dm_free(vginfo);
 
@@ -681,7 +697,7 @@ static int _drop_vginfo(struct lvmcache_info *info, struct lvmcache_vginfo *vgin
 
 	/* vginfo still referenced? */
 	if (!vginfo || is_orphan_vg(vginfo->vgname) ||
-	    !list_empty(&vginfo->infos))
+	    !dm_list_empty(&vginfo->infos))
 		return 1;
 
 	if (!_free_vginfo(vginfo))
@@ -707,11 +723,14 @@ void lvmcache_del(struct lvmcache_info *info)
 
 static int _lvmcache_update_pvid(struct lvmcache_info *info, const char *pvid)
 {
-	if (!strcmp(info->dev->pvid, pvid))
+	/*
+	 * Nothing to do if already stored with same pvid.
+	 */
+	if (((dm_hash_lookup(_pvid_hash, pvid)) == info) &&
+	    !strcmp(info->dev->pvid, pvid))
 		return 1;
-	if (*info->dev->pvid) {
+	if (*info->dev->pvid)
 		dm_hash_remove(_pvid_hash, info->dev->pvid);
-	}
 	strncpy(info->dev->pvid, pvid, sizeof(info->dev->pvid));
 	if (!dm_hash_insert(_pvid_hash, pvid, info)) {
 		log_error("_lvmcache_update: pvid insertion failed: %s", pvid);
@@ -904,7 +923,7 @@ static int _lvmcache_update_vgname(struct lvmcache_info *info,
 			log_error("cache vgname alloc failed for %s", vgname);
 			return 0;
 		}
-		list_init(&vginfo->infos);
+		dm_list_init(&vginfo->infos);
 
 		/*
 		 * If we're scanning and there's an invalidated entry, remove it.
@@ -912,13 +931,13 @@ static int _lvmcache_update_vgname(struct lvmcache_info *info,
 		 */
 		while ((primary_vginfo = vginfo_from_vgname(vgname, NULL)) &&
 		       _scanning_in_progress && _vginfo_is_invalid(primary_vginfo))
-			list_iterate_items_safe(info2, info3, &primary_vginfo->infos) {
+			dm_list_iterate_items_safe(info2, info3, &primary_vginfo->infos) {
 				orphan_vginfo = vginfo_from_vgname(primary_vginfo->fmt->orphan_vg_name, NULL);
 				_drop_vginfo(info2, primary_vginfo);	
 				_vginfo_attach_info(orphan_vginfo, info2);
 				if (info2->mdas.n)
 					sprintf(mdabuf, " with %u mdas",
-						list_size(&info2->mdas));
+						dm_list_size(&info2->mdas));
 				else
 					mdabuf[0] = '\0';
 				log_debug("lvmcache: %s: now in VG %s%s%s%s%s",
@@ -936,9 +955,9 @@ static int _lvmcache_update_vgname(struct lvmcache_info *info,
 		}
 		/* Ensure orphans appear last on list_iterate */
 		if (is_orphan_vg(vgname))
-			list_add(&_vginfos, &vginfo->list);
+			dm_list_add(&_vginfos, &vginfo->list);
 		else
-			list_add_h(&_vginfos, &vginfo->list);
+			dm_list_add_h(&_vginfos, &vginfo->list);
 /***
 		}
 ***/
@@ -956,7 +975,7 @@ static int _lvmcache_update_vgname(struct lvmcache_info *info,
 
 	if (info) {
 		if (info->mdas.n)
-			sprintf(mdabuf, " with %u mdas", list_size(&info->mdas));
+			sprintf(mdabuf, " with %u mdas", dm_list_size(&info->mdas));
 		else
 			mdabuf[0] = '\0';
 		log_debug("lvmcache: %s: now in VG %s%s%s%s%s",
@@ -1027,7 +1046,7 @@ int lvmcache_update_vgname_and_id(struct lvmcache_info *info,
 	}
 
 	/* If PV without mdas is already in a real VG, don't make it orphan */
-	if (is_orphan_vg(vgname) && info->vginfo && !list_size(&info->mdas) &&
+	if (is_orphan_vg(vgname) && info->vginfo && !dm_list_size(&info->mdas) &&
 	    !is_orphan_vg(info->vginfo->vgname) && memlock())
 		return 1;
 
@@ -1048,12 +1067,11 @@ int lvmcache_update_vg(struct volume_group *vg, unsigned precommitted)
 {
 	struct pv_list *pvl;
 	struct lvmcache_info *info;
-	struct lvmcache_vginfo *vginfo;
 	char pvid_s[ID_LEN + 1] __attribute((aligned(8)));
 
 	pvid_s[sizeof(pvid_s) - 1] = '\0';
 
-	list_iterate_items(pvl, &vg->pvs) {
+	dm_list_iterate_items(pvl, &vg->pvs) {
 		strncpy(pvid_s, (char *) &pvl->pv->id, sizeof(pvid_s) - 1);
 		/* FIXME Could pvl->pv->dev->pvid ever be different? */
 		if ((info = info_from_pvid(pvid_s, 0)) &&
@@ -1064,9 +1082,8 @@ int lvmcache_update_vg(struct volume_group *vg, unsigned precommitted)
 	}
 
 	/* store text representation of vg to cache */
-	if (vg->cmd->current_settings.cache_vgmetadata &&
-	    (vginfo = vginfo_from_vgname(vg->name, NULL)))
-		_store_metadata(vginfo, vg, precommitted);
+	if (vg->cmd->current_settings.cache_vgmetadata)
+		_store_metadata(vg, precommitted);
 
 	return 1;
 }
@@ -1101,7 +1118,7 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 
 		label->info = info;
 		info->label = label;
-		list_init(&info->list);
+		dm_list_init(&info->list);
 		info->dev = dev;
 	} else {
 		if (existing->dev != dev) {
@@ -1136,11 +1153,15 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 			//else if (dm_is_dm_major(MAJOR(existing->dev->dev)) &&
 				 //dm_is_dm_major(MAJOR(dev->dev)))
 				 //
-			else
+			else if (!strcmp(pvid_s, existing->dev->pvid)) 
 				log_error("Found duplicate PV %s: using %s not "
 					  "%s", pvid, dev_name(dev),
 					  dev_name(existing->dev));
 		}
+		if (strcmp(pvid_s, existing->dev->pvid)) 
+			log_debug("Updating pvid cache to %s (%s) from %s (%s)",
+				  pvid_s, dev_name(dev),
+				  existing->dev->pvid, dev_name(existing->dev));
 		/* Switch over to new preferred device */
 		existing->dev = dev;
 		info = existing;
@@ -1246,9 +1267,9 @@ void lvmcache_destroy(struct cmd_context *cmd, int retain_orphans)
 		_lock_hash = NULL;
 	}
 
-	if (!list_empty(&_vginfos))
+	if (!dm_list_empty(&_vginfos))
 		log_error("Internal error: _vginfos list should be empty");
-	list_init(&_vginfos);
+	dm_list_init(&_vginfos);
 
 	if (retain_orphans)
 		init_lvmcache_orphans(cmd);

lib/cache/lvmcache.h

@@ -35,8 +35,8 @@ struct volume_group;
 
 /* One per VG */
 struct lvmcache_vginfo {
-	struct list list;	/* Join these vginfos together */
-	struct list infos;	/* List head for lvmcache_infos */
+	struct dm_list list;	/* Join these vginfos together */
+	struct dm_list infos;	/* List head for lvmcache_infos */
 	const struct format_type *fmt;
 	char *vgname;		/* "" == orphan */
 	uint32_t status;
@@ -50,9 +50,9 @@ struct lvmcache_vginfo {
 
 /* One per device */
 struct lvmcache_info {
-	struct list list;	/* Join VG members together */
-	struct list mdas;	/* list head for metadata areas */
-	struct list das;	/* list head for data areas */
+	struct dm_list list;	/* Join VG members together */
+	struct dm_list mdas;	/* list head for metadata areas */
+	struct dm_list das;	/* list head for data areas */
 	struct lvmcache_vginfo *vginfo;	/* NULL == unknown */
 	struct label *label;
 	const struct format_type *fmt;
@@ -98,14 +98,14 @@ int vgname_is_locked(const char *vgname);
 
 /* Returns list of struct str_lists containing pool-allocated copy of vgnames */
 /* Set full_scan to 1 to reread every filtered device label */
-struct list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan);
+struct dm_list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan);
 
 /* Returns list of struct str_lists containing pool-allocated copy of vgids */
 /* Set full_scan to 1 to reread every filtered device label */
-struct list *lvmcache_get_vgids(struct cmd_context *cmd, int full_scan);
+struct dm_list *lvmcache_get_vgids(struct cmd_context *cmd, int full_scan);
 
 /* Returns list of struct str_lists containing pool-allocated copy of pvids */
-struct list *lvmcache_get_pvids(struct cmd_context *cmd, const char *vgname,
+struct dm_list *lvmcache_get_pvids(struct cmd_context *cmd, const char *vgname,
 				const char *vgid);
 
 /* Returns cached volume group metadata. */

lib/commands/errors.h

@@ -21,4 +21,6 @@
 #define EINVALID_CMD_LINE	3
 #define ECMD_FAILED		5
 
+/* FIXME Also returned by cmdlib. */
+
 #endif

lib/commands/toolcontext.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -64,7 +64,7 @@ static int _get_env_vars(struct cmd_context *cmd)
 
 	/* Set to "" to avoid using any system directory */
 	if ((e = getenv("LVM_SYSTEM_DIR"))) {
-		if (dm_snprintf(cmd->sys_dir, sizeof(cmd->sys_dir),
+		if (dm_snprintf(cmd->system_dir, sizeof(cmd->system_dir),
 				 "%s", e) < 0) {
 			log_error("LVM_SYSTEM_DIR environment variable "
 				  "is too long.");
@@ -75,6 +75,49 @@ static int _get_env_vars(struct cmd_context *cmd)
 	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 %s", 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;
@@ -119,6 +162,7 @@ static void _init_logging(struct cmd_context *cmd)
 	/* 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))
@@ -154,6 +198,7 @@ static int _process_config(struct cmd_context *cmd)
 {
 	mode_t old_umask;
 	const char *read_ahead;
+	struct stat st;
 
 	/* umask */
 	cmd->default_settings.umask = find_config_tree_int(cmd,
@@ -189,6 +234,8 @@ static int _process_config(struct cmd_context *cmd)
 		cmd->proc_dir[0] = '\0';
 	}
 
+	_get_sysfs_dir(cmd);
+
 	/* activation? */
 	cmd->default_settings.activation = find_config_tree_int(cmd,
 							   "global/activation",
@@ -218,6 +265,30 @@ static int _process_config(struct cmd_context *cmd)
 		return 0;
 	}
 
+	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";
+		}
+	}
+
 	return 1;
 }
 
@@ -322,7 +393,7 @@ static int _load_config_file(struct cmd_context *cmd, const char *tag)
 		filler = "_";
 
 	if (dm_snprintf(config_file, sizeof(config_file), "%s/lvm%s%s.conf",
-			 cmd->sys_dir, filler, tag) < 0) {
+			 cmd->system_dir, filler, tag) < 0) {
 		log_error("LVM_SYSTEM_DIR or tag was too long");
 		return 0;
 	}
@@ -340,7 +411,7 @@ static int _load_config_file(struct cmd_context *cmd, const char *tag)
 	/* Is there a config file? */
 	if (stat(config_file, &info) == -1) {
 		if (errno == ENOENT) {
-			list_add(&cmd->config_files, &cfl->list);
+			dm_list_add(&cmd->config_files, &cfl->list);
 			goto out;
 		}
 		log_sys_error("stat", config_file);
@@ -355,7 +426,7 @@ static int _load_config_file(struct cmd_context *cmd, const char *tag)
 		return 0;
 	}
 
-	list_add(&cmd->config_files, &cfl->list);
+	dm_list_add(&cmd->config_files, &cfl->list);
 
       out:
 	if (*tag)
@@ -371,7 +442,7 @@ static int _load_config_file(struct cmd_context *cmd, const char *tag)
 static int _init_lvm_conf(struct cmd_context *cmd)
 {
 	/* No config file if LVM_SYSTEM_DIR is empty */
-	if (!*cmd->sys_dir) {
+	if (!*cmd->system_dir) {
 		if (!(cmd->cft = create_config_tree(NULL, 0))) {
 			log_error("Failed to create config tree");
 			return 0;
@@ -391,7 +462,7 @@ static int _init_tag_configs(struct cmd_context *cmd)
 	struct str_list *sl;
 
 	/* Tag list may grow while inside this loop */
-	list_iterate_items(sl, &cmd->tags) {
+	dm_list_iterate_items(sl, &cmd->tags) {
 		if (!_load_config_file(cmd, sl->str))
 			return_0;
 	}
@@ -411,7 +482,7 @@ static int _merge_config_files(struct cmd_context *cmd)
 		}
 	}
 
-	list_iterate_items(cfl, &cmd->config_files) {
+	dm_list_iterate_items(cfl, &cmd->config_files) {
 		/* Merge all config trees into cmd->cft using merge/tag rules */
 		if (!merge_config_tree(cmd, cmd->cft, cfl->cft))
 			return_0;
@@ -422,10 +493,10 @@ static int _merge_config_files(struct cmd_context *cmd)
 
 static void _destroy_tags(struct cmd_context *cmd)
 {
-	struct list *slh, *slht;
+	struct dm_list *slh, *slht;
 
-	list_iterate_safe(slh, slht, &cmd->tags) {
-		list_del(slh);
+	dm_list_iterate_safe(slh, slht, &cmd->tags) {
+		dm_list_del(slh);
 	}
 }
 
@@ -433,7 +504,7 @@ int config_files_changed(struct cmd_context *cmd)
 {
 	struct config_tree_list *cfl;
 
-	list_iterate_items(cfl, &cmd->config_files) {
+	dm_list_iterate_items(cfl, &cmd->config_files) {
 		if (config_file_changed(cfl->cft))
 			return 1;
 	}
@@ -445,16 +516,18 @@ static void _destroy_tag_configs(struct cmd_context *cmd)
 {
 	struct config_tree_list *cfl;
 
-	if (cmd->cft && cmd->cft->root) {
+	dm_list_iterate_items(cfl, &cmd->config_files) {
+		if (cfl->cft == cmd->cft)
+			cmd->cft = NULL;
+		destroy_config_tree(cfl->cft);
+	}
+
+	if (cmd->cft) {
 		destroy_config_tree(cmd->cft);
 		cmd->cft = NULL;
 	}
 
-	list_iterate_items(cfl, &cmd->config_files) {
-		destroy_config_tree(cfl->cft);
-	}
-
-	list_init(&cmd->config_files);
+	dm_list_init(&cmd->config_files);
 }
 
 static int _init_dev_cache(struct cmd_context *cmd)
@@ -534,7 +607,7 @@ static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
 	 */
 	if (find_config_tree_bool(cmd, "devices/sysfs_scan",
 			     DEFAULT_SYSFS_SCAN)) {
-		if ((filters[nr_filt] = sysfs_filter_create(cmd->proc_dir)))
+		if ((filters[nr_filt] = sysfs_filter_create(cmd->sysfs_dir)))
 			nr_filt++;
 	}
 
@@ -592,7 +665,7 @@ static int _init_filters(struct cmd_context *cmd, unsigned load_persistent_cache
 	if (cache_dir || cache_file_prefix) {
 		if (dm_snprintf(cache_file, sizeof(cache_file),
 		    "%s%s%s/%s.cache",
-		    cache_dir ? "" : cmd->sys_dir,
+		    cache_dir ? "" : cmd->system_dir,
 		    cache_dir ? "" : "/",
 		    cache_dir ? : DEFAULT_CACHE_SUBDIR,
 		    cache_file_prefix ? : DEFAULT_CACHE_FILE_PREFIX) < 0) {
@@ -602,7 +675,7 @@ static int _init_filters(struct cmd_context *cmd, unsigned load_persistent_cache
 	} else if (!(dev_cache = find_config_tree_str(cmd, "devices/cache", NULL)) &&
 		   (dm_snprintf(cache_file, sizeof(cache_file),
 				"%s/%s/%s.cache",
-				cmd->sys_dir, DEFAULT_CACHE_SUBDIR,
+				cmd->system_dir, DEFAULT_CACHE_SUBDIR,
 				DEFAULT_CACHE_FILE_PREFIX) < 0)) {
 		log_error("Persistent cache filename too long.");
 		return 0;
@@ -620,7 +693,7 @@ static int _init_filters(struct cmd_context *cmd, unsigned load_persistent_cache
 	if (find_config_tree_int(cmd, "devices/write_cache_state", 1))
 		cmd->dump_filter = 1;
 
-	if (!*cmd->sys_dir)
+	if (!*cmd->system_dir)
 		cmd->dump_filter = 0;
 
 	/*
@@ -655,19 +728,19 @@ static int _init_formats(struct cmd_context *cmd)
 	if (!(fmt = init_lvm1_format(cmd)))
 		return 0;
 	fmt->library = NULL;
-	list_add(&cmd->formats, &fmt->list);
+	dm_list_add(&cmd->formats, &fmt->list);
 #endif
 
 #ifdef POOL_INTERNAL
 	if (!(fmt = init_pool_format(cmd)))
 		return 0;
 	fmt->library = NULL;
-	list_add(&cmd->formats, &fmt->list);
+	dm_list_add(&cmd->formats, &fmt->list);
 #endif
 
 #ifdef HAVE_LIBDL
 	/* Load any formats in shared libs if not static */
-	if (!cmd->is_static &&
+	if (!is_static() &&
 	    (cn = find_config_tree_node(cmd, "global/format_libraries"))) {
 
 		struct config_value *cv;
@@ -694,7 +767,7 @@ static int _init_formats(struct cmd_context *cmd)
 			if (!(fmt = init_format_fn(cmd)))
 				return 0;
 			fmt->library = lib;
-			list_add(&cmd->formats, &fmt->list);
+			dm_list_add(&cmd->formats, &fmt->list);
 		}
 	}
 #endif
@@ -702,17 +775,18 @@ static int _init_formats(struct cmd_context *cmd)
 	if (!(fmt = create_text_format(cmd)))
 		return 0;
 	fmt->library = NULL;
-	list_add(&cmd->formats, &fmt->list);
+	dm_list_add(&cmd->formats, &fmt->list);
 
 	cmd->fmt_backup = fmt;
 
 	format = find_config_tree_str(cmd, "global/format",
 				 DEFAULT_FORMAT);
 
-	list_iterate_items(fmt, &cmd->formats) {
+	dm_list_iterate_items(fmt, &cmd->formats) {
 		if (!strcasecmp(fmt->name, format) ||
 		    (fmt->alias && !strcasecmp(fmt->alias, format))) {
 			cmd->default_settings.fmt = fmt;
+			cmd->fmt = cmd->default_settings.fmt;
 			return 1;
 		}
 	}
@@ -725,16 +799,63 @@ int init_lvmcache_orphans(struct cmd_context *cmd)
 {
 	struct format_type *fmt;
 
-	list_iterate_items(fmt, &cmd->formats)
+	dm_list_iterate_items(fmt, &cmd->formats)
 		if (!lvmcache_add_orphan_vginfo(fmt->orphan_vg_name, fmt))
 			return_0;
 
 	return 1;
 }
 
+struct segtype_library {
+	struct cmd_context *cmd;
+	void *lib;
+	const char *libname;
+};
+
+int lvm_register_segtype(struct segtype_library *seglib,
+			 struct segment_type *segtype)
+{
+	struct segment_type *segtype2;
+
+	segtype->library = seglib->lib;
+	segtype->cmd = seglib->cmd;
+
+	dm_list_iterate_items(segtype2, &seglib->cmd->segtypes) {
+		if (strcmp(segtype2->name, segtype->name))
+			continue;
+		log_error("Duplicate segment type %s: "
+			  "unloading shared library %s",
+			  segtype->name, seglib->libname);
+		segtype->ops->destroy(segtype);
+		return 0;
+	}
+
+	dm_list_add(&seglib->cmd->segtypes, &segtype->list);
+
+	return 1;
+}
+
+static int _init_single_segtype(struct segtype_library *seglib)
+{
+	struct segment_type *(*init_segtype_fn) (struct cmd_context *);
+	struct segment_type *segtype;
+
+	if (!(init_segtype_fn = dlsym(seglib->lib, "init_segtype"))) {
+		log_error("Shared library %s does not contain segment type "
+			  "functions", seglib->libname);
+		return 0;
+	}
+
+	if (!(segtype = init_segtype_fn(seglib->cmd)))
+		return_0;
+
+	return lvm_register_segtype(seglib, segtype);
+}
+
 static int _init_segtypes(struct cmd_context *cmd)
 {
 	struct segment_type *segtype;
+	struct segtype_library seglib = { .cmd = cmd };
 
 #ifdef HAVE_LIBDL
 	const struct config_node *cn;
@@ -743,46 +864,46 @@ static int _init_segtypes(struct cmd_context *cmd)
 	if (!(segtype = init_striped_segtype(cmd)))
 		return 0;
 	segtype->library = NULL;
-	list_add(&cmd->segtypes, &segtype->list);
+	dm_list_add(&cmd->segtypes, &segtype->list);
 
 	if (!(segtype = init_zero_segtype(cmd)))
 		return 0;
 	segtype->library = NULL;
-	list_add(&cmd->segtypes, &segtype->list);
+	dm_list_add(&cmd->segtypes, &segtype->list);
 
 	if (!(segtype = init_error_segtype(cmd)))
 		return 0;
 	segtype->library = NULL;
-	list_add(&cmd->segtypes, &segtype->list);
+	dm_list_add(&cmd->segtypes, &segtype->list);
 
 	if (!(segtype = init_free_segtype(cmd)))
 		return 0;
 	segtype->library = NULL;
-	list_add(&cmd->segtypes, &segtype->list);
+	dm_list_add(&cmd->segtypes, &segtype->list);
 
 #ifdef SNAPSHOT_INTERNAL
 	if (!(segtype = init_snapshot_segtype(cmd)))
 		return 0;
 	segtype->library = NULL;
-	list_add(&cmd->segtypes, &segtype->list);
+	dm_list_add(&cmd->segtypes, &segtype->list);
 #endif
 
 #ifdef MIRRORED_INTERNAL
 	if (!(segtype = init_mirrored_segtype(cmd)))
 		return 0;
 	segtype->library = NULL;
-	list_add(&cmd->segtypes, &segtype->list);
+	dm_list_add(&cmd->segtypes, &segtype->list);
 #endif
 
 #ifdef HAVE_LIBDL
 	/* Load any formats in shared libs unless static */
-	if (!cmd->is_static &&
+	if (!is_static() &&
 	    (cn = find_config_tree_node(cmd, "global/segment_libraries"))) {
 
 		struct config_value *cv;
-		struct segment_type *(*init_segtype_fn) (struct cmd_context *);
-		void *lib;
-		struct segment_type *segtype2;
+		int (*init_multiple_segtypes_fn) (struct segtype_library *);
+
+		seglib.cmd = cmd;
 
 		for (cv = cn->v; cv; cv = cv->next) {
 			if (cv->type != CFG_STRING) {
@@ -790,32 +911,37 @@ static int _init_segtypes(struct cmd_context *cmd)
 					  "global/segment_libraries");
 				return 0;
 			}
-			if (!(lib = load_shared_library(cmd, cv->v.str,
+			seglib.libname = cv->v.str;
+			if (!(seglib.lib = load_shared_library(cmd,
+							seglib.libname,
 							"segment type", 0)))
 				return_0;
 
-			if (!(init_segtype_fn = dlsym(lib, "init_segtype"))) {
-				log_error("Shared library %s does not contain "
-					  "segment type functions", cv->v.str);
-				dlclose(lib);
-				return 0;
-			}
-
-			if (!(segtype = init_segtype_fn(cmd)))
-				return 0;
-			segtype->library = lib;
-			list_add(&cmd->segtypes, &segtype->list);
-
-			list_iterate_items(segtype2, &cmd->segtypes) {
-				if ((segtype == segtype2) ||
-				     strcmp(segtype2->name, segtype->name))
-					continue;
-				log_error("Duplicate segment type %s: "
-					  "unloading shared library %s",
-					  segtype->name, cv->v.str);
-				list_del(&segtype->list);
-				segtype->ops->destroy(segtype);
-				dlclose(lib);
+			if ((init_multiple_segtypes_fn =
+			    dlsym(seglib.lib, "init_multiple_segtypes"))) {
+				if (dlsym(seglib.lib, "init_segtype"))
+					log_warn("WARNING: Shared lib %s has "
+						 "conflicting init fns.  Using"
+						 " init_multiple_segtypes().",
+						 seglib.libname);
+			} else
+				init_multiple_segtypes_fn =
+				    _init_single_segtype;
+ 
+			if (!init_multiple_segtypes_fn(&seglib)) {
+				struct dm_list *sgtl, *tmp;
+				log_error("init_multiple_segtypes() failed: "
+					  "Unloading shared library %s",
+					  seglib.libname);
+				dm_list_iterate_safe(sgtl, tmp, &cmd->segtypes) {
+					segtype = dm_list_item(sgtl, struct segment_type);
+					if (segtype->library == seglib.lib) {
+						dm_list_del(&segtype->list);
+						segtype->ops->destroy(segtype);
+					}
+				}
+				dlclose(seglib.lib);
+				return_0;
 			}
 		}
 	}
@@ -852,10 +978,10 @@ static int _init_backup(struct cmd_context *cmd)
 	char default_dir[PATH_MAX];
 	const char *dir;
 
-	if (!cmd->sys_dir) {
+	if (!cmd->system_dir) {
 		log_warn("WARNING: Metadata changes will NOT be backed up");
-		backup_init(cmd, "");
-		archive_init(cmd, "", 0, 0);
+		backup_init(cmd, "", 0);
+		archive_init(cmd, "", 0, 0, 0);
 		return 1;
 	}
 
@@ -871,18 +997,19 @@ static int _init_backup(struct cmd_context *cmd)
 					 DEFAULT_ARCHIVE_NUMBER);
 
 	if (dm_snprintf
-	    (default_dir, sizeof(default_dir), "%s/%s", cmd->sys_dir,
+	    (default_dir, sizeof(default_dir), "%s/%s", cmd->system_dir,
 	     DEFAULT_ARCHIVE_SUBDIR) == -1) {
 		log_err("Couldn't create default archive path '%s/%s'.",
-			cmd->sys_dir, DEFAULT_ARCHIVE_SUBDIR);
+			cmd->system_dir, DEFAULT_ARCHIVE_SUBDIR);
 		return 0;
 	}
 
 	dir = find_config_tree_str(cmd, "backup/archive_dir",
 			      default_dir);
 
-	if (!archive_init(cmd, dir, days, min)) {
-		log_debug("backup_init failed.");
+	if (!archive_init(cmd, dir, days, min,
+			  cmd->default_settings.archive)) {
+		log_debug("archive_init failed.");
 		return 0;
 	}
 
@@ -892,16 +1019,16 @@ static int _init_backup(struct cmd_context *cmd)
 			     DEFAULT_BACKUP_ENABLED);
 
 	if (dm_snprintf
-	    (default_dir, sizeof(default_dir), "%s/%s", cmd->sys_dir,
+	    (default_dir, sizeof(default_dir), "%s/%s", cmd->system_dir,
 	     DEFAULT_BACKUP_SUBDIR) == -1) {
 		log_err("Couldn't create default backup path '%s/%s'.",
-			cmd->sys_dir, DEFAULT_BACKUP_SUBDIR);
+			cmd->system_dir, DEFAULT_BACKUP_SUBDIR);
 		return 0;
 	}
 
 	dir = find_config_tree_str(cmd, "backup/backup_dir", default_dir);
 
-	if (!backup_init(cmd, dir)) {
+	if (!backup_init(cmd, dir, cmd->default_settings.backup)) {
 		log_debug("backup_init failed.");
 		return 0;
 	}
@@ -909,9 +1036,24 @@ static int _init_backup(struct cmd_context *cmd)
 	return 1;
 }
 
+static void _init_rand(struct cmd_context *cmd)
+{
+	if (read_urandom(&cmd->rand_seed, sizeof(cmd->rand_seed)))
+		return;
+
+	cmd->rand_seed = (unsigned) time(NULL) + (unsigned) getpid();
+}
+
+static void _init_globals(struct cmd_context *cmd)
+{
+	init_full_scan_done(0);
+	init_mirror_in_sync(0);
+
+}
+
 /* Entry point */
-struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static,
-				       unsigned is_long_lived)
+struct cmd_context *create_toolcontext(unsigned is_long_lived,
+				       const char *system_dir)
 {
 	struct cmd_context *cmd;
 
@@ -933,22 +1075,27 @@ struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static,
 		return NULL;
 	}
 	memset(cmd, 0, sizeof(*cmd));
-	cmd->args = the_args;
-	cmd->is_static = is_static;
 	cmd->is_long_lived = is_long_lived;
+	cmd->handles_missing_pvs = 0;
 	cmd->hosttags = 0;
-	list_init(&cmd->formats);
-	list_init(&cmd->segtypes);
-	list_init(&cmd->tags);
-	list_init(&cmd->config_files);
+	dm_list_init(&cmd->formats);
+	dm_list_init(&cmd->segtypes);
+	dm_list_init(&cmd->tags);
+	dm_list_init(&cmd->config_files);
 
-	strcpy(cmd->sys_dir, DEFAULT_SYS_DIR);
+	/*
+	 * Environment variable LVM_SYSTEM_DIR overrides this below.
+	 */
+        if (system_dir)
+		strncpy(cmd->system_dir, system_dir, sizeof(cmd->system_dir) - 1);
+	else
+		strcpy(cmd->system_dir, DEFAULT_SYS_DIR);
 
 	if (!_get_env_vars(cmd))
 		goto error;
 
 	/* Create system directory if it doesn't already exist */
-	if (*cmd->sys_dir && !dm_create_dir(cmd->sys_dir)) {
+	if (*cmd->system_dir && !dm_create_dir(cmd->system_dir)) {
 		log_error("Failed to create LVM2 system dir for metadata backups, config "
 			  "files and internal cache.");
 		log_error("Set environment variable LVM_SYSTEM_DIR to alternative location "
@@ -1006,6 +1153,10 @@ struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static,
 	if (!_init_backup(cmd))
 		goto error;
 
+	_init_rand(cmd);
+
+	_init_globals(cmd);
+
 	cmd->default_settings.cache_vgmetadata = 1;
 	cmd->current_settings = cmd->default_settings;
 
@@ -1013,19 +1164,27 @@ struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static,
 	return cmd;
 
       error:
+	_destroy_tag_configs(cmd);
+	dev_cache_exit();
+	if (cmd->filter)
+		cmd->filter->destroy(cmd->filter);
+	if (cmd->mem)
+		dm_pool_destroy(cmd->mem);
+	if (cmd->libmem)
+		dm_pool_destroy(cmd->libmem);
 	dm_free(cmd);
 	return NULL;
 }
 
-static void _destroy_formats(struct list *formats)
+static void _destroy_formats(struct dm_list *formats)
 {
-	struct list *fmtl, *tmp;
+	struct dm_list *fmtl, *tmp;
 	struct format_type *fmt;
 	void *lib;
 
-	list_iterate_safe(fmtl, tmp, formats) {
-		fmt = list_item(fmtl, struct format_type);
-		list_del(&fmt->list);
+	dm_list_iterate_safe(fmtl, tmp, formats) {
+		fmt = dm_list_item(fmtl, struct format_type);
+		dm_list_del(&fmt->list);
 		lib = fmt->library;
 		fmt->ops->destroy(fmt);
 #ifdef HAVE_LIBDL
@@ -1035,20 +1194,30 @@ static void _destroy_formats(struct list *formats)
 	}
 }
 
-static void _destroy_segtypes(struct list *segtypes)
+static void _destroy_segtypes(struct dm_list *segtypes)
 {
-	struct list *sgtl, *tmp;
+	struct dm_list *sgtl, *tmp;
 	struct segment_type *segtype;
 	void *lib;
 
-	list_iterate_safe(sgtl, tmp, segtypes) {
-		segtype = list_item(sgtl, struct segment_type);
-		list_del(&segtype->list);
+	dm_list_iterate_safe(sgtl, tmp, segtypes) {
+		segtype = dm_list_item(sgtl, struct segment_type);
+		dm_list_del(&segtype->list);
 		lib = segtype->library;
 		segtype->ops->destroy(segtype);
 #ifdef HAVE_LIBDL
-		if (lib)
+		/*
+		 * If no segtypes remain from this library, close it.
+		 */
+		if (lib) {
+			struct segment_type *segtype2;
+			dm_list_iterate_items(segtype2, segtypes)
+				if (segtype2->library == lib)
+					goto skip_dlclose;
 			dlclose(lib);
+skip_dlclose:
+			;
+		}
 #endif
 	}
 }
@@ -1133,12 +1302,15 @@ void destroy_toolcontext(struct cmd_context *cmd)
 	label_exit();
 	_destroy_segtypes(&cmd->segtypes);
 	_destroy_formats(&cmd->formats);
-	cmd->filter->destroy(cmd->filter);
-	dm_pool_destroy(cmd->mem);
+	if (cmd->filter)
+		cmd->filter->destroy(cmd->filter);
+	if (cmd->mem)
+		dm_pool_destroy(cmd->mem);
 	dev_cache_exit();
 	_destroy_tags(cmd);
 	_destroy_tag_configs(cmd);
-	dm_pool_destroy(cmd->libmem);
+	if (cmd->libmem)
+		dm_pool_destroy(cmd->libmem);
 	dm_free(cmd);
 
 	release_log_memory();

lib/commands/toolcontext.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
- * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -57,22 +57,23 @@ struct cmd_context {
 	const struct format_type *fmt;	/* Current format to use by default */
 	struct format_type *fmt_backup;	/* Format to use for backups */
 
-	struct list formats;	/* Available formats */
-	struct list segtypes;	/* Available segment types */
+	struct dm_list formats;	/* Available formats */
+	struct dm_list segtypes;	/* Available segment types */
 	const char *hostname;
 	const char *kernel_vsn;
 
-	char *cmd_line;
+	unsigned rand_seed;
+	const char *cmd_line;
 	struct command *command;
-	struct arg *args;
 	char **argv;
-	unsigned is_static;	/* Static binary? */
-	unsigned is_long_lived;	/* Optimises persistent_filter handling */
+	unsigned is_long_lived:1;	/* Optimises persistent_filter handling */
+	unsigned handles_missing_pvs:1;
+	unsigned partial_activation:1;
 
 	struct dev_filter *filter;
 	int dump_filter;	/* Dump filter when exiting? */
 
-	struct list config_files;
+	struct dm_list config_files;
 	int config_valid;
 	struct config_tree *cft;
 	struct config_tree *cft_override;
@@ -81,17 +82,24 @@ struct cmd_context {
 
 	struct archive_params *archive_params;
 	struct backup_params *backup_params;
+	const char *stripe_filler;
 
 	/* List of defined tags */
-	struct list tags;
+	struct dm_list tags;
 	int hosttags;
 
-	char sys_dir[PATH_MAX];
+	char system_dir[PATH_MAX];
 	char dev_dir[PATH_MAX];
 	char proc_dir[PATH_MAX];
+	char sysfs_dir[PATH_MAX];
 };
 
-struct cmd_context *create_toolcontext(struct arg *the_args, unsigned is_static, unsigned is_long_lived);
+/*
+ * system_dir may be NULL to use the default value.
+ * The environment variable LVM_SYSTEM_DIR always takes precedence.
+ */
+struct cmd_context *create_toolcontext(unsigned is_long_lived,
+				       const char *system_dir);
 void destroy_toolcontext(struct cmd_context *cmd);
 int refresh_toolcontext(struct cmd_context *cmd);
 int config_files_changed(struct cmd_context *cmd);

lib/config/config.c

@@ -457,9 +457,9 @@ static int _write_config(struct config_node *n, int only_one,
 			line_append(" {");
 			if (!_line_end(outline))
 				return_0;
+			_write_config(n->child, 0, outline, level + 1);
 			if (!_line_start(outline))
 				return_0;
-			_write_config(n->child, 0, outline, level + 1);
 			line_append("%s}", space);
 		} else {
 			/* it's a value */
@@ -546,6 +546,7 @@ static struct config_node *_file(struct parser *p)
 			root = n;
 		else
 			l->sib = n;
+		n->parent = root;
 		l = n;
 	}
 	return root;
@@ -573,6 +574,7 @@ static struct config_node *_section(struct parser *p)
 				root->child = n;
 			else
 				l->sib = n;
+			n->parent = root;
 			l = n;
 		}
 		match(TOK_SECTION_E);
@@ -1165,7 +1167,7 @@ static void _merge_section(struct config_node *cn1, struct config_node *cn2)
 	}
 }
 
-static int _match_host_tags(struct list *tags, struct config_node *tn)
+static int _match_host_tags(struct dm_list *tags, struct config_node *tn)
 {
 	struct config_value *tv;
 	const char *str;
@@ -1251,6 +1253,10 @@ static unsigned _count_tokens(const char *str, unsigned len, int type)
 	return count_chars(str, len, c);
 }
 
+const char *config_parent_name(const struct config_node *n)
+{
+	return (n->parent ? n->parent->key : "(root)");
+}
 /*
  * Heuristic function to make a quick guess as to whether a text
  * region probably contains a valid config "section".  (Useful for

lib/config/config.h

@@ -40,7 +40,7 @@ struct config_value {
 
 struct config_node {
 	char *key;
-	struct config_node *sib, *child;
+	struct config_node *parent, *sib, *child;
 	struct config_value *v;
 };
 
@@ -49,7 +49,7 @@ struct config_tree {
 };
 
 struct config_tree_list {
-	struct list list;
+	struct dm_list list;
 	struct config_tree *cft;
 };
 
@@ -110,4 +110,6 @@ int get_config_str(const struct config_node *cn, const char *path,
 
 unsigned maybe_config_section(const char *str, unsigned len);
 
+const char *config_parent_name(const struct config_node *n);
+
 #endif

lib/config/defaults.h

@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
- * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -32,6 +32,7 @@
 #define DEFAULT_PROC_DIR "/proc"
 #define DEFAULT_SYSFS_SCAN 1
 #define DEFAULT_MD_COMPONENT_DETECTION 1
+#define DEFAULT_MD_CHUNK_ALIGNMENT 1
 #define DEFAULT_IGNORE_SUSPENDED_DEVICES 1
 
 #define DEFAULT_LOCK_DIR "/var/lock/lvm"
@@ -65,6 +66,10 @@
 #define DEFAULT_LABELSECTOR UINT64_C(1)
 #define DEFAULT_READ_AHEAD "auto"
 #define DEFAULT_EXTENT_SIZE 4096	/* In KB */
+#define DEFAULT_MAX_PV 0
+#define DEFAULT_MAX_LV 0
+#define DEFAULT_ALLOC_POLICY ALLOC_NORMAL
+#define DEFAULT_CLUSTERED 0
 
 #define DEFAULT_MSG_PREFIX "  "
 #define DEFAULT_CMD_NAME 0
@@ -91,7 +96,7 @@
 #  define DEFAULT_ACTIVATION 0
 #endif
 
-#define DEFAULT_STRIPE_FILLER "/dev/ioerror"
+#define DEFAULT_STRIPE_FILLER "error"
 #define DEFAULT_MIRROR_REGION_SIZE 512	/* KB */
 #define DEFAULT_INTERVAL 15
 
@@ -125,4 +130,7 @@
 #define DEFAULT_SEGS_SORT "vg_name,lv_name,seg_start"
 #define DEFAULT_PVSEGS_SORT "pv_name,pvseg_start"
 
+#define DEFAULT_MIRROR_DEVICE_FAULT_POLICY "remove"
+#define DEFAULT_MIRROR_LOG_FAULT_POLICY "allocate"
+
 #endif				/* _LVM_DEFAULTS_H */

lib/datastruct/list.c

@@ -19,7 +19,7 @@
  * Initialise a list before use.
  * The list head's next and previous pointers point back to itself.
  */
-void list_init(struct list *head)
+void dm_list_init(struct dm_list *head)
 {
 	head->n = head->p = head;
 }
@@ -28,7 +28,7 @@ void list_init(struct list *head)
  * Insert an element before 'head'.
  * If 'head' is the list head, this adds an element to the end of the list.
  */
-void list_add(struct list *head, struct list *elem)
+void dm_list_add(struct dm_list *head, struct dm_list *elem)
 {
 	assert(head->n);
 
@@ -43,7 +43,7 @@ void list_add(struct list *head, struct list *elem)
  * Insert an element after 'head'.
  * If 'head' is the list head, this adds an element to the front of the list.
  */
-void list_add_h(struct list *head, struct list *elem)
+void dm_list_add_h(struct dm_list *head, struct dm_list *elem)
 {
 	assert(head->n);
 
@@ -59,7 +59,7 @@ void list_add_h(struct list *head, struct list *elem)
  * Note that this doesn't change the element itself - it may still be safe
  * to follow its pointers.
  */
-void list_del(struct list *elem)
+void dm_list_del(struct dm_list *elem)
 {
 	elem->n->p = elem->p;
 	elem->p->n = elem->n;
@@ -68,16 +68,16 @@ void list_del(struct list *elem)
 /*
  * Remove an element from existing list and insert before 'head'.
  */
-void list_move(struct list *head, struct list *elem)
+void dm_list_move(struct dm_list *head, struct dm_list *elem)
 {
-        list_del(elem);
-        list_add(head, elem);
+        dm_list_del(elem);
+        dm_list_add(head, elem);
 }
 
 /*
  * Is the list empty?
  */
-int list_empty(const struct list *head)
+int dm_list_empty(const struct dm_list *head)
 {
 	return head->n == head;
 }
@@ -85,7 +85,7 @@ int list_empty(const struct list *head)
 /*
  * Is this the first element of the list?
  */
-int list_start(const struct list *head, const struct list *elem)
+int dm_list_start(const struct dm_list *head, const struct dm_list *elem)
 {
 	return elem->p == head;
 }
@@ -93,7 +93,7 @@ int list_start(const struct list *head, const struct list *elem)
 /*
  * Is this the last element of the list?
  */
-int list_end(const struct list *head, const struct list *elem)
+int dm_list_end(const struct dm_list *head, const struct dm_list *elem)
 {
 	return elem->n == head;
 }
@@ -101,44 +101,44 @@ int list_end(const struct list *head, const struct list *elem)
 /*
  * Return first element of the list or NULL if empty
  */
-struct list *list_first(const struct list *head)
+struct dm_list *dm_list_first(const struct dm_list *head)
 {
-	return (list_empty(head) ? NULL : head->n);
+	return (dm_list_empty(head) ? NULL : head->n);
 }
 
 /*
  * Return last element of the list or NULL if empty
  */
-struct list *list_last(const struct list *head)
+struct dm_list *dm_list_last(const struct dm_list *head)
 {
-	return (list_empty(head) ? NULL : head->p);
+	return (dm_list_empty(head) ? NULL : head->p);
 }
 
 /*
  * Return the previous element of the list, or NULL if we've reached the start.
  */
-struct list *list_prev(const struct list *head, const struct list *elem)
+struct dm_list *dm_list_prev(const struct dm_list *head, const struct dm_list *elem)
 {
-	return (list_start(head, elem) ? NULL : elem->p);
+	return (dm_list_start(head, elem) ? NULL : elem->p);
 }
 
 /*
  * Return the next element of the list, or NULL if we've reached the end.
  */
-struct list *list_next(const struct list *head, const struct list *elem)
+struct dm_list *dm_list_next(const struct dm_list *head, const struct dm_list *elem)
 {
-	return (list_end(head, elem) ? NULL : elem->n);
+	return (dm_list_end(head, elem) ? NULL : elem->n);
 }
 
 /*
  * Return the number of elements in a list by walking it.
  */
-unsigned int list_size(const struct list *head)
+unsigned int dm_list_size(const struct dm_list *head)
 {
 	unsigned int s = 0;
-	const struct list *v;
+	const struct dm_list *v;
 
-	list_iterate(v, head)
+	dm_list_iterate(v, head)
 	    s++;
 
 	return s;

lib/datastruct/list.h

@@ -24,106 +24,106 @@
  * The list head's pointers point to the first and the last element.
  */
 
-struct list {
-	struct list *n, *p;
+struct dm_list {
+	struct dm_list *n, *p;
 };
 
 /*
  * Initialise a list before use.
  * The list head's next and previous pointers point back to itself.
  */
-#define LIST_INIT(name)	struct list name = { &(name), &(name) }
-void list_init(struct list *head);
+#define DM_LIST_INIT(name)	struct dm_list name = { &(name), &(name) }
+void dm_list_init(struct dm_list *head);
 
 /*
  * Insert an element before 'head'.
  * If 'head' is the list head, this adds an element to the end of the list.
  */
-void list_add(struct list *head, struct list *elem);
+void dm_list_add(struct dm_list *head, struct dm_list *elem);
 
 /*
  * Insert an element after 'head'.
  * If 'head' is the list head, this adds an element to the front of the list.
  */
-void list_add_h(struct list *head, struct list *elem);
+void dm_list_add_h(struct dm_list *head, struct dm_list *elem);
 
 /*
  * Delete an element from its list.
  * Note that this doesn't change the element itself - it may still be safe
  * to follow its pointers.
  */
-void list_del(struct list *elem);
+void dm_list_del(struct dm_list *elem);
 
 /*
  * Remove an element from existing list and insert before 'head'.
  */
-void list_move(struct list *head, struct list *elem);
+void dm_list_move(struct dm_list *head, struct dm_list *elem);
 
 /*
  * Is the list empty?
  */
-int list_empty(const struct list *head);
+int dm_list_empty(const struct dm_list *head);
 
 /*
  * Is this the first element of the list?
  */
-int list_start(const struct list *head, const struct list *elem);
+int dm_list_start(const struct dm_list *head, const struct dm_list *elem);
 
 /*
  * Is this the last element of the list?
  */
-int list_end(const struct list *head, const struct list *elem);
+int dm_list_end(const struct dm_list *head, const struct dm_list *elem);
 
 /*
  * Return first element of the list or NULL if empty
  */
-struct list *list_first(const struct list *head);
+struct dm_list *dm_list_first(const struct dm_list *head);
 
 /*
  * Return last element of the list or NULL if empty
  */
-struct list *list_last(const struct list *head);
+struct dm_list *dm_list_last(const struct dm_list *head);
 
 /*
  * Return the previous element of the list, or NULL if we've reached the start.
  */
-struct list *list_prev(const struct list *head, const struct list *elem);
+struct dm_list *dm_list_prev(const struct dm_list *head, const struct dm_list *elem);
 
 /*
  * Return the next element of the list, or NULL if we've reached the end.
  */
-struct list *list_next(const struct list *head, const struct list *elem);
+struct dm_list *dm_list_next(const struct dm_list *head, const struct dm_list *elem);
 
 /*
- * Given the address v of an instance of 'struct list' called 'head' 
+ * Given the address v of an instance of 'struct dm_list' called 'head' 
  * contained in a structure of type t, return the containing structure.
  */
-#define list_struct_base(v, t, head) \
+#define dm_list_struct_base(v, t, head) \
     ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->head))
 
 /*
- * Given the address v of an instance of 'struct list list' contained in
+ * Given the address v of an instance of 'struct dm_list list' contained in
  * a structure of type t, return the containing structure.
  */
-#define list_item(v, t) list_struct_base((v), t, list)
+#define dm_list_item(v, t) dm_list_struct_base((v), t, list)
 
 /*
  * Given the address v of one known element e in a known structure of type t,
  * return another element f.
  */
-#define struct_field(v, t, e, f) \
+#define dm_struct_field(v, t, e, f) \
     (((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->e))->f)
 
 /*
  * Given the address v of a known element e in a known structure of type t,
  * return the list head 'list'
  */
-#define list_head(v, t, e) struct_field(v, t, e, list)
+#define dm_list_head(v, t, e) dm_struct_field(v, t, e, list)
 
 /*
  * Set v to each element of a list in turn.
  */
-#define list_iterate(v, head) \
+#define dm_list_iterate(v, head) \
 	for (v = (head)->n; v != head; v = v->n)
 
 /*
@@ -133,7 +133,7 @@ struct list *list_next(const struct list *head, const struct list *elem);
  * already-processed elements.
  * If 'start' is 'head' it walks the list backwards.
  */
-#define list_uniterate(v, head, start) \
+#define dm_list_uniterate(v, head, start) \
 	for (v = (start)->p; v != head; v = v->p)
 
 /*
@@ -141,68 +141,68 @@ struct list *list_next(const struct list *head, const struct list *elem);
  * the way.
  * t must be defined as a temporary variable of the same type as v.
  */
-#define list_iterate_safe(v, t, head) \
+#define dm_list_iterate_safe(v, t, head) \
 	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)
 
 /*
  * Walk a list, setting 'v' in turn to the containing structure of each item.
  * The containing structure should be the same type as 'v'.
- * The 'struct list' variable within the containing structure is 'field'.
+ * The 'struct dm_list' variable within the containing structure is 'field'.
  */
-#define list_iterate_items_gen(v, head, field) \
-	for (v = list_struct_base((head)->n, typeof(*v), field); \
+#define dm_list_iterate_items_gen(v, head, field) \
+	for (v = dm_list_struct_base((head)->n, typeof(*v), field); \
 	     &v->field != (head); \
-	     v = list_struct_base(v->field.n, typeof(*v), field))
+	     v = dm_list_struct_base(v->field.n, typeof(*v), field))
 
 /*
  * Walk a list, setting 'v' in turn to the containing structure of each item.
  * The containing structure should be the same type as 'v'.
- * The list should be 'struct list list' within the containing structure.
+ * The list should be 'struct dm_list list' within the containing structure.
  */
-#define list_iterate_items(v, head) list_iterate_items_gen(v, (head), list)
+#define dm_list_iterate_items(v, head) dm_list_iterate_items_gen(v, (head), list)
 
 /*
  * Walk a list, setting 'v' in turn to the containing structure of each item.
  * The containing structure should be the same type as 'v'.
- * The 'struct list' variable within the containing structure is 'field'.
+ * The 'struct dm_list' variable within the containing structure is 'field'.
  * t must be defined as a temporary variable of the same type as v.
  */
-#define list_iterate_items_gen_safe(v, t, head, field) \
-	for (v = list_struct_base((head)->n, typeof(*v), field), \
-	     t = list_struct_base(v->field.n, typeof(*v), field); \
+#define dm_list_iterate_items_gen_safe(v, t, head, field) \
+	for (v = dm_list_struct_base((head)->n, typeof(*v), field), \
+	     t = dm_list_struct_base(v->field.n, typeof(*v), field); \
 	     &v->field != (head); \
-	     v = t, t = list_struct_base(v->field.n, typeof(*v), field))
+	     v = t, t = dm_list_struct_base(v->field.n, typeof(*v), field))
 /*
  * Walk a list, setting 'v' in turn to the containing structure of each item.
  * The containing structure should be the same type as 'v'.
- * The list should be 'struct list list' within the containing structure.
+ * The list should be 'struct dm_list list' within the containing structure.
  * t must be defined as a temporary variable of the same type as v.
  */
-#define list_iterate_items_safe(v, t, head) \
-	list_iterate_items_gen_safe(v, t, (head), list)
+#define dm_list_iterate_items_safe(v, t, head) \
+	dm_list_iterate_items_gen_safe(v, t, (head), list)
 
 /*
  * Walk a list backwards, setting 'v' in turn to the containing structure 
  * of each item.
  * The containing structure should be the same type as 'v'.
- * The 'struct list' variable within the containing structure is 'field'.
+ * The 'struct dm_list' variable within the containing structure is 'field'.
  */
-#define list_iterate_back_items_gen(v, head, field) \
-	for (v = list_struct_base((head)->p, typeof(*v), field); \
+#define dm_list_iterate_back_items_gen(v, head, field) \
+	for (v = dm_list_struct_base((head)->p, typeof(*v), field); \
 	     &v->field != (head); \
-	     v = list_struct_base(v->field.p, typeof(*v), field))
+	     v = dm_list_struct_base(v->field.p, typeof(*v), field))
 
 /*
  * Walk a list backwards, setting 'v' in turn to the containing structure 
  * of each item.
  * The containing structure should be the same type as 'v'.
- * The list should be 'struct list list' within the containing structure.
+ * The list should be 'struct dm_list list' within the containing structure.
  */
-#define list_iterate_back_items(v, head) list_iterate_back_items_gen(v, (head), list)
+#define dm_list_iterate_back_items(v, head) dm_list_iterate_back_items_gen(v, (head), list)
 
 /*
  * Return the number of elements in a list by walking it.
  */
-unsigned int list_size(const struct list *head);
+unsigned int dm_list_size(const struct dm_list *head);
 
 #endif

lib/datastruct/lvm-types.h

@@ -16,8 +16,6 @@
 #ifndef _LVM_TYPES_H
 #define _LVM_TYPES_H
 
-#include "list.h"
-
 #include <sys/types.h>
 #include <inttypes.h>
 
@@ -27,7 +25,7 @@
 #define PRIpid_t PRId32
 
 struct str_list {
-	struct list list;
+	struct dm_list list;
 	const char *str;
 };
 

lib/datastruct/str_list.c

@@ -16,19 +16,19 @@
 #include "lib.h"
 #include "str_list.h"
 
-struct list *str_list_create(struct dm_pool *mem)
+struct dm_list *str_list_create(struct dm_pool *mem)
 {
-	struct list *sl;
+	struct dm_list *sl;
 
-	if (!(sl = dm_pool_alloc(mem, sizeof(struct list))))
+	if (!(sl = dm_pool_alloc(mem, sizeof(struct dm_list))))
 		return_NULL;
 
-	list_init(sl);
+	dm_list_init(sl);
 
 	return sl;
 }
 
-int str_list_add(struct dm_pool *mem, struct list *sll, const char *str)
+int str_list_add(struct dm_pool *mem, struct dm_list *sll, const char *str)
 {
 	struct str_list *sln;
 
@@ -43,31 +43,31 @@ int str_list_add(struct dm_pool *mem, struct list *sll, const char *str)
 		return_0;
 
 	sln->str = str;
-	list_add(sll, &sln->list);
+	dm_list_add(sll, &sln->list);
 
 	return 1;
 }
 
-int str_list_del(struct list *sll, const char *str)
+int str_list_del(struct dm_list *sll, const char *str)
 {
-	struct list *slh, *slht;
+	struct dm_list *slh, *slht;
 
-	list_iterate_safe(slh, slht, sll) {
-		if (!strcmp(str, list_item(slh, struct str_list)->str))
-			 list_del(slh);
+	dm_list_iterate_safe(slh, slht, sll) {
+		if (!strcmp(str, dm_list_item(slh, struct str_list)->str))
+			 dm_list_del(slh);
 	}
 
 	return 1;
 }
 
-int str_list_dup(struct dm_pool *mem, struct list *sllnew,
-		 const struct list *sllold)
+int str_list_dup(struct dm_pool *mem, struct dm_list *sllnew,
+		 const struct dm_list *sllold)
 {
 	struct str_list *sl;
 
-	list_init(sllnew);
+	dm_list_init(sllnew);
 
-	list_iterate_items(sl, sllold) {
+	dm_list_iterate_items(sl, sllold) {
 		if (!str_list_add(mem, sllnew, dm_pool_strdup(mem, sl->str)))
 			return_0;
 	}
@@ -78,11 +78,11 @@ int str_list_dup(struct dm_pool *mem, struct list *sllnew,
 /*
  * Is item on list?
  */
-int str_list_match_item(const struct list *sll, const char *str)
+int str_list_match_item(const struct dm_list *sll, const char *str)
 {
 	struct str_list *sl;
 
-	list_iterate_items(sl, sll)
+	dm_list_iterate_items(sl, sll)
 	    if (!strcmp(str, sl->str))
 		return 1;
 
@@ -92,11 +92,11 @@ int str_list_match_item(const struct list *sll, const char *str)
 /*
  * Is at least one item on both lists?
  */
-int str_list_match_list(const struct list *sll, const struct list *sll2)
+int str_list_match_list(const struct dm_list *sll, const struct dm_list *sll2)
 {
 	struct str_list *sl;
 
-	list_iterate_items(sl, sll)
+	dm_list_iterate_items(sl, sll)
 	    if (str_list_match_item(sll2, sl->str))
 		return 1;
 
@@ -106,14 +106,14 @@ int str_list_match_list(const struct list *sll, const struct list *sll2)
 /*
  * Do both lists contain the same set of items?
  */
-int str_list_lists_equal(const struct list *sll, const struct list *sll2)
+int str_list_lists_equal(const struct dm_list *sll, const struct dm_list *sll2)
 {
 	struct str_list *sl;
 
-	if (list_size(sll) != list_size(sll2))
+	if (dm_list_size(sll) != dm_list_size(sll2))
 		return 0;
 
-	list_iterate_items(sl, sll)
+	dm_list_iterate_items(sl, sll)
 	    if (!str_list_match_item(sll2, sl->str))
 		return 0;
 

lib/datastruct/str_list.h

@@ -16,13 +16,13 @@
 #ifndef _LVM_STR_LIST_H
 #define _LVM_STR_LIST_H
 
-struct list *str_list_create(struct dm_pool *mem);
-int str_list_add(struct dm_pool *mem, struct list *sll, const char *str);
-int str_list_del(struct list *sll, const char *str);
-int str_list_match_item(const struct list *sll, const char *str);
-int str_list_match_list(const struct list *sll, const struct list *sll2);
-int str_list_lists_equal(const struct list *sll, const struct list *sll2);
-int str_list_dup(struct dm_pool *mem, struct list *sllnew,
-		 const struct list *sllold);
+struct dm_list *str_list_create(struct dm_pool *mem);
+int str_list_add(struct dm_pool *mem, struct dm_list *sll, const char *str);
+int str_list_del(struct dm_list *sll, const char *str);
+int str_list_match_item(const struct dm_list *sll, const char *str);
+int str_list_match_list(const struct dm_list *sll, const struct dm_list *sll2);
+int str_list_lists_equal(const struct dm_list *sll, const struct dm_list *sll2);
+int str_list_dup(struct dm_pool *mem, struct dm_list *sllnew,
+		 const struct dm_list *sllold);
 
 #endif

lib/device/dev-cache.c

@@ -31,7 +31,7 @@ struct dev_iter {
 };
 
 struct dir_list {
-	struct list list;
+	struct dm_list list;
 	char dir[0];
 };
 
@@ -42,8 +42,8 @@ static struct {
 	struct dm_regex *preferred_names_matcher;
 
 	int has_scanned;
-	struct list dirs;
-	struct list files;
+	struct dm_list dirs;
+	struct dm_list files;
 
 } _cache;
 
@@ -97,15 +97,16 @@ struct device *dev_create_file(const char *filename, struct device *dev,
 	}
 
 	dev->flags |= DEV_REGULAR;
-	list_init(&dev->aliases);
-	list_add(&dev->aliases, &alias->list);
+	dm_list_init(&dev->aliases);
+	dm_list_add(&dev->aliases, &alias->list);
 	dev->end = UINT64_C(0);
 	dev->dev = 0;
 	dev->fd = -1;
 	dev->open_count = 0;
 	dev->block_size = -1;
+	dev->read_ahead = -1;
 	memset(dev->pvid, 0, sizeof(dev->pvid));
-	list_init(&dev->open_list);
+	dm_list_init(&dev->open_list);
 
 	return dev;
 }
@@ -119,14 +120,15 @@ static struct device *_dev_create(dev_t d)
 		return NULL;
 	}
 	dev->flags = 0;
-	list_init(&dev->aliases);
+	dm_list_init(&dev->aliases);
 	dev->dev = d;
 	dev->fd = -1;
 	dev->open_count = 0;
 	dev->block_size = -1;
+	dev->read_ahead = -1;
 	dev->end = UINT64_C(0);
 	memset(dev->pvid, 0, sizeof(dev->pvid));
-	list_init(&dev->open_list);
+	dm_list_init(&dev->open_list);
 
 	return dev;
 }
@@ -140,8 +142,8 @@ void dev_set_preferred_name(struct str_list *sl, struct device *dev)
 		return;
 
 	log_debug("%s: New preferred name", sl->str);
-	list_del(&sl->list);
-	list_add_h(&dev->aliases, &sl->list);
+	dm_list_del(&sl->list);
+	dm_list_add_h(&dev->aliases, &sl->list);
 }
 
 /* Return 1 if we prefer path1 else return 0 */
@@ -240,7 +242,7 @@ static int _add_alias(struct device *dev, const char *path)
 		return_0;
 
 	/* Is name already there? */
-	list_iterate_items(strl, &dev->aliases) {
+	dm_list_iterate_items(strl, &dev->aliases) {
 		if (!strcmp(strl->str, path)) {
 			log_debug("%s: Already in device cache", path);
 			return 1;
@@ -250,8 +252,8 @@ static int _add_alias(struct device *dev, const char *path)
 	if (!(sl->str = dm_pool_strdup(_cache.mem, path)))
 		return_0;
 
-	if (!list_empty(&dev->aliases)) {
-		oldpath = list_item(dev->aliases.n, struct str_list)->str;
+	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)");
@@ -260,9 +262,9 @@ static int _add_alias(struct device *dev, const char *path)
 		log_debug("%s: Added to device cache", path);
 
 	if (prefer_old)
-		list_add(&dev->aliases, &sl->list);
+		dm_list_add(&dev->aliases, &sl->list);
 	else
-		list_add_h(&dev->aliases, &sl->list);
+		dm_list_add_h(&dev->aliases, &sl->list);
 
 	return 1;
 }
@@ -443,10 +445,10 @@ static void _full_scan(int dev_scan)
 	if (_cache.has_scanned && !dev_scan)
 		return;
 
-	list_iterate_items(dl, &_cache.dirs)
+	dm_list_iterate_items(dl, &_cache.dirs)
 		_insert_dir(dl->dir);
 
-	list_iterate_items(dl, &_cache.files)
+	dm_list_iterate_items(dl, &_cache.files)
 		_insert_file(dl->dir);
 
 	_cache.has_scanned = 1;
@@ -543,8 +545,8 @@ int dev_cache_init(struct cmd_context *cmd)
 		goto bad;
 	}
 
-	list_init(&_cache.dirs);
-	list_init(&_cache.files);
+	dm_list_init(&_cache.dirs);
+	dm_list_init(&_cache.files);
 
 	if (!_init_preferred_names(cmd))
 		goto_bad;
@@ -587,8 +589,8 @@ void dev_cache_exit(void)
 
 	_cache.devices = NULL;
 	_cache.has_scanned = 0;
-	list_init(&_cache.dirs);
-	list_init(&_cache.files);
+	dm_list_init(&_cache.dirs);
+	dm_list_init(&_cache.files);
 }
 
 int dev_cache_add_dir(const char *path)
@@ -613,7 +615,7 @@ int dev_cache_add_dir(const char *path)
 	}
 
 	strcpy(dl->dir, path);
-	list_add(&_cache.dirs, &dl->list);
+	dm_list_add(&_cache.dirs, &dl->list);
 	return 1;
 }
 
@@ -639,7 +641,7 @@ int dev_cache_add_loopfile(const char *path)
 	}
 
 	strcpy(dl->dir, path);
-	list_add(&_cache.files, &dl->list);
+	dm_list_add(&_cache.files, &dl->list);
 	return 1;
 }
 
@@ -656,7 +658,7 @@ const char *dev_name_confirmed(struct device *dev, int quiet)
 	if ((dev->flags & DEV_REGULAR))
 		return dev_name(dev);
 
-	while ((r = stat(name = list_item(dev->aliases.n,
+	while ((r = stat(name = dm_list_item(dev->aliases.n,
 					  struct str_list)->str, &buf)) ||
 	       (buf.st_rdev != dev->dev)) {
 		if (r < 0) {
@@ -680,8 +682,8 @@ const char *dev_name_confirmed(struct device *dev, int quiet)
 		/* 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 (list_size(&dev->aliases) > 1) {
-			list_del(dev->aliases.n);
+		if (dm_list_size(&dev->aliases) > 1) {
+			dm_list_del(dev->aliases.n);
 			if (!r)
 				_insert(name, 0);
 			continue;
@@ -776,6 +778,6 @@ int dev_fd(struct device *dev)
 
 const char *dev_name(const struct device *dev)
 {
-	return (dev) ? list_item(dev->aliases.n, struct str_list)->str :
+	return (dev) ? dm_list_item(dev->aliases.n, struct str_list)->str :
 	    "unknown device";
 }

lib/device/dev-io.c

@@ -51,7 +51,7 @@
 #  endif
 #endif
 
-static LIST_INIT(_open_devices);
+static DM_LIST_INIT(_open_devices);
 
 /*-----------------------------------------------------------------
  * The standard io loop that keeps submitting an io until it's
@@ -262,18 +262,65 @@ static int _dev_get_size_dev(const struct device *dev, uint64_t *size)
 	return 1;
 }
 
+static int _dev_read_ahead_dev(struct device *dev, uint32_t *read_ahead)
+{
+	long read_ahead_long;
+
+	if (dev->read_ahead != -1) {
+		*read_ahead = (uint32_t) dev->read_ahead;
+		return 1;
+	}
+
+	if (!dev_open(dev))
+		return_0;
+
+	if (ioctl(dev->fd, BLKRAGET, &read_ahead_long) < 0) {
+		log_sys_error("ioctl BLKRAGET", dev_name(dev));
+		if (!dev_close(dev))
+			stack;
+		return 0;
+	}
+
+	if (!dev_close(dev))
+		stack;
+
+	*read_ahead = (uint32_t) read_ahead_long;
+	dev->read_ahead = read_ahead_long;
+
+	log_very_verbose("%s: read_ahead is %u sectors",
+			 dev_name(dev), *read_ahead);
+
+	return 1;
+}
+
 /*-----------------------------------------------------------------
  * Public functions
  *---------------------------------------------------------------*/
 
 int dev_get_size(const struct device *dev, uint64_t *size)
 {
+	if (!dev)
+		return 0;
+
 	if ((dev->flags & DEV_REGULAR))
 		return _dev_get_size_file(dev, size);
 	else
 		return _dev_get_size_dev(dev, size);
 }
 
+int dev_get_read_ahead(struct device *dev, uint32_t *read_ahead)
+{
+	if (!dev)
+		return 0;
+
+	if (dev->flags & DEV_REGULAR) {
+		*read_ahead = 0;
+		return 1;
+	}
+
+	return _dev_read_ahead_dev(dev, read_ahead);
+}
+
 /* FIXME Unused
 int dev_get_sectsize(struct device *dev, uint32_t *size)
 {
@@ -431,7 +478,7 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 	if ((flags & O_CREAT) && !(flags & O_TRUNC))
 		dev->end = lseek(dev->fd, (off_t) 0, SEEK_END);
 
-	list_add(&_open_devices, &dev->open_list);
+	dm_list_add(&_open_devices, &dev->open_list);
 
 	log_debug("Opened %s %s%s%s", dev_name(dev),
 		  dev->flags & DEV_OPENED_RW ? "RW" : "RO",
@@ -480,12 +527,12 @@ static void _close(struct device *dev)
 		log_sys_error("close", dev_name(dev));
 	dev->fd = -1;
 	dev->block_size = -1;
-	list_del(&dev->open_list);
+	dm_list_del(&dev->open_list);
 
 	log_debug("Closed %s", dev_name(dev));
 
 	if (dev->flags & DEV_ALLOCED) {
-		dm_free((void *) list_item(dev->aliases.n, struct str_list)->
+		dm_free((void *) dm_list_item(dev->aliases.n, struct str_list)->
 			 str);
 		dm_free(dev->aliases.n);
 		dm_free(dev);
@@ -537,11 +584,11 @@ int dev_close_immediate(struct device *dev)
 
 void dev_close_all(void)
 {
-	struct list *doh, *doht;
+	struct dm_list *doh, *doht;
 	struct device *dev;
 
-	list_iterate_safe(doh, doht, &_open_devices) {
-		dev = list_struct_base(doh, struct device, open_list);
+	dm_list_iterate_safe(doh, doht, &_open_devices) {
+		dev = dm_list_struct_base(doh, struct device, open_list);
 		if (dev->open_count < 1)
 			_close(dev);
 	}

lib/device/dev-md.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2004 Luca Berra
- * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -16,6 +16,7 @@
 #include "lib.h"
 #include "metadata.h"
 #include "xlate.h"
+#include "filter.h"
 
 #ifdef linux
 
@@ -124,6 +125,188 @@ out:
 	return ret;
 }
 
+static int _md_sysfs_attribute_snprintf(char *path, size_t size,
+					const char *sysfs_dir,
+					struct device *dev,
+					const char *attribute)
+{
+	struct stat info;
+	int ret = -1;
+
+	if (MAJOR(dev->dev) != md_major())
+		return ret;
+
+	if (!sysfs_dir || !*sysfs_dir)
+		return ret;
+
+	ret = dm_snprintf(path, size, "%s/dev/block/%d:%d/md/%s",
+	      sysfs_dir, MAJOR(dev->dev), MINOR(dev->dev), attribute);
+	if (ret < 0) {
+		log_error("dm_snprintf md %s failed", attribute);
+		return ret;
+	}
+
+	if (stat(path, &info) < 0) {
+		/* old sysfs structure */
+		ret = dm_snprintf(path, size, "%s/block/md%d/md/%s",
+				  sysfs_dir, MINOR(dev->dev), attribute);
+		if (ret < 0) {
+			log_error("dm_snprintf old md %s failed", attribute);
+			return ret;
+		}
+	}
+
+	return ret;
+}
+
+static int _md_sysfs_attribute_scanf(const char *sysfs_dir,
+				     struct device *dev,
+				     const char *attribute_name,
+				     const char *attribute_fmt,
+				     void *attribute_value)
+{
+	char path[PATH_MAX+1], buffer[64];
+	FILE *fp;
+	int ret = 0;
+
+	if (_md_sysfs_attribute_snprintf(path, PATH_MAX, sysfs_dir,
+					 dev, attribute_name) < 0)
+		return ret;
+
+	if (!(fp = fopen(path, "r"))) {
+		log_sys_error("fopen", path);
+		return ret;
+	}
+
+	if (!fgets(buffer, sizeof(buffer), fp)) {
+		log_sys_error("fgets", path);
+		goto out;
+	}
+
+	if ((ret = sscanf(buffer, attribute_fmt, attribute_value)) != 1) {
+		log_error("%s sysfs attr %s not in expected format: %s",
+			  dev_name(dev), attribute_name, buffer);
+		goto out;
+	}
+
+out:
+	if (fclose(fp))
+		log_sys_error("fclose", path);
+
+	return ret;
+}
+
+/*
+ * Retrieve chunk size from md device using sysfs.
+ */
+static unsigned long dev_md_chunk_size(const char *sysfs_dir,
+				       struct device *dev)
+{
+	const char *attribute = "chunk_size";
+	unsigned long chunk_size_bytes = 0UL;
+
+	if (_md_sysfs_attribute_scanf(sysfs_dir, dev, attribute,
+				      "%lu", &chunk_size_bytes) != 1)
+		return 0;
+
+	log_very_verbose("Device %s %s is %lu bytes.",
+			 dev_name(dev), attribute, chunk_size_bytes);
+
+	return chunk_size_bytes >> SECTOR_SHIFT;
+}
+
+/*
+ * Retrieve level from md device using sysfs.
+ */
+static int dev_md_level(const char *sysfs_dir, struct device *dev)
+{
+	const char *attribute = "level";
+	int level = -1;
+
+	if (_md_sysfs_attribute_scanf(sysfs_dir, dev, attribute,
+				      "raid%d", &level) != 1)
+		return -1;
+
+	log_very_verbose("Device %s %s is raid%d.",
+			 dev_name(dev), attribute, level);
+
+	return level;
+}
+
+/*
+ * Retrieve raid_disks from md device using sysfs.
+ */
+static int dev_md_raid_disks(const char *sysfs_dir, struct device *dev)
+{
+	const char *attribute = "raid_disks";
+	int raid_disks = 0;
+
+	if (_md_sysfs_attribute_scanf(sysfs_dir, dev, attribute,
+				      "%d", &raid_disks) != 1)
+		return 0;
+
+	log_very_verbose("Device %s %s is %d.",
+			 dev_name(dev), attribute, raid_disks);
+
+	return raid_disks;
+}
+
+/*
+ * Calculate stripe width of md device using its sysfs files.
+ */
+unsigned long dev_md_stripe_width(const char *sysfs_dir, struct device *dev)
+{
+	unsigned long chunk_size_sectors = 0UL;
+	unsigned long stripe_width_sectors = 0UL;
+	int level, raid_disks, data_disks;
+
+	chunk_size_sectors = dev_md_chunk_size(sysfs_dir, dev);
+	if (!chunk_size_sectors)
+		return 0;
+
+	level = dev_md_level(sysfs_dir, dev);
+	if (level < 0)
+		return 0;
+
+	raid_disks = dev_md_raid_disks(sysfs_dir, dev);
+	if (!raid_disks)
+		return 0;
+
+	/* The raid level governs the number of data disks. */
+	switch (level) {
+	case 0:
+		/* striped md does not have any parity disks */
+		data_disks = raid_disks;
+		break;
+	case 1:
+	case 10:
+		/* mirrored md effectively has 1 data disk */
+		data_disks = 1;
+		break;
+	case 4:
+	case 5:
+		/* both raid 4 and 5 have a single parity disk */
+		data_disks = raid_disks - 1;
+		break;
+	case 6:
+		/* raid 6 has 2 parity disks */
+		data_disks = raid_disks - 2;
+		break;
+	default:
+		log_error("Device %s has an unknown md raid level: %d",
+			  dev_name(dev), level);
+		return 0;
+	}
+
+	stripe_width_sectors = chunk_size_sectors * data_disks;
+
+	log_very_verbose("Device %s stripe-width is %lu bytes.",
+			 dev_name(dev),
+			 stripe_width_sectors << SECTOR_SHIFT);
+
+	return stripe_width_sectors;
+}
+
 #else
 
 int dev_is_md(struct device *dev __attribute((unused)),
@@ -132,4 +315,10 @@ int dev_is_md(struct device *dev __attribute((unused)),
 	return 0;
 }
 
+unsigned long dev_md_stripe_width(const char *sysfs_dir __attribute((unused)),
+				  struct device *dev  __attribute((unused)))
+{
+	return 0UL;
+}
+
 #endif

lib/device/dev-swap.c

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2009 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "metadata.h"
+#include "xlate.h"
+#include "filter.h"
+
+#ifdef linux
+
+#define MAX_PAGESIZE	(64 * 1024)
+#define SIGNATURE_SIZE  10
+
+static int
+_swap_detect_signature(const char *buf)
+{
+	if (memcmp(buf, "SWAP-SPACE", 10) == 0 ||
+            memcmp(buf, "SWAPSPACE2", 10) == 0)
+		return 1;
+
+	if (memcmp(buf, "S1SUSPEND", 9) == 0 ||
+	    memcmp(buf, "S2SUSPEND", 9) == 0 ||
+	    memcmp(buf, "ULSUSPEND", 9) == 0 ||
+	    memcmp(buf, "\xed\xc3\x02\xe9\x98\x56\xe5\x0c", 8) == 0)
+		return 1;
+
+	return 0;
+}
+
+int dev_is_swap(struct device *dev, uint64_t *signature)
+{
+	char buf[10];
+	uint64_t size;
+	int page;
+
+	if (!dev_get_size(dev, &size)) {
+		stack;
+		return -1;
+	}
+
+	if (!dev_open(dev)) {
+		stack;
+		return -1;
+	}
+
+	*signature = 0;
+
+	for (page = 0x1000; page <= MAX_PAGESIZE; page <<= 1) {
+		/*
+		 * skip 32k pagesize since this does not seem to be supported
+		 */
+		if (page == 0x8000)
+			continue;
+		if (size < page)
+			break;
+		if (!dev_read(dev, page - SIGNATURE_SIZE,
+			      SIGNATURE_SIZE, buf)) {
+			stack;
+			return -1;
+		}
+		if (_swap_detect_signature(buf)) {
+			*signature = page - SIGNATURE_SIZE;
+			break;
+		}
+	}
+
+	if (!dev_close(dev))
+		stack;
+
+	if (*signature)
+		return 1;
+
+	return 0;
+}
+
+#endif

lib/device/device.c

@@ -43,6 +43,10 @@ static int _is_partitionable(struct device *dev)
 {
 	int parts = max_partitions(MAJOR(dev->dev));
 
+	/* All MD devices are partitionable via blkext (as of 2.6.28) */
+	if (MAJOR(dev->dev) == md_major())
+		return 1;
+
 	if ((parts <= 1) || (MINOR(dev->dev) % parts))
 		return 0;
 

lib/device/device.h

@@ -33,23 +33,24 @@
  * pointer comparisons are valid.
  */
 struct device {
-	struct list aliases;	/* struct str_list from lvm-types.h */
+	struct dm_list aliases;	/* struct str_list from lvm-types.h */
 	dev_t dev;
 
 	/* private */
 	int fd;
 	int open_count;
 	int block_size;
+	int read_ahead;
 	uint32_t flags;
 	uint64_t end;
-	struct list open_list;
+	struct dm_list open_list;
 
 	char pvid[ID_LEN + 1];
 	char _padding[7];
 };
 
 struct device_list {
-	struct list list;
+	struct dm_list list;
 	struct device *dev;
 };
 
@@ -64,6 +65,7 @@ struct device_area {
  */
 int dev_get_size(const struct device *dev, uint64_t *size);
 int dev_get_sectsize(struct device *dev, uint32_t *size);
+int dev_get_read_ahead(struct device *dev, uint32_t *read_ahead);
 
 /* Use quiet version if device number could change e.g. when opening LV */
 int dev_open(struct device *dev);
@@ -93,6 +95,8 @@ const char *dev_name_confirmed(struct device *dev, int quiet);
 
 /* Does device contain md superblock?  If so, where? */
 int dev_is_md(struct device *dev, uint64_t *sb);
+int dev_is_swap(struct device *dev, uint64_t *signature);
+unsigned long dev_md_stripe_width(const char *sysfs_dir, struct device *dev);
 
 int is_partitioned_dev(struct device *dev);
 

lib/display/display.c

@@ -62,14 +62,14 @@ uint64_t units_to_bytes(const char *units, char *unit_type)
 		v = UINT64_C(1);
 		*unit_type = *units;
 		break;
-	case 's':
-		v *= SECTOR_SIZE;
-		break;
 	case 'b':
 	case 'B':
 		v *= UINT64_C(1);
 		break;
 #define KILO UINT64_C(1024)
+	case 's':
+		v *= (KILO/2);
+		break;
 	case 'k':
 		v *= KILO;
 		break;
@@ -90,6 +90,9 @@ uint64_t units_to_bytes(const char *units, char *unit_type)
 		break;
 #undef KILO
 #define KILO UINT64_C(1000)
+	case 'S':
+		v *= (KILO/2);
+		break;
 	case 'K':
 		v *= KILO;
 		break;
@@ -266,7 +269,7 @@ void pvdisplay_segments(const struct physical_volume *pv)
 	if (pv->pe_size)
 		log_print("--- Physical Segments ---");
 
-	list_iterate_items(pvseg, &pv->segments) {
+	dm_list_iterate_items(pvseg, &pv->segments) {
 		log_print("Physical extent %u to %u:",
 			  pvseg->pe, pvseg->pe + pvseg->len - 1);
 
@@ -425,7 +428,7 @@ int lvdisplay_full(struct cmd_context *cmd,
 	if (lv_is_origin(lv)) {
 		log_print("LV snapshot status     source of");
 
-		list_iterate_items_gen(snap_seg, &lv->snapshot_segs,
+		dm_list_iterate_items_gen(snap_seg, &lv->snapshot_segs,
 				       origin_list) {
 			if (inkernel &&
 			    (snap_active = lv_snapshot_percent(snap_seg->cow,
@@ -483,7 +486,7 @@ int lvdisplay_full(struct cmd_context *cmd,
 			  display_size(cmd, (uint64_t) snap_seg->chunk_size));
 	}
 
-	log_print("Segments               %u", list_size(&lv->segments));
+	log_print("Segments               %u", dm_list_size(&lv->segments));
 
 /********* FIXME Stripes & stripesize for each segment
 	log_print("Stripe size (KByte)    %u", lv->stripesize / 2);
@@ -551,7 +554,7 @@ int lvdisplay_segments(const struct logical_volume *lv)
 
 	log_print("--- Segments ---");
 
-	list_iterate_items(seg, &lv->segments) {
+	dm_list_iterate_items(seg, &lv->segments) {
 		log_print("Logical extent %u to %u:",
 			  seg->le, seg->le + seg->len - 1);
 
@@ -572,16 +575,11 @@ void vgdisplay_extents(const struct volume_group *vg __attribute((unused)))
 
 void vgdisplay_full(const struct volume_group *vg)
 {
-	uint32_t access;
+	uint32_t access_str;
 	uint32_t active_pvs;
-	uint32_t lv_count = 0;
-	struct lv_list *lvl;
 	char uuid[64] __attribute((aligned(8)));
 
-	if (vg->status & PARTIAL_VG)
-		active_pvs = list_size(&vg->pvs);
-	else
-		active_pvs = vg->pv_count;
+	active_pvs = vg->pv_count - vg_missing_pv_count(vg);
 
 	log_print("--- Volume group ---");
 	log_print("VG Name               %s", vg->name);
@@ -589,15 +587,15 @@ void vgdisplay_full(const struct volume_group *vg)
 	log_print("Format                %s", vg->fid->fmt->name);
 	if (vg->fid->fmt->features & FMT_MDAS) {
 		log_print("Metadata Areas        %d",
-			  list_size(&vg->fid->metadata_areas));
+			  dm_list_size(&vg->fid->metadata_areas));
 		log_print("Metadata Sequence No  %d", vg->seqno);
 	}
-	access = vg->status & (LVM_READ | LVM_WRITE);
+	access_str = vg->status & (LVM_READ | LVM_WRITE);
 	log_print("VG Access             %s%s%s%s",
-		  access == (LVM_READ | LVM_WRITE) ? "read/write" : "",
-		  access == LVM_READ ? "read" : "",
-		  access == LVM_WRITE ? "write" : "",
-		  access == 0 ? "error" : "");
+		  access_str == (LVM_READ | LVM_WRITE) ? "read/write" : "",
+		  access_str == LVM_READ ? "read" : "",
+		  access_str == LVM_WRITE ? "write" : "",
+		  access_str == 0 ? "error" : "");
 	log_print("VG Status             %s%sresizable",
 		  vg->status & EXPORTED_VG ? "exported/" : "",
 		  vg->status & RESIZEABLE_VG ? "" : "NOT ");
@@ -610,12 +608,8 @@ void vgdisplay_full(const struct volume_group *vg)
 			  vg->status & SHARED ? "yes" : "no");
 	}
 
-	list_iterate_items(lvl, &vg->lvs)
-		if (lv_is_visible(lvl->lv) && !(lvl->lv->status & SNAPSHOT))
-			lv_count++;
-
 	log_print("MAX LV                %u", vg->max_lv);
-	log_print("Cur LV                %u", lv_count);
+	log_print("Cur LV                %u", vg_visible_lvs(vg));
 	log_print("Open LV               %u", lvs_in_vg_opened(vg));
 /****** FIXME Max LV Size
       log_print ( "MAX LV Size           %s",
@@ -659,32 +653,23 @@ void vgdisplay_full(const struct volume_group *vg)
 void vgdisplay_colons(const struct volume_group *vg)
 {
 	uint32_t active_pvs;
-	uint32_t lv_count;
-	struct lv_list *lvl;
-	const char *access;
+	const char *access_str;
 	char uuid[64] __attribute((aligned(8)));
 
-	if (vg->status & PARTIAL_VG)
-		active_pvs = list_size(&vg->pvs);
-	else
-		active_pvs = vg->pv_count;
-
-	list_iterate_items(lvl, &vg->lvs)
-		if (lv_is_visible(lvl->lv) && !(lvl->lv->status & SNAPSHOT))
-			lv_count++;
+	active_pvs = vg->pv_count - vg_missing_pv_count(vg);
 
 	switch (vg->status & (LVM_READ | LVM_WRITE)) {
 		case LVM_READ | LVM_WRITE:
-			access = "r/w";
+			access_str = "r/w";
 			break;
 		case LVM_READ:
-			access = "r";
+			access_str = "r";
 			break;
 		case LVM_WRITE:
-			access = "w";
+			access_str = "w";
 			break;
 		default:
-			access = "";
+			access_str = "";
 	}
 
 	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {
@@ -695,11 +680,11 @@ void vgdisplay_colons(const struct volume_group *vg)
 	log_print("%s:%s:%d:-1:%u:%u:%u:-1:%u:%u:%u:%" PRIu64 ":%" PRIu32
 		  ":%u:%u:%u:%s",
 		vg->name,
-		access,
+		access_str,
 		vg->status,
 		/* internal volume group number; obsolete */
 		vg->max_lv,
-		vg->lv_count,
+		vg_visible_lvs(vg),
 		lvs_in_vg_opened(vg),
 		/* FIXME: maximum logical volume size */
 		vg->max_pv,
@@ -732,7 +717,7 @@ void display_formats(const struct cmd_context *cmd)
 {
 	const struct format_type *fmt;
 
-	list_iterate_items(fmt, &cmd->formats) {
+	dm_list_iterate_items(fmt, &cmd->formats) {
 		log_print("%s", fmt->name);
 	}
 }
@@ -741,7 +726,7 @@ void display_segtypes(const struct cmd_context *cmd)
 {
 	const struct segment_type *segtype;
 
-	list_iterate_items(segtype, &cmd->segtypes) {
+	dm_list_iterate_items(segtype, &cmd->segtypes) {
 		log_print("%s", segtype->name);
 	}
 }

lib/error/errseg.c

@@ -51,7 +51,8 @@ static int _errseg_add_target_line(struct dev_manager *dm __attribute((unused)),
 	return dm_tree_node_add_error_target(node, len);
 }
 
-static int _errseg_target_present(const struct lv_segment *seg __attribute((unused)),
+static int _errseg_target_present(struct cmd_context *cmd,
+				  const struct lv_segment *seg __attribute((unused)),
 				  unsigned *attributes __attribute((unused)))
 {
 	static int _errseg_checked = 0;
@@ -59,7 +60,8 @@ static int _errseg_target_present(const struct lv_segment *seg __attribute((unus
 
 	/* Reported truncated in older kernels */
 	if (!_errseg_checked &&
-	    (target_present("error", 0) || target_present("erro", 0)))
+	    (target_present(cmd, "error", 0) ||
+	     target_present(cmd, "erro", 0)))
 		_errseg_present = 1;
 
 	_errseg_checked = 1;
@@ -69,7 +71,7 @@ static int _errseg_target_present(const struct lv_segment *seg __attribute((unus
 
 static int _errseg_modules_needed(struct dm_pool *mem,
 				  const struct lv_segment *seg __attribute((unused)),
-				  struct list *modules)
+				  struct dm_list *modules)
 {
 	if (!str_list_add(mem, modules, "error")) {
 		log_error("error module string list allocation failed");

lib/filters/filter-persistent.c

@@ -177,7 +177,7 @@ static void _write_array(struct pfilter *pf, FILE *fp, const char *path,
 
 int persistent_filter_dump(struct dev_filter *f)
 {
-	struct pfilter *pf = (struct pfilter *) f->private;
+	struct pfilter *pf;
 	char *tmp_file;
 	struct stat info, info2;
 	struct config_tree *cft = NULL;
@@ -185,6 +185,10 @@ int persistent_filter_dump(struct dev_filter *f)
 	int lockfd;
 	int r = 0;
 
+	if (!f)
+		return_0;
+	pf = (struct pfilter *) f->private;
+
 	if (!dm_hash_get_num_entries(pf->devices)) {
 		log_very_verbose("Internal persistent device cache empty "
 				 "- not writing to %s", pf->file);
@@ -273,7 +277,7 @@ static int _lookup_p(struct dev_filter *f, struct device *dev)
 		l = pf->real->passes_filter(pf->real, dev) ?
 		    PF_GOOD_DEVICE : PF_BAD_DEVICE;
 
-		list_iterate_items(sl, &dev->aliases)
+		dm_list_iterate_items(sl, &dev->aliases)
 			dm_hash_insert(pf->devices, sl->str, l);
 
 	} else if (l == PF_BAD_DEVICE)

lib/filters/filter-regex.c

@@ -151,7 +151,7 @@ static int _accept_p(struct dev_filter *f, struct device *dev)
 	struct rfilter *rf = (struct rfilter *) f->private;
 	struct str_list *sl;
 
-	list_iterate_items(sl, &dev->aliases) {
+	dm_list_iterate_items(sl, &dev->aliases) {
 		m = dm_regex_match(rf->engine, sl->str);
 
 		if (m >= 0) {

lib/filters/filter-sysfs.c

@@ -20,47 +20,11 @@
 
 #include <dirent.h>
 
-static int _locate_sysfs_blocks(const char *proc, char *path, size_t len,
+static int _locate_sysfs_blocks(const char *sysfs_dir, char *path, size_t len,
 				unsigned *sysfs_depth)
 {
-	char proc_mounts[PATH_MAX];
-	FILE *fp;
-	char *split[4], buffer[PATH_MAX + 16];
-	const char *sys_mnt = NULL;
 	struct stat info;
 
-	if (!*proc) {
-		log_verbose("No proc filesystem found: skipping sysfs filter");
-		return 0;
-	}
-		
-	if (dm_snprintf(proc_mounts, sizeof(proc_mounts),
-			 "%s/mounts", proc) < 0) {
-		log_error("Failed to create /proc/mounts string");
-		return 0;
-	}
-
-	if (!(fp = fopen(proc_mounts, "r"))) {
-		log_sys_error("fopen %s", proc_mounts);
-		return 0;
-	}
-
-	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 0;
-	}
-
 	/*
 	 * unified classification directory for all kernel subsystems
 	 *
@@ -70,7 +34,7 @@ static int _locate_sysfs_blocks(const char *proc, char *path, size_t len,
 	 *  `-- sr0 -> ../../../devices/pci0000:00/0000:00:1f.2/host1/target1:0:0/1:0:0:0/block/sr0
 	 *
 	 */
-	if (dm_snprintf(path, len, "%s/%s", sys_mnt,
+	if (dm_snprintf(path, len, "%s/%s", sysfs_dir,
 			"subsystem/block/devices") >= 0) {
 		if (!stat(path, &info)) {
 			*sysfs_depth = 0;
@@ -87,7 +51,7 @@ static int _locate_sysfs_blocks(const char *proc, char *path, size_t len,
 	 *  `-- sr0 -> ../../devices/pci0000:00/0000:00:1f.2/host1/target1:0:0/1:0:0:0/block/sr0
 	 *
 	 */
-	if (dm_snprintf(path, len, "%s/%s", sys_mnt, "class/block") >= 0) {
+	if (dm_snprintf(path, len, "%s/%s", sysfs_dir, "class/block") >= 0) {
 		if (!stat(path, &info)) {
 			*sysfs_depth = 0;
 			return 1;
@@ -112,7 +76,7 @@ static int _locate_sysfs_blocks(const char *proc, char *path, size_t len,
 	 * ...
 	 *
 	 */
-	if (dm_snprintf(path, len, "%s/%s", sys_mnt, "block") >= 0) {
+	if (dm_snprintf(path, len, "%s/%s", sysfs_dir, "block") >= 0) {
 		if (!stat(path, &info)) {
 			*sysfs_depth = 1;
 			return 1;
@@ -321,7 +285,7 @@ static void _destroy(struct dev_filter *f)
 	dm_pool_destroy(ds->mem);
 }
 
-struct dev_filter *sysfs_filter_create(const char *proc)
+struct dev_filter *sysfs_filter_create(const char *sysfs_dir)
 {
 	char sys_block[PATH_MAX];
 	unsigned sysfs_depth;
@@ -329,7 +293,12 @@ struct dev_filter *sysfs_filter_create(const char *proc)
 	struct dev_set *ds;
 	struct dev_filter *f;
 
-	if (!_locate_sysfs_blocks(proc, sys_block, sizeof(sys_block), &sysfs_depth))
+	if (!*sysfs_dir) {
+		log_verbose("No proc filesystem found: skipping sysfs filter");
+		return NULL;
+	}
+
+	if (!_locate_sysfs_blocks(sysfs_dir, sys_block, sizeof(sys_block), &sysfs_depth))
 		return NULL;
 
 	if (!(mem = dm_pool_create("sysfs", 256))) {
@@ -357,7 +326,7 @@ struct dev_filter *sysfs_filter_create(const char *proc)
 
 #else
 
-struct dev_filter *sysfs_filter_create(const char *proc __attribute((unused)))
+struct dev_filter *sysfs_filter_create(const char *sysfs_dir __attribute((unused)))
 {
 	return NULL;
 }

lib/filters/filter-sysfs.h

@@ -18,6 +18,6 @@
 #include "config.h"
 #include "dev-cache.h"
 
-struct dev_filter *sysfs_filter_create(const char *proc);
+struct dev_filter *sysfs_filter_create(const char *sysfs_dir);
 
 #endif

lib/filters/filter.c

@@ -57,6 +57,7 @@ static const device_info_t device_info[] = {
 	{"ide", 64},		/* IDE disk */
 	{"sd", 16},		/* SCSI disk */
 	{"md", 1},		/* Multiple Disk driver (SoftRAID) */
+	{"mdp", 1},		/* Partitionable MD */
 	{"loop", 1},		/* Loop device */
 	{"dasd", 4},		/* DASD disk (IBM S/390, zSeries) */
 	{"dac960", 8},		/* DAC960 */
@@ -78,6 +79,8 @@ static const device_info_t device_info[] = {
 	{"vdisk", 8},		/* SUN's LDOM virtual block device */
 	{"ps3disk", 16},	/* PlayStation 3 internal disk */
 	{"virtblk", 8},		/* VirtIO disk */
+	{"mmc", 16},		/* MMC block device */
+	{"blkext", 1},		/* Extended device partitions */
 	{NULL, 0}
 };
 

lib/format1/Makefile.in

@@ -26,6 +26,7 @@ SOURCES =\
 	vg_number.c
 
 LIB_SHARED = liblvm2format1.so
+LIB_VERSION = $(LIB_VERSION_LVM)
 
 include $(top_srcdir)/make.tmpl
 

lib/format1/disk-rep.c

@@ -261,7 +261,7 @@ static int _read_uuids(struct disk_list *data)
 		memcpy(ul->uuid, buffer, NAME_LEN);
 		ul->uuid[NAME_LEN - 1] = '\0';
 
-		list_add(&data->uuids, &ul->list);
+		dm_list_add(&data->uuids, &ul->list);
 
 		pos += NAME_LEN;
 		num_read++;
@@ -277,12 +277,12 @@ static int _check_lvd(struct lv_disk *lvd)
 
 static int _read_lvs(struct disk_list *data)
 {
-	unsigned int i, read = 0;
+	unsigned int i, lvs_read = 0;
 	uint64_t pos;
 	struct lvd_list *ll;
 	struct vg_disk *vgd = &data->vgd;
 
-	for (i = 0; (i < vgd->lv_max) && (read < vgd->lv_cur); i++) {
+	for (i = 0; (i < vgd->lv_max) && (lvs_read < vgd->lv_cur); i++) {
 		pos = data->pvd.lv_on_disk.base + (i * sizeof(struct lv_disk));
 		ll = dm_pool_alloc(data->mem, sizeof(*ll));
 
@@ -295,8 +295,8 @@ static int _read_lvs(struct disk_list *data)
 		if (!_check_lvd(&ll->lvd))
 			continue;
 
-		read++;
-		list_add(&data->lvds, &ll->list);
+		lvs_read++;
+		dm_list_add(&data->lvds, &ll->list);
 	}
 
 	return 1;
@@ -336,7 +336,7 @@ static void __update_lvmcache(const struct format_type *fmt,
 	}
 
 	info->device_size = xlate32(dl->pvd.pv_size) << SECTOR_SHIFT;
-	list_init(&info->mdas);
+	dm_list_init(&info->mdas);
 	info->status &= ~CACHE_INVALID;
 }
 
@@ -352,11 +352,11 @@ static struct disk_list *__read_disk(const struct format_type *fmt,
 
 	dl->dev = dev;
 	dl->mem = mem;
-	list_init(&dl->uuids);
-	list_init(&dl->lvds);
+	dm_list_init(&dl->uuids);
+	dm_list_init(&dl->lvds);
 
 	if (!_read_pvd(dev, &dl->pvd))
-		goto bad;
+		goto_bad;
 
 	/*
 	 * is it an orphan ?
@@ -426,12 +426,12 @@ struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
 	return dl;
 }
 
-static void _add_pv_to_list(struct list *head, struct disk_list *data)
+static void _add_pv_to_list(struct dm_list *head, struct disk_list *data)
 {
 	struct pv_disk *pvd;
 	struct disk_list *diskl;
 
-	list_iterate_items(diskl, head) {
+	dm_list_iterate_items(diskl, head) {
 		pvd = &diskl->pvd;
 		if (!strncmp((char *)data->pvd.pv_uuid, (char *)pvd->pv_uuid,
 			     sizeof(pvd->pv_uuid))) {
@@ -443,11 +443,11 @@ static void _add_pv_to_list(struct list *head, struct disk_list *data)
 			}
 			log_very_verbose("Duplicate PV %s - using md %s",
 					 pvd->pv_uuid, dev_name(data->dev));
-			list_del(&diskl->list);
+			dm_list_del(&diskl->list);
 			break;
 		}
 	}
-	list_add(head, &data->list);
+	dm_list_add(head, &data->list);
 }
 
 /*
@@ -457,7 +457,7 @@ static void _add_pv_to_list(struct list *head, struct disk_list *data)
  */
 int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		   struct dev_filter *filter, struct dm_pool *mem,
-		   struct list *head)
+		   struct dm_list *head)
 {
 	struct dev_iter *iter;
 	struct device *dev;
@@ -468,7 +468,7 @@ int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 	/* Fast path if we already saw this VG and cached the list of PVs */
 	if (vg_name && (vginfo = vginfo_from_vgname(vg_name, NULL)) &&
 	    vginfo->infos.n) {
-		list_iterate_items(info, &vginfo->infos) {
+		dm_list_iterate_items(info, &vginfo->infos) {
 			dev = info->dev;
 			if (dev && !(data = read_disk(fmt, dev, mem, vg_name)))
 				break;
@@ -478,11 +478,11 @@ int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		/* Did we find the whole VG? */
 		if (!vg_name || is_orphan_vg(vg_name) ||
 		    (data && *data->pvd.vg_name &&
-		     list_size(head) == data->vgd.pv_cur))
+		     dm_list_size(head) == data->vgd.pv_cur))
 			return 1;
 
 		/* Failed */
-		list_init(head);
+		dm_list_init(head);
 		/* vgcache_del(vg_name); */
 	}
 
@@ -499,7 +499,7 @@ int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 	}
 	dev_iter_destroy(iter);
 
-	if (list_empty(head))
+	if (dm_list_empty(head))
 		return 0;
 
 	return 1;
@@ -528,7 +528,7 @@ static int _write_uuids(struct disk_list *data)
 	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;
 	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;
 
-	list_iterate_items(ul, &data->uuids) {
+	dm_list_iterate_items(ul, &data->uuids) {
 		if (pos >= end) {
 			log_error("Too many uuids to fit on %s",
 				  dev_name(data->dev));
@@ -576,7 +576,7 @@ static int _write_lvs(struct disk_list *data)
 		return 0;
 	}
 
-	list_iterate_items(ll, &data->lvds) {
+	dm_list_iterate_items(ll, &data->lvds) {
 		offset = sizeof(struct lv_disk) * ll->lvd.lv_number;
 		if (offset + sizeof(struct lv_disk) > data->pvd.lv_on_disk.size) {
 			log_error("lv_number %d too large", ll->lvd.lv_number);
@@ -719,11 +719,11 @@ static int _write_all_pvd(const struct format_type *fmt, struct disk_list *data)
  * little sanity checking, so make sure correct
  * data is passed to here.
  */
-int write_disks(const struct format_type *fmt, struct list *pvs)
+int write_disks(const struct format_type *fmt, struct dm_list *pvs)
 {
 	struct disk_list *dl;
 
-	list_iterate_items(dl, pvs) {
+	dm_list_iterate_items(dl, pvs) {
 		if (!(_write_all_pvd(fmt, dl)))
 			return_0;
 

lib/format1/disk-rep.h

@@ -147,24 +147,24 @@ struct pe_disk {
 } __attribute__ ((packed));
 
 struct uuid_list {
-	struct list list;
+	struct dm_list list;
 	char uuid[NAME_LEN] __attribute((aligned(8)));
 };
 
 struct lvd_list {
-	struct list list;
+	struct dm_list list;
 	struct lv_disk lvd;
 };
 
 struct disk_list {
-	struct list list;
+	struct dm_list list;
 	struct dm_pool *mem;
 	struct device *dev;
 
 	struct pv_disk pvd __attribute((aligned(8)));
 	struct vg_disk vgd __attribute((aligned(8)));
-	struct list uuids __attribute((aligned(8)));
-	struct list lvds __attribute((aligned(8)));
+	struct dm_list uuids __attribute((aligned(8)));
+	struct dm_list lvds __attribute((aligned(8)));
 	struct pe_disk *extents __attribute((aligned(8)));
 };
 
@@ -195,9 +195,9 @@ struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
 
 int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		   struct dev_filter *filter,
-		   struct dm_pool *mem, struct list *results);
+		   struct dm_pool *mem, struct dm_list *results);
 
-int write_disks(const struct format_type *fmt, struct list *pvds);
+int write_disks(const struct format_type *fmt, struct dm_list *pvds);
 
 /*
  * Functions to translate to between disk and in
@@ -212,39 +212,40 @@ int export_pv(struct cmd_context *cmd, struct dm_pool *mem,
 	      struct pv_disk *pvd, struct physical_volume *pv);
 
 int import_vg(struct dm_pool *mem,
-	      struct volume_group *vg, struct disk_list *dl, int partial);
+	      struct volume_group *vg, struct disk_list *dl);
 int export_vg(struct vg_disk *vgd, struct volume_group *vg);
 
-int import_lv(struct dm_pool *mem, struct logical_volume *lv, struct lv_disk *lvd);
+int import_lv(struct cmd_context *cmd, struct dm_pool *mem,
+	      struct logical_volume *lv, struct lv_disk *lvd);
 
 int import_extents(struct cmd_context *cmd, struct volume_group *vg,
-		   struct list *pvds);
+		   struct dm_list *pvds);
 int export_extents(struct disk_list *dl, uint32_t lv_num,
 		   struct logical_volume *lv, struct physical_volume *pv);
 
 int import_pvs(const struct format_type *fmt, struct dm_pool *mem,
 	       struct volume_group *vg,
-	       struct list *pvds, struct list *results, uint32_t *count);
+	       struct dm_list *pvds, struct dm_list *results, uint32_t *count);
 
-int import_lvs(struct dm_pool *mem, struct volume_group *vg, struct list *pvds);
+int import_lvs(struct dm_pool *mem, struct volume_group *vg, struct dm_list *pvds);
 int export_lvs(struct disk_list *dl, struct volume_group *vg,
 	       struct physical_volume *pv, const char *dev_dir);
 
 int import_snapshots(struct dm_pool *mem, struct volume_group *vg,
-		     struct list *pvds);
+		     struct dm_list *pvds);
 
 int export_uuids(struct disk_list *dl, struct volume_group *vg);
 
-void export_numbers(struct list *pvds, struct volume_group *vg);
+void export_numbers(struct dm_list *pvds, struct volume_group *vg);
 
-void export_pv_act(struct list *pvds);
+void export_pv_act(struct dm_list *pvds);
 int munge_pvd(struct device *dev, struct pv_disk *pvd);
 int read_vgd(struct device *dev, struct vg_disk *vgd, struct pv_disk *pvd);
 
 /* blech */
 int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 		       const char *candidate_vg, int *result);
-int export_vg_number(struct format_instance *fid, struct list *pvds,
+int export_vg_number(struct format_instance *fid, struct dm_list *pvds,
 		     const char *vg_name, struct dev_filter *filter);
 
 #endif

lib/format1/format1.c

@@ -23,9 +23,9 @@
 #include "segtype.h"
 
 /* VG consistency checks */
-static int _check_vgs(struct list *pvs, int *partial)
+static int _check_vgs(struct dm_list *pvs)
 {
-	struct list *pvh, *t;
+	struct dm_list *pvh, *t;
 	struct disk_list *dl = NULL;
 	struct disk_list *first = NULL;
 
@@ -33,14 +33,12 @@ static int _check_vgs(struct list *pvs, int *partial)
 	uint32_t exported = 0;
 	int first_time = 1;
 
-	*partial = 0;
-
 	/*
 	 * If there are exported and unexported PVs, ignore exported ones.
 	 * This means an active VG won't be affected if disks are inserted
 	 * bearing an exported VG with the same name.
 	 */
-	list_iterate_items(dl, pvs) {
+	dm_list_iterate_items(dl, pvs) {
 		if (first_time) {
 			exported = dl->pvd.pv_status & VG_EXPORTED;
 			first_time = 0;
@@ -49,18 +47,18 @@ static int _check_vgs(struct list *pvs, int *partial)
 
 		if (exported != (dl->pvd.pv_status & VG_EXPORTED)) {
 			/* Remove exported PVs */
-			list_iterate_safe(pvh, t, pvs) {
-				dl = list_item(pvh, struct disk_list);
+			dm_list_iterate_safe(pvh, t, pvs) {
+				dl = dm_list_item(pvh, struct disk_list);
 				if (dl->pvd.pv_status & VG_EXPORTED)
-					list_del(pvh);
+					dm_list_del(pvh);
 			}
 			break;
 		}
 	}
 
 	/* Remove any PVs with VG structs that differ from the first */
-	list_iterate_safe(pvh, t, pvs) {
-		dl = list_item(pvh, struct disk_list);
+	dm_list_iterate_safe(pvh, t, pvs) {
+		dl = dm_list_item(pvh, struct disk_list);
 
 		if (!first)
 			first = dl;
@@ -97,11 +95,7 @@ static int _check_vgs(struct list *pvs, int *partial)
 				  dl->vgd.vgda, dl->vgd.pe_size,
 				  dl->vgd.pe_total, dl->vgd.pe_allocated,
 				  dl->vgd.pvg_total);
-			list_del(pvh);
-			if (partial_mode()) {
-				*partial = 1;
-				continue;
-			}
+			dm_list_del(pvh);
 			return 0;
 		}
 		pv_count++;
@@ -111,43 +105,40 @@ static int _check_vgs(struct list *pvs, int *partial)
 	if (pv_count != first->vgd.pv_cur) {
 		log_error("%d PV(s) found for VG %s: expected %d",
 			  pv_count, first->pvd.vg_name, first->vgd.pv_cur);
-		if (!partial_mode())
-			return 0;
-		*partial = 1;
 	}
 
 	return 1;
 }
 
 static struct volume_group *_build_vg(struct format_instance *fid,
-				      struct list *pvs)
+				      struct dm_list *pvs,
+				      struct dm_pool *mem)
 {
-	struct dm_pool *mem = fid->fmt->cmd->mem;
 	struct volume_group *vg = dm_pool_alloc(mem, sizeof(*vg));
 	struct disk_list *dl;
-	int partial;
 
 	if (!vg)
 		goto_bad;
 
-	if (list_empty(pvs))
+	if (dm_list_empty(pvs))
 		goto_bad;
 
 	memset(vg, 0, sizeof(*vg));
 
 	vg->cmd = fid->fmt->cmd;
+	vg->vgmem = mem;
 	vg->fid = fid;
 	vg->seqno = 0;
-	list_init(&vg->pvs);
-	list_init(&vg->lvs);
-	list_init(&vg->tags);
+	dm_list_init(&vg->pvs);
+	dm_list_init(&vg->lvs);
+	dm_list_init(&vg->tags);
 
-	if (!_check_vgs(pvs, &partial))
+	if (!_check_vgs(pvs))
 		goto_bad;
 
-	dl = list_item(pvs->n, struct disk_list);
+	dl = dm_list_item(pvs->n, struct disk_list);
 
-	if (!import_vg(mem, vg, dl, partial))
+	if (!import_vg(mem, vg, dl))
 		goto_bad;
 
 	if (!import_pvs(fid->fmt, mem, vg, pvs, &vg->pvs, &vg->pv_count))
@@ -173,10 +164,10 @@ static struct volume_group *_format1_vg_read(struct format_instance *fid,
 				     const char *vg_name,
 				     struct metadata_area *mda __attribute((unused)))
 {
-	struct dm_pool *mem = dm_pool_create("lvm1 vg_read", 1024 * 10);
-	struct list pvs;
+	struct dm_pool *mem = dm_pool_create("lvm1 vg_read", VG_MEMPOOL_CHUNK);
+	struct dm_list pvs;
 	struct volume_group *vg = NULL;
-	list_init(&pvs);
+	dm_list_init(&pvs);
 
 	if (!mem)
 		return_NULL;
@@ -188,12 +179,13 @@ static struct volume_group *_format1_vg_read(struct format_instance *fid,
 	    (fid->fmt, vg_name, fid->fmt->cmd->filter, mem, &pvs))
 		goto_bad;
 
-	if (!(vg = _build_vg(fid, &pvs)))
+	if (!(vg = _build_vg(fid, &pvs, mem)))
 		goto_bad;
 
-      bad:
-	dm_pool_destroy(mem);
 	return vg;
+bad:
+	dm_pool_destroy(mem);
+	return NULL;
 }
 
 static struct disk_list *_flatten_pv(struct format_instance *fid,
@@ -209,8 +201,8 @@ static struct disk_list *_flatten_pv(struct format_instance *fid,
 	dl->mem = mem;
 	dl->dev = pv->dev;
 
-	list_init(&dl->uuids);
-	list_init(&dl->lvds);
+	dm_list_init(&dl->uuids);
+	dm_list_init(&dl->lvds);
 
 	if (!export_pv(fid->fmt->cmd, mem, vg, &dl->pvd, pv) ||
 	    !export_vg(&dl->vgd, vg) ||
@@ -225,17 +217,17 @@ static struct disk_list *_flatten_pv(struct format_instance *fid,
 
 static int _flatten_vg(struct format_instance *fid, struct dm_pool *mem,
 		       struct volume_group *vg,
-		       struct list *pvds, const char *dev_dir,
+		       struct dm_list *pvds, const char *dev_dir,
 		       struct dev_filter *filter)
 {
 	struct pv_list *pvl;
 	struct disk_list *data;
 
-	list_iterate_items(pvl, &vg->pvs) {
+	dm_list_iterate_items(pvl, &vg->pvs) {
 		if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir)))
 			return_0;
 
-		list_add(pvds, &data->list);
+		dm_list_add(pvds, &data->list);
 	}
 
 	export_numbers(pvds, vg);
@@ -250,14 +242,14 @@ static int _flatten_vg(struct format_instance *fid, struct dm_pool *mem,
 static int _format1_vg_write(struct format_instance *fid, struct volume_group *vg,
 		     struct metadata_area *mda __attribute((unused)))
 {
-	struct dm_pool *mem = dm_pool_create("lvm1 vg_write", 1024 * 10);
-	struct list pvds;
+	struct dm_pool *mem = dm_pool_create("lvm1 vg_write", VG_MEMPOOL_CHUNK);
+	struct dm_list pvds;
 	int r = 0;
 
 	if (!mem)
 		return_0;
 
-	list_init(&pvds);
+	dm_list_init(&pvds);
 
 	r = (_flatten_vg(fid, mem, vg, &pvds, fid->fmt->cmd->dev_dir,
 			 fid->fmt->cmd->filter) &&
@@ -269,7 +261,8 @@ static int _format1_vg_write(struct format_instance *fid, struct volume_group *v
 }
 
 static int _format1_pv_read(const struct format_type *fmt, const char *pv_name,
-		    struct physical_volume *pv, struct list *mdas __attribute((unused)))
+		    struct physical_volume *pv, struct dm_list *mdas __attribute((unused)),
+		    int scan_label_only __attribute((unused)))
 {
 	struct dm_pool *mem = dm_pool_create("lvm1 pv_read", 1024);
 	struct disk_list *dl;
@@ -302,8 +295,9 @@ static int _format1_pv_read(const struct format_type *fmt, const char *pv_name,
 static int _format1_pv_setup(const struct format_type *fmt,
 		     uint64_t pe_start, uint32_t extent_count,
 		     uint32_t extent_size,
+		     unsigned long data_alignment __attribute((unused)),
 		     int pvmetadatacopies __attribute((unused)),
-		     uint64_t pvmetadatasize __attribute((unused)), struct list *mdas __attribute((unused)),
+		     uint64_t pvmetadatasize __attribute((unused)), struct dm_list *mdas __attribute((unused)),
 		     struct physical_volume *pv, struct volume_group *vg __attribute((unused)))
 {
 	if (pv->size > MAX_PV_SIZE)
@@ -356,11 +350,11 @@ static int _format1_lv_setup(struct format_instance *fid, struct logical_volume
 }
 
 static int _format1_pv_write(const struct format_type *fmt, struct physical_volume *pv,
-		     struct list *mdas __attribute((unused)), int64_t sector __attribute((unused)))
+		     struct dm_list *mdas __attribute((unused)), int64_t sector __attribute((unused)))
 {
 	struct dm_pool *mem;
 	struct disk_list *dl;
-	struct list pvs;
+	struct dm_list pvs;
 	struct label *label;
 	struct lvmcache_info *info;
 
@@ -371,9 +365,9 @@ static int _format1_pv_write(const struct format_type *fmt, struct physical_volu
 	info->device_size = pv->size << SECTOR_SHIFT;
 	info->fmt = fmt;
 
-	list_init(&info->mdas);
+	dm_list_init(&info->mdas);
 
-	list_init(&pvs);
+	dm_list_init(&pvs);
 
 	/* Ensure any residual PE structure is gone */
 	pv->pe_size = pv->pe_count = 0;
@@ -397,7 +391,7 @@ static int _format1_pv_write(const struct format_type *fmt, struct physical_volu
 	dl->pvd.pv_on_disk.size = PV_SIZE;
 	dl->pvd.pe_on_disk.base = LVM1_PE_ALIGN << SECTOR_SHIFT;
 
-	list_add(&pvs, &dl->list);
+	dm_list_add(&pvs, &dl->list);
 	if (!write_disks(fmt, &pvs))
 		goto_bad;
 
@@ -467,7 +461,7 @@ static struct format_instance *_format1_create_instance(const struct format_type
 		return_NULL;
 
 	fid->fmt = fmt;
-	list_init(&fid->metadata_areas);
+	dm_list_init(&fid->metadata_areas);
 
 	/* Define a NULL metadata area */
 	if (!(mda = dm_pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
@@ -477,7 +471,7 @@ static struct format_instance *_format1_create_instance(const struct format_type
 
 	mda->ops = &_metadata_format1_ops;
 	mda->metadata_locn = NULL;
-	list_add(&fid->metadata_areas, &mda->list);
+	dm_list_add(&fid->metadata_areas, &mda->list);
 
 	return fid;
 }