Drop leading zeros from dm_format_dev.

Suppress attempt to reload identical table.

VERSION

@@ -1 +1 @@
-2.00.24-cvs (2004-09-16)
+2.02.01-cvs (2005-11-10)

WHATS_NEW

@@ -1,3 +1,324 @@
+Version 2.02.01 -
+====================================
+  Fix missing vg_revert in lvcreate error path.
+
+Version 2.02.00 - 10th November 2005
+====================================
+  Extend allocation areas to avoid overflow with contiguous with other PVs.
+  Stop lvcreate attempting to wipe zero or error segments.
+  Added new lvs table attributes.
+  Separated out activation preload.
+  Moved activation functions into libdevmapper.
+  Fixed build_dm_name.
+  Add return macros.
+  Added xen xvd devices.
+  Clear up precommitted metadata better.
+  A pvresize implementation.
+  Fix contiguous allocation when there are no preceding segments.
+  Add mirror_seg pointer to lv_segment struct.
+  Only keep a device open if it's known to belong to a locked VG.
+  Fix lvdisplay to show all mirror destinations.
+  Replacement suspend code using libdevmapper dependency tree.
+  Add DEFS to make.tmpl.
+  Use dm_is_dm_major instead of local copy.
+  Allow mapped devices to be used as PVs.
+  Move set_selinux_context into libdevmapper.
+  Fix automatic text metadata buffer expansion (using macro).
+  Cache formatted text metadata buffer between metadata area writes.
+  Add pe_start field to pvs.
+  Add 'LVM-' prefix to uuids.
+  Split lv_segment_area from lv_segment to permit extension.
+  Replacement deactivation code using libdevmapper dependency tree.
+  Simplify dev_manager_info().
+  Attempt to load missing targets using modprobe.
+  Add -a to lvscan.
+  Move mknodes into libdevmapper.
+  Move bitset, hash, pool and dbg_malloc into libdevmapper.
+
+Version 2.01.15 - 16th October 2005
+===================================
+  Refuse to run pvcreate/pvremove on devices we can't open exclusively.
+  Use ORPHAN lock definition throughout.
+  Validate chunksize in lvcreate.
+  Reduce chunksize limit to 512k.
+  Fix chunksize field in reports.
+  Don't hide snapshots from default 'lvs' output.
+  Add is_dm_major() for use in duplicate device detection in lvmcache_add().
+  Really switch device number in lvmcache when it says it is doing so.
+  Option for bitset memory allocation using malloc as well as pool.
+  Don't assume exactly two mirrors when parsing mirror status.
+  Suppress fsync() error message on filesystems that don't support it.
+  Fix yes_no_prompt() error handling.
+  Add lvm.conf comment warning against multiple filter lines.
+  Tidy lvmconf.sh.
+  Add format1 dev_write debug messages.
+  Add clustered VG attribute to report.
+  Move lvconvert parameters into struct lvconvert_params.
+  Add clustered VG flag to LV lock requests.
+  Change LV locking macros to take lv instead of lvid.
+  Prepend 'cluster' activation parameter to mirror log when appropriate.
+  Pass exclusive flag to lv_activate and on to target activation code.
+  Prevent snapshot creation in a clustered VG for now.
+  Factor out adjusted_mirror_region_size() and generate_log_name_format().
+  Move compose_log_line() into mirror directory.
+  Factor out _get_library_path().
+  Don't kill idling clvmd threads.
+  clvmd no longer takes out locks for non-clustered LVs.
+  Recognise ATA over Ethernet (aoe) devices.
+
+Version 2.01.14 - 4th August 2005
+=================================
+  Fix lvconvert PV parameter in help string.
+  Prevent snapshots getting activated in a clustered VG.
+  Separate out _build_dev_string.
+  Move zero_lv to toollib.
+  Fix pool format handler to work with pv segment code.
+
+Version 2.01.13 - 13th July 2005
+================================
+  Fix pvmove segment splitting.
+  Abstract vg_validate.
+  Only make one attempt at contiguous allocation.
+  Fix lvm1 format metadata read.
+  Fix lvm1 format non-mirror lvcreate.
+
+Version 2.01.12 - 14th June 2005
+================================
+  Various allocation-related pvmove fixes.
+  Log an error if clvmd can't resolve a host name got from CCS.
+  Fix potential spin loop in clvmd.
+
+Version 2.01.11 - 13th June 2005
+================================
+  Added lvmconf.sh.
+  Use matchpathcon mode parameter.
+  Don't defer closing dead FDs in clvmd.
+  Remove hard-coded 64k text metadata writing restriction.
+  Make VG name restrictions consistent.
+  Introduce lvconvert.  So far only removes mirror images.
+  Allow mirror images to be resized.
+  Allow mirror images to have more than one segment.
+  Centralise restrictions on LV names.
+  Always insert an intermediate layer for mirrors.
+  Suppress hidden LVs from reports unless --all is given.
+  Use square brackets for hidden LVs in reports.
+  Allow the creation of mirrors with contiguous extents.
+  Always perform sanity checks against metadata before committing it to disk.
+  Split lv_extend into two steps: choosing extents + allocation to LV(s).
+  Add mirror log region size to metadata.
+  Use list_iterate_items throughout and add list*back macros.
+  Introduce seg_ macros to access areas.
+  Add segtype_is_ macros.
+  Support tiny metadata areas for pool conversions.
+  Mirror activation handles disk log as well as core.
+  Activation code recognises mirror log dependency.
+  Add mirror_log and regionsize fields to report.
+  Fix non-orphan pvchange -u.
+  Fix vgmerge to handle duplicate LVIDs.
+  Move archiver code from tools into library.
+  vgscan/change/display/vgs automatically create metadata backups if needed.
+  Merge cloned allocation functions.
+  Fix contiguous allocation policy with linear.
+  Cope with missing format1 PVs again.
+  Remove lists of free PV segments.
+  Simplify pv_maps code and remove slow bitset algorithm.
+  Red-Hat-ify the clvmd rhel4 initscript.
+  %Zu->%zu
+  Fix loopfiles alias alloc & mem debugging.
+  Un-inline dbg_strdup.
+  lv_reduce tidying.
+  Remove some unnecessary parameters.
+  Introduce seg_is macros.
+
+Version 2.01.10 - 3rd May 2005
+==============================
+  Don't create backup and archive dirs till needed.
+  Reinstate full PV size when removing from VG.
+  Support loopfiles for testing.
+  Tidy lv_segment interface.
+  pv_segment support.
+  vgchange --physicalextentsize
+  Internal snapshot restructuring.
+  Remove unused internal non-persistent snapshot option.
+  Allow offline extension of snapshot volumes.
+  Move from 2-step to 3-step on-disk metadata commit.
+  Scan ramdisks too and allow non-O_DIRECT fallback.
+  Annotate, tidy and extend list.h.
+  Alignment tidying.
+  Make clvmd work around some "bugs" in gulm's node state notifications.
+  Tidy clvmd's SIGHUP handler
+
+Version 2.01.09 - 4th April 2005
+================================
+  Add --ignorelockingfailure to vgmknodes.
+  clvmd: Don't allow user operations to start until the lvm thread is fully up.
+  clvmd-gulm: set KEEPALIVE on sockets.
+
+Version 2.01.08 - 22nd March 2005
+=================================
+  Add clustered attribute so vgchange can identify clustered VGs w/o locking.
+  Improve detection of external changes affecting internal cache.
+  Add 'already in device cache' debug message.
+  Add -a to pvdisplay -C.
+  Avoid rmdir opendir error messsages when dir was already removed.
+  Tighten signal handlers.
+  Avoid some compiler warnings.
+  Additional rename failure error message.
+  read/write may be macros.
+  clvmd: don't take out lvm thread lock at startup, it only protects jobs list.
+
+Version 2.01.07 - 8th March 2005
+================================
+  Cope with new devices appearing by rescanning /dev if a uuid can't be found.
+  Remove DESTDIR from LVM_SHARED_PATH.
+  clvmd fixes: make FDs close-on-exec
+               gulm unlocks VG & orphan locks at startup in case they are stale
+               gulm now unlocks VG & orphan locks if client dies.
+
+Version 2.01.06 - 1st March 2005
+================================
+  Suppress 'open failed' error messages during scanning.
+  Option to suppress warnings of file descriptors left open.
+  Fix default value of metadatacopies in documentation (2->1).
+  Fix clvmd-gulm locking.
+  ./configure --enable-debug now enables debugging code in clvmd.
+  Fix clvmd-gulm node up/down code so it actually works.
+  clvmd-gulm now releases locks when shut down.
+
+Version 2.01.05 - 18th February 2005
+====================================
+  Static binary invokes dynamic binary if appropriate.
+  Make clvmd config check a little more tolerant.
+  gulm clvmd can now cope with >1 message arriving in a TCP message.
+
+Version 2.01.04 - 9th February 2005
+===================================
+  Add fixed offset to imported pool minor numbers.
+  Update binary pathnames in clvmd_init_rhel4.
+  lvm2cmd.so should skip the check for open fds.
+  Remove unused -f from pvmove.
+  Gulm clvmd doesn't report "connection refused" errors.
+  clvmd does a basic config file sanity check at startup.
+  Fix potential thread shutdown race in clvmd.
+
+Version 2.01.03 - 1st February 2005
+===================================
+  More 64-bit display/report fixes.
+  More informative startup mesg if can't create /etc/lvm.
+  Fix snapshot device size bug (since 2.01.01).
+  clvmd announces startup and cluster connection in syslog.
+  Gulm clvmd doesn't hang trying to talk to a rebooted node.
+  Gulm clvmd doesn't print cman error on startup.
+
+Version 2.01.02 - 21st January 2005
+===================================
+  Update clvmd_init_rhel4: use lvm.static and don't load dlm.
+  Fix some size_t printing.
+  Fix 64 bit xlate consts.
+  Split out pool sptype_names to avoid unused const.
+  Always fail if random id generation fails.
+  Recognise gnbd devices.
+  Fix clvmd startup bug introduced in cman/gulm amalgamation.
+  Improve reporting of node-specific locking errors.
+
+Version 2.01.01 - 19th January 2005
+===================================
+  Fix clvmd lv_info_by_lvid open_count.
+  Store snapshot and origin sizes separately.
+  Update vgcreate man page.
+
+Version 2.01.00 - 17th January 2005
+===================================
+  Fix vgscan metadata auto-correction.
+  Only ask libdevmapper for open_count when we need it.
+  Adjust RHEL4 clvmd init script priority.
+  Enable building of CMAN & GULM versions of clvmd into a single binary
+
+Version 2.00.33 - 7th January 2005
+==================================
+  pvcreate wipes first 4 sectors unless given --zero n.
+  gulm clvmd now uses new ccsd key names.
+  gulm clvmd now doesn't ignore the first node in cluster.conf
+  Improve clvmd failure message if it's already running.
+  Allow user to kill clvmd during initialisation.
+  Fix off-by-one error in cluster_locking that could cause read hangs.
+
+Version 2.00.32 - 22nd December 2004
+====================================
+  Drop static/dl restriction for now.
+  Fix an error fprintf.
+  Fix vgdisplay -s. Breaks (undocumented) lvs/pvs/vgs -s instead for now.
+  Fix device reference counting on re-opens.
+  Ignore sysfs symlinks when DT_UNKNOWN.
+  Add clvmd init script for RHEL4.
+  Skip devices that are too small to be PVs.
+  Fix pvchange -x segfault with lvm2-format orphan.
+  Cope with empty msdos partition tables.
+  Add CONTRIBUTORS file.
+
+Version 2.00.31 - 12th December 2004
+====================================
+  Reopen RO file descriptors RW if necessary.
+
+Version 2.00.30 - 10th December 2004
+====================================
+  Additional device-handling debug messages.
+  Additional verbosity level -vvvv includes line numbers and backtraces.
+  Verbose messages now go to stderr not stdout.
+  Close any stray file descriptors before starting.
+  Refine partitionable checks for certain device types.
+  Allow devices/types to override built-ins.
+  Fix lvreduce man page .i->.I
+  Fix vgsplit man page title.
+  Fix clvmd man makefile.
+  Extend dev_open logging.
+  Make clvmd_fix_conf.sh UNDOable.
+
+Version 2.00.29 - 27th November 2004
+====================================
+  xlate compilation fix.
+
+Version 2.00.28 - 27th November 2004
+====================================
+  Fix partition table & md signature detection.
+  Minor configure/makefile tidy.
+  Export version.h from tools for clvmd.
+
+Version 2.00.27 - 24th November 2004
+====================================
+  Trap large memory allocation requests.
+  Fix to partition table detection code.
+  Improve filter debug mesgs.
+  Make clvmd_fix_conf.sh UNDOable
+
+Version 2.00.26 - 23rd November 2004
+====================================
+  Improve pool debugging stats.
+  Detect partition table signature.
+  pvcreate wipes md superblocks. (With --uuid or --restorefile it prompts.)
+  Separate out md superblock detection code.
+  Prevent snapshot origin resizing.
+  Improve a vgremove error message.
+  Update some man pages.
+  Allow y/n with -ae args (exclusive activation).
+  Fixes to lvcreate vgname parsing.
+  Fix dm_name string size calculation.
+  Improve clvmd error reporting during startup.
+  Make clvmd cope with large gaps in node numbers IDs.
+  Make clvmd initialisation cope better with debugging output.
+  Tidy clvmd socket callbacks so all work happens outside main loop.
+  clvmd -V now displays lvm version too.
+  Add optional gulm build for clvmd
+
+Version 2.00.25 - 29th September 2004
+=====================================
+  Fix return code from rm_link for vgmknodes.
+  Make clvmd LV hash table thread-safe.
+  Fix clvmd locking so it will lock out multiple users on the same node.
+  Fix clvmd VG locking to it can cope with multiple VG locks.
+  Remove spurious trailing dot in lvreduce man page.
+  Fix vgremove locking.
+
 Version 2.00.24 - 16th September 2004
 =====================================
   Fix pool_empty so it really does empty the memory pool.

WHATS_NEW_DM

@@ -1,5 +1,69 @@
-Version 1.00.20 -
+Version 1.02.01 - 
 =============================
+  Drop leading zeros from dm_format_dev.
+  Suppress attempt to reload identical table.
+  Additional LVM- prefix matching for transitional period.
+
+Version 1.02.00 - 10 Nov 2005
+=============================
+  Added activation functions to library.
+  Added return macros.
+  Also suppress error if device doesn't exist with DM_DEVICE_STATUS.
+  Export dm_set_selinux_context().
+  Add dm_driver_version().
+  Added dependency tree functions to library.
+  Added hash, bitset, pool, dbg_malloc to library.
+  Added ls --tree to dmsetup.
+  Added dmsetup --nolockfs support for suspend/reload.
+
+Version 1.01.05 - 26 Sep 2005
+=============================
+  Resync list.h with LVM2.
+  Remember increased buffer size and use for subsequent calls.
+  On 'buffer full' condition, double buffer size and repeat ioctl.
+  Fix termination of getopt_long() option array.
+  Report 'buffer full' condition with v4 ioctl as well as with v1.
+
+Version 1.01.04 - 2 Aug 2005
+============================
+  Fix dmsetup ls -j and status --target with empty table.
+
+Version 1.01.03 - 13 Jun 2005
+=============================
+  Use matchpathcon mode parameter.
+  Fix configure script to re-enable selinux.
+
+Version 1.01.02 - 17 May 2005
+=============================
+  Call dm_lib_exit() and dm_lib_release() automatically now.
+  Add --target <target_type> filter to dmsetup table/status/ls.
+  Add --exec <command> to dmsetup ls.
+  Fix dmsetup getopt_long usage.
+
+Version 1.01.01 - 29 Mar 2005
+=============================
+  Update dmsetup man page.
+  Drop-in devmap_name replacement.
+  Add option to compile without ioctl for testing.
+  Fix DM_LIB_VERSION sed.
+
+Version 1.01.00 - 17 Jan 2005
+=============================
+  Add dm_task_no_open_count() to skip getting open_count.
+
+Version 1.00.21 - 7 Jan 2005
+============================
+  Fix /proc/devices parsing.
+
+Version 1.00.20 - 6 Jan 2005
+============================
+  Attempt to fix /dev/mapper/control transparently if it's wrong.
+  Configuration-time option for setting uid/gid/mode for /dev/mapper nodes.
+  Update kernel patches for 2.4.27/2.4.28-pre-4 (includes minor fixes).
+  Add --noheadings columns option for colon-separated dmsetup output.
+  Support device referencing by uuid or major/minor.
+  Warn if kernel data didn't fit in buffer.
+  Fix a printf.
 
 Version 1.00.19 - 3 July 2004
 =============================

configure.in

@@ -50,7 +50,7 @@ case "$host_os" in
 		LDDEPS="$LDDEPS"
 		LDFLAGS="$LDFLAGS"
 		SOFLAG="-dynamiclib"
-		DEVMAPPER=no
+		DEVMAPPER=yes
 		ODIRECT=no
 		SELINUX=no
 		CLUSTER=none
@@ -280,12 +280,18 @@ AC_MSG_RESULT($SELINUX)
 ################################################################################
 dnl -- Build cluster LVM daemon
 AC_MSG_CHECKING(whether to build cluster LVM daemon)
-AC_ARG_WITH(clvmd, [  --with-clvmd            Build cluster LVM Daemon],
-CLVMD=$withval, CLVMD=no)
+AC_ARG_WITH(clvmd,
+  [  --with-clvmd=TYPE       Build cluster LVM Daemon: cman/gulm/none/all
+                          [TYPE=none] ],
+  [ CLVMD="$withval" ],
+  [ CLVMD="none" ])
+if test x$CLVMD = xyes; then
+	CLVMD=all
+fi
 AC_MSG_RESULT($CLVMD)
 
 dnl -- If clvmd enabled without cluster locking, automagically include it
-if  test x$CLVMD = xyes && test x$CLUSTER = xnone; then
+if  test x$CLVMD != xnone && test x$CLUSTER = xnone; then
 	CLUSTER=internal
 fi
 
@@ -383,7 +389,7 @@ fi
 dnl -- Check for dlopen
 AC_CHECK_LIB(dl, dlopen, HAVE_LIBDL=yes, HAVE_LIBDL=no)
 
-if [[ "x$HAVE_LIBDL" = xyes -a "x$STATIC_LINK" = xno ]]; then
+if [[ "x$HAVE_LIBDL" = xyes ]]; then
 	CFLAGS="$CFLAGS -DHAVE_LIBDL"
 	LIBS="-ldl $LIBS"
 else
@@ -475,7 +481,7 @@ if test x$READLINE = xyes; then
 	AC_CHECK_HEADERS(readline/readline.h readline/history.h,,AC_MSG_ERROR(bailing out))
 fi
 
-if test x$CLVMD = xyes; then
+if test x$CLVMD != xnone; then
 	AC_CHECK_HEADERS(mntent.h netdb.h netinet/in.h pthread.h search.h sys/mount.h sys/socket.h sys/uio.h sys/un.h utmpx.h,,AC_MSG_ERROR(bailing out))
 	AC_CHECK_FUNCS(dup2 getmntent memmove select socket,,AC_MSG_ERROR(bailing out))
 	AC_FUNC_GETMNTENT
@@ -509,6 +515,13 @@ if test x$HAVE_SELINUX = xyes; then
 	AC_CHECK_HEADERS(selinux/selinux.h,,AC_MSG_ERROR(bailing out))
 fi
 
+################################################################################
+AC_PATH_PROG(MODPROBE_CMD, modprobe)
+
+if test x$MODPROBE_CMD != x; then
+	CFLAGS="$CFLAGS -DMODPROBE_CMD=\\\"$MODPROBE_CMD\\\""
+fi
+
 ################################################################################
 if test "-f VERSION"; then
   LVM_VERSION="\"`cat VERSION`\""

daemons/Makefile.in

@@ -15,7 +15,7 @@ srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 
-ifeq ("@CLVMD@", "yes")
+ifneq ("@CLVMD@", "none")
   SUBDIRS = clvmd
 endif
 

daemons/clvmd/Makefile.in

@@ -16,26 +16,53 @@ top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 
 SOURCES = \
-	clvmd-cman.c     \
 	clvmd-command.c  \
 	clvmd.c          \
-	libclvm.c        \
 	lvm-functions.c  \
 	system-lv.c
 
+ifeq ("@CLVMD@", "gulm")
+	GULM = yes
+endif
+
+ifeq ("@CLVMD@", "cman")
+	CMAN = yes
+endif
+
+ifeq ("@CLVMD@", "all")
+	GULM = yes
+	CMAN = yes
+endif
+
+ifeq ("@DEBUG@", "yes")
+	CFLAGS += -DDEBUG
+endif
+
+ifeq ("$(GULM)", "yes")
+	SOURCES += clvmd-gulm.c tcp-comms.c
+	LMLIBS += -lccs -lgulm
+	CFLAGS += -DUSE_GULM
+endif
+
+ifeq ("$(CMAN)", "yes")
+	SOURCES += clvmd-cman.c
+	LMLIBS += -ldlm
+	CFLAGS += -DUSE_CMAN
+endif
+
 TARGETS = \
 	clvmd
 
 include $(top_srcdir)/make.tmpl
 
 CFLAGS += -D_REENTRANT -fno-strict-aliasing
-LIBS += -ldevmapper -ldlm -llvm -lpthread
+LIBS += -ldevmapper -llvm -lpthread
 
 INSTALL_TARGETS = \
 	install_clvmd
 
 clvmd: $(OBJECTS) $(top_srcdir)/lib/liblvm.a
-	$(CC) -o clvmd $(OBJECTS) $(LDFLAGS) $(LVMLIBS) $(LIBS)
+	$(CC) -o clvmd $(OBJECTS) $(LDFLAGS) $(LVMLIBS) $(LMLIBS) $(LIBS)
 
 .PHONY: install_clvmd
 

daemons/clvmd/clvm.h

@@ -43,6 +43,7 @@ struct clvm_header {
 /* Flags */
 #define CLVMD_FLAG_LOCAL        1	/* Only do this on the local node */
 #define CLVMD_FLAG_SYSTEMLV     2	/* Data in system LV under my node name */
+#define CLVMD_FLAG_NODEERRS     4       /* Reply has errors in node-specific portion */
 
 /* Name of the local socket to communicate between libclvm and clvmd */
 //static const char CLVMD_SOCKNAME[]="/var/run/clvmd";

daemons/clvmd/clvmd-cman.c

@@ -55,7 +55,6 @@ static int max_updown_nodes = 50;	/* Current size of the allocated array */
 static int *node_updown = NULL;
 static dlm_lshandle_t *lockspace;
 
-static void sigusr1_handler(int sig);
 static void count_clvmds_running(void);
 static void get_members(void);
 static int nodeid_from_csid(char *csid);
@@ -67,7 +66,7 @@ struct lock_wait {
 	struct dlm_lksb lksb;
 };
 
-int init_cluster()
+static int _init_cluster(void)
 {
 	struct sockaddr_cl saddr;
 	int port = CLUSTER_PORT_CLVMD;
@@ -75,9 +74,11 @@ int init_cluster()
 	/* Open the cluster communication socket */
 	cluster_sock = socket(AF_CLUSTER, SOCK_DGRAM, CLPROTO_CLIENT);
 	if (cluster_sock == -1) {
-		perror("Can't open cluster socket");
+		/* Don't print an error here because we could be just probing for CMAN */
 		return -1;
 	}
+	/* Set Close-on-exec */
+	fcntl(cluster_sock, F_SETFD, 1);
 
 	/* Bind to our port number on the cluster.
 	   Writes to this will block if the cluster loses quorum */
@@ -87,7 +88,7 @@ int init_cluster()
 	if (bind
 	    (cluster_sock, (struct sockaddr *) &saddr,
 	     sizeof(struct sockaddr_cl))) {
-		log_error("Can't bind cluster socket: %m");
+		syslog(LOG_ERR, "Can't bind cluster socket: %m");
 		return -1;
 	}
 
@@ -98,25 +99,31 @@ int init_cluster()
 	/* Create a lockspace for LV & VG locks to live in */
 	lockspace = dlm_create_lockspace(LOCKSPACE_NAME, 0600);
 	if (!lockspace) {
-		log_error("Unable to create lockspace for CLVM\n");
+		syslog(LOG_ERR, "Unable to create lockspace for CLVM: %m");
 		return -1;
 	}
 	dlm_ls_pthread_init(lockspace);
+
 	return 0;
 }
 
-int get_main_cluster_fd()
+static void _cluster_init_completed(void)
+{
+	clvmd_cluster_init_completed();
+}
+
+static int _get_main_cluster_fd()
 {
 	return cluster_sock;
 }
 
-int get_num_nodes()
+static int _get_num_nodes()
 {
 	return num_nodes;
 }
 
 /* send_message with the fd check removed */
-int cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
+static int _cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
 {
 	struct iovec iov[2];
 	struct msghdr msg;
@@ -136,7 +143,7 @@ int cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
 	if (csid) {
 		msg.msg_name = &saddr;
 		msg.msg_namelen = sizeof(saddr);
-		memcpy(&saddr.scl_nodeid, csid, MAX_CSID_LEN);
+		memcpy(&saddr.scl_nodeid, csid, CMAN_MAX_CSID_LEN);
 	} else {		/* Cluster broadcast */
 
 		msg.msg_name = NULL;
@@ -152,26 +159,26 @@ int cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
 	return len;
 }
 
-void get_our_csid(char *csid)
+static void _get_our_csid(char *csid)
 {
 	int i;
-	memset(csid, 0, MAX_CSID_LEN);
+	memset(csid, 0, CMAN_MAX_CSID_LEN);
 
 	for (i = 0; i < num_nodes; i++) {
 		if (nodes[i].us)
-			memcpy(csid, &nodes[i].node_id, MAX_CSID_LEN);
+			memcpy(csid, &nodes[i].node_id, CMAN_MAX_CSID_LEN);
 	}
 }
 
 /* Call a callback routine for each node that known (down mean not running a clvmd) */
-int cluster_do_node_callback(struct local_client *client,
+static int _cluster_do_node_callback(struct local_client *client,
 			     void (*callback) (struct local_client *, char *,
 					       int))
 {
 	int i;
 	int somedown = 0;
 
-	for (i = 0; i < get_num_nodes(); i++) {
+	for (i = 0; i < _get_num_nodes(); i++) {
 		callback(client, (char *)&nodes[i].node_id, node_updown[nodes[i].node_id]);
 		if (!node_updown[nodes[i].node_id])
 			somedown = -1;
@@ -203,7 +210,7 @@ static void process_oob_msg(char *buf, int len, int nodeid)
 	}
 }
 
-int cluster_fd_callback(struct local_client *fd, char *buf, int len, char *csid,
+static int _cluster_fd_callback(struct local_client *client, char *buf, int len, char *csid,
 			struct local_client **new_client)
 {
 	struct iovec iov[2];
@@ -247,34 +254,39 @@ int cluster_fd_callback(struct local_client *fd, char *buf, int len, char *csid,
 		len = -1;
 		errno = EAGAIN;
 	}
-	memcpy(csid, &saddr.scl_nodeid, sizeof(saddr.scl_nodeid));
+	else {
+		memcpy(csid, &saddr.scl_nodeid, sizeof(saddr.scl_nodeid));
+		/* Send it back to clvmd */
+		process_message(client, buf, len, csid);
+	}
 	return len;
 }
 
-void add_up_node(char *csid)
+static void _add_up_node(char *csid)
 {
 	/* It's up ! */
 	int nodeid = nodeid_from_csid(csid);
 
 	if (nodeid >= max_updown_nodes) {
-		int *new_updown = realloc(node_updown, max_updown_nodes + 10);
+	        int new_size = nodeid + 10;
+		int *new_updown = realloc(node_updown, new_size);
 
 		if (new_updown) {
 			node_updown = new_updown;
-			max_updown_nodes += 10;
+			max_updown_nodes = new_size;
 			DEBUGLOG("realloced more space for nodes. now %d\n",
 				 max_updown_nodes);
 		} else {
 			log_error
-			    ("Realloc failed. Node status for clvmd will be wrong\n");
-			return;
+			    ("Realloc failed. Node status for clvmd will be wrong. quitting\n");
+			exit(999);
 		}
 	}
 	node_updown[nodeid] = 1;
 	DEBUGLOG("Added new node %d to updown list\n", nodeid);
 }
 
-void cluster_closedown()
+static void _cluster_closedown()
 {
 	unlock_all();
 	dlm_release_lockspace(LOCKSPACE_NAME, lockspace, 1);
@@ -303,7 +315,7 @@ static int is_listening(int nodeid)
 
 /* Populate the list of CLVMDs running.
    called only at startup time */
-void count_clvmds_running(void)
+static void count_clvmds_running(void)
 {
 	int i;
 
@@ -319,7 +331,7 @@ static void get_members()
 
 	num_nodes = ioctl(cluster_sock, SIOCCLUSTER_GETMEMBERS, 0);
 	if (num_nodes == -1) {
-		perror("get nodes");
+		log_error("Unable to get node count");
 	} else {
 	        /* Not enough room for new nodes list ? */
 	        if (num_nodes > count_nodes && nodes) {
@@ -331,16 +343,16 @@ static void get_members()
 		        count_nodes = num_nodes + 10; /* Overallocate a little */
 		        nodes = malloc(count_nodes * sizeof(struct cl_cluster_node));
 			if (!nodes) {
-			        perror("Unable to allocate nodes array\n");
+			        log_error("Unable to allocate nodes array\n");
 				exit(5);
 			}
 		}
 		nodelist.max_members = count_nodes;
 		nodelist.nodes = nodes;
-		
+
 		num_nodes = ioctl(cluster_sock, SIOCCLUSTER_GETMEMBERS, &nodelist);
 		if (num_nodes <= 0) {
-		        perror("get node details");
+		        log_error("Unable to get node details");
 			exit(6);
 		}
 
@@ -362,13 +374,13 @@ static void get_members()
 }
 
 /* Convert a node name to a CSID */
-int csid_from_name(char *csid, char *name)
+static int _csid_from_name(char *csid, char *name)
 {
 	int i;
 
 	for (i = 0; i < num_nodes; i++) {
 		if (strcmp(name, nodes[i].name) == 0) {
-			memcpy(csid, &nodes[i].node_id, MAX_CSID_LEN);
+			memcpy(csid, &nodes[i].node_id, CMAN_MAX_CSID_LEN);
 			return 0;
 		}
 	}
@@ -376,12 +388,12 @@ int csid_from_name(char *csid, char *name)
 }
 
 /* Convert a CSID to a node name */
-int name_from_csid(char *csid, char *name)
+static int _name_from_csid(char *csid, char *name)
 {
 	int i;
 
 	for (i = 0; i < num_nodes; i++) {
-		if (memcmp(csid, &nodes[i].node_id, MAX_CSID_LEN) == 0) {
+		if (memcmp(csid, &nodes[i].node_id, CMAN_MAX_CSID_LEN) == 0) {
 			strcpy(name, nodes[i].name);
 			return 0;
 		}
@@ -392,7 +404,7 @@ int name_from_csid(char *csid, char *name)
 }
 
 /* Convert a node ID to a node name */
-int name_from_nodeid(int nodeid, char *name)
+static int name_from_nodeid(int nodeid, char *name)
 {
 	int i;
 
@@ -412,12 +424,12 @@ static int nodeid_from_csid(char *csid)
 {
         int nodeid;
 
-	memcpy(&nodeid, csid, MAX_CSID_LEN);
+	memcpy(&nodeid, csid, CMAN_MAX_CSID_LEN);
 
 	return nodeid;
 }
 
-int is_quorate()
+static int _is_quorate()
 {
 	return ioctl(cluster_sock, SIOCCLUSTER_ISQUORATE, 0);
 }
@@ -431,7 +443,7 @@ static void sync_ast_routine(void *arg)
 	pthread_mutex_unlock(&lwait->mutex);
 }
 
-int sync_lock(const char *resource, int mode, int flags, int *lockid)
+static int _sync_lock(const char *resource, int mode, int flags, int *lockid)
 {
 	int status;
 	struct lock_wait lwait;
@@ -441,6 +453,7 @@ int sync_lock(const char *resource, int mode, int flags, int *lockid)
 		return -1;
 	}
 
+	DEBUGLOG("sync_lock: '%s' mode:%d flags=%d\n", resource,mode,flags);
 	/* Conversions need the lockid in the LKSB */
 	if (flags & LKF_CONVERT)
 		lwait.lksb.sb_lkid = *lockid;
@@ -466,17 +479,20 @@ int sync_lock(const char *resource, int mode, int flags, int *lockid)
 	*lockid = lwait.lksb.sb_lkid;
 
 	errno = lwait.lksb.sb_status;
+	DEBUGLOG("sync_lock: returning lkid %x\n", *lockid);
 	if (lwait.lksb.sb_status)
 		return -1;
 	else
 		return 0;
 }
 
-int sync_unlock(const char *resource /* UNUSED */, int lockid)
+static int _sync_unlock(const char *resource /* UNUSED */, int lockid)
 {
 	int status;
 	struct lock_wait lwait;
 
+	DEBUGLOG("sync_unlock: '%s' lkid:%x\n", resource, lockid);
+
 	pthread_cond_init(&lwait.cond, NULL);
 	pthread_mutex_init(&lwait.mutex, NULL);
 	pthread_mutex_lock(&lwait.mutex);
@@ -497,3 +513,28 @@ int sync_unlock(const char *resource /* UNUSED */, int lockid)
 		return 0;
 
 }
+
+static struct cluster_ops _cluster_cman_ops = {
+	.cluster_init_completed   = _cluster_init_completed,
+	.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,
+	.cluster_closedown        = _cluster_closedown,
+	.sync_lock                = _sync_lock,
+	.sync_unlock              = _sync_unlock,
+};
+
+struct cluster_ops *init_cman_cluster(void)
+{
+	if (!_init_cluster())
+		return &_cluster_cman_ops;
+	else
+		return NULL;
+}

daemons/clvmd/clvmd-command.c

@@ -65,6 +65,7 @@
 #include <unistd.h>
 #include <errno.h>
 
+#include "libdevmapper.h"
 #include "list.h"
 #include "locking.h"
 #include "log.h"
@@ -108,7 +109,7 @@ int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
 
 	case CLVMD_CMD_LOCK_LV:
 		/* This is the biggie */
-		lock_cmd = args[0];
+		lock_cmd = args[0] & 0x3F;
 		lock_flags = args[1];
 		lockname = &args[2];
 		status = do_lock_lv(lock_cmd, lock_flags, lockname);
@@ -135,6 +136,61 @@ int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
 
 }
 
+static int lock_vg(struct local_client *client)
+{
+    struct dm_hash_table *lock_hash;
+    struct clvm_header *header =
+	(struct clvm_header *) client->bits.localsock.cmd;
+    unsigned char lock_cmd;
+    unsigned char lock_flags;
+    char *args = header->node + strlen(header->node) + 1;
+    int lkid;
+    int status = 0;
+    char *lockname;
+
+    /* Keep a track of VG locks in our own hash table. In current
+       practice there should only ever be more than two VGs locked
+       if a user tries to merge lots of them at once */
+    if (client->bits.localsock.private) {
+	lock_hash = (struct dm_hash_table *)client->bits.localsock.private;
+    }
+    else {
+	lock_hash = dm_hash_create(3);
+	if (!lock_hash)
+	    return ENOMEM;
+	client->bits.localsock.private = (void *)lock_hash;
+    }
+
+    lock_cmd = args[0] & 0x3F;
+    lock_flags = args[1];
+    lockname = &args[2];
+    DEBUGLOG("doing PRE command LOCK_VG '%s' at %x (client=%p)\n", lockname, lock_cmd, client);
+
+    if (lock_cmd == LCK_UNLOCK) {
+
+	lkid = (int)(long)dm_hash_lookup(lock_hash, lockname);
+	if (lkid == 0)
+	    return EINVAL;
+
+	status = sync_unlock(lockname, lkid);
+	if (status)
+	    status = errno;
+	else
+	    dm_hash_remove(lock_hash, lockname);
+    }
+    else {
+
+	status = sync_lock(lockname, (int)lock_cmd, (int)lock_flags, &lkid);
+	if (status)
+	    status = errno;
+	else
+	    dm_hash_insert(lock_hash, lockname, (void *)lkid);
+    }
+
+    return status;
+}
+
+
 /* Pre-command is a good place to get locks that are needed only for the duration
    of the commands around the cluster (don't forget to free them in post-command),
    and to sanity check the command arguments */
@@ -156,20 +212,7 @@ int do_pre_command(struct local_client *client)
 		break;
 
 	case CLVMD_CMD_LOCK_VG:
-		lock_cmd = args[0];
-		lock_flags = args[1];
-		lockname = &args[2];
-		DEBUGLOG("doing PRE command LOCK_VG %s at %x\n", lockname,
-			 lock_cmd);
-		if (lock_cmd == LCK_UNLOCK) {
-			hold_unlock(lockname);
-		} else {
-			status =
-			    hold_lock(lockname, (int) lock_cmd,
-				      (int) lock_flags);
-			if (status)
-				status = errno;
-		}
+       	        status = lock_vg(client);
 		break;
 
 	case CLVMD_CMD_LOCK_LV:
@@ -202,6 +245,7 @@ int do_post_command(struct local_client *client)
 	case CLVMD_CMD_TEST:
 		status =
 		    sync_unlock("CLVMD_TEST", (int) (long) client->bits.localsock.private);
+		client->bits.localsock.private = 0;
 		break;
 
 	case CLVMD_CMD_LOCK_VG:
@@ -217,3 +261,26 @@ int do_post_command(struct local_client *client)
 	}
 	return status;
 }
+
+
+/* Called when the client is about to be deleted */
+void cmd_client_cleanup(struct local_client *client)
+{
+    if (client->bits.localsock.private) {
+
+	struct dm_hash_node *v;
+	struct dm_hash_table *lock_hash =
+	    (struct dm_hash_table *)client->bits.localsock.private;
+
+	dm_hash_iterate(v, lock_hash) {
+		int lkid = (int)(long)dm_hash_get_data(lock_hash, v);
+		char *lockname = dm_hash_get_key(lock_hash, v);
+
+		DEBUGLOG("cleanup: Unlocking lock %s %x\n", lockname, lkid);
+		sync_unlock(lockname, lkid);
+	}
+
+	dm_hash_destroy(lock_hash);
+	client->bits.localsock.private = 0;
+    }
+}

daemons/clvmd/clvmd-comms.h

@@ -22,33 +22,48 @@
 
 struct local_client;
 
-extern int cluster_send_message(void *buf, int msglen, char *csid,
+struct cluster_ops {
+	void (*cluster_init_completed) (void);
+
+	int (*cluster_send_message) (void *buf, int msglen, char *csid,
 				const char *errtext);
-extern int name_from_csid(char *csid, char *name);
-extern int csid_from_name(char *csid, char *name);
-extern int get_num_nodes(void);
-extern int cluster_fd_callback(struct local_client *fd, char *buf, int len,
+	int (*name_from_csid) (char *csid, char *name);
+	int (*csid_from_name) (char *csid, char *name);
+	int (*get_num_nodes) (void);
+	int (*cluster_fd_callback) (struct local_client *fd, char *buf, int len,
 			       char *csid, struct local_client **new_client);
-extern int init_cluster(void);
-extern int get_main_cluster_fd(void);	/* gets accept FD or cman cluster socket */
-extern int cluster_do_node_callback(struct local_client *client,
+	int (*get_main_cluster_fd) (void);	/* gets accept FD or cman cluster socket */
+	int (*cluster_do_node_callback) (struct local_client *client,
 				    void (*callback) (struct local_client *,
 						      char *csid, int node_up));
-extern int is_quorate(void);
+	int (*is_quorate) (void);
 
-extern void get_our_csid(char *csid);
-extern void add_up_node(char *csid);
-extern void cluster_closedown(void);
+	void (*get_our_csid) (char *csid);
+	void (*add_up_node) (char *csid);
+	void (*reread_config) (void);
+	void (*cluster_closedown) (void);
 
-extern int sync_lock(const char *resource, int mode, int flags, int *lockid);
-extern int sync_unlock(const char *resource, int lockid);
+	int (*sync_lock) (const char *resource, int mode, int flags, int *lockid);
+	int (*sync_unlock) (const char *resource, int lockid);
+
+};
 
 #ifdef USE_GULM
-#include "tcp-comms.h"
-#else
-/* cman */
-#include "cnxman-socket.h"
-#define MAX_CSID_LEN 4
+#  include "tcp-comms.h"
+struct cluster_ops *init_gulm_cluster(void);
+#define MAX_CSID_LEN 			GULM_MAX_CSID_LEN
+#define MAX_CLUSTER_MEMBER_NAME_LEN	GULM_MAX_CLUSTER_MEMBER_NAME_LEN
+#endif
+
+#ifdef USE_CMAN
+#  include "cnxman-socket.h"
+#  define CMAN_MAX_CSID_LEN 4
+#  ifndef MAX_CSID_LEN
+#    define MAX_CSID_LEN CMAN_MAX_CSID_LEN
+#  endif
+#  undef MAX_CLUSTER_MEMBER_NAME_LEN
+#  define MAX_CLUSTER_MEMBER_NAME_LEN	CMAN_MAX_CLUSTER_MEMBER_NAME_LEN
+struct cluster_ops *init_cman_cluster(void);
 #endif
 
 

daemons/clvmd/clvmd-gulm.c

@@ -2,6 +2,7 @@
 *******************************************************************************
 **
 **  Copyright (C) Sistina Software, Inc.  2002-2003  All rights reserved.
+**  Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
 **
 *******************************************************************************
 ******************************************************************************/
@@ -40,31 +41,33 @@
 #include <syslog.h>
 #include <assert.h>
 
+#include "libdevmapper.h"
 #include "ccs.h"
 #include "list.h"
 #include "locking.h"
 #include "log.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
+#include "lvm-functions.h"
 #include "clvmd.h"
-#include "hash.h"
 #include "clvmd-gulm.h"
 #include "libgulm.h"
-#include "hash.h"
 
 /* Hash list of nodes in the cluster */
-static struct hash_table *node_hash;
+static struct dm_hash_table *node_hash;
 
 /* hash list of outstanding lock requests */
-static struct hash_table *lock_hash;
+static struct dm_hash_table *lock_hash;
 
-/* Copy of the current core state */
-static uint8_t current_corestate;
+/* Copy of the current quorate state */
+static uint8_t gulm_quorate = 0;
+static enum {INIT_NOTDONE, INIT_DONE, INIT_WAITQUORATE} init_state = INIT_NOTDONE;
 
 /* Number of active nodes */
 static int num_nodes;
 
 static char *cluster_name;
+static int in_shutdown = 0;
 
 static pthread_mutex_t lock_start_mutex;
 static volatile int lock_start_flag;
@@ -72,7 +75,7 @@ static volatile int lock_start_flag;
 struct node_info
 {
     enum {NODE_UNKNOWN, NODE_DOWN, NODE_UP, NODE_CLVMD} state;
-    char name[MAX_CLUSTER_MEMBER_NAME_LEN];
+    char name[GULM_MAX_CLUSTER_MEMBER_NAME_LEN];
 };
 
 struct lock_wait
@@ -88,9 +91,11 @@ static int read_from_core_sock(struct local_client *client, char *buf, int len,
 static int read_from_lock_sock(struct local_client *client, char *buf, int len, char *csid,
 			       struct local_client **new_client);
 static int get_all_cluster_nodes(void);
+static int _csid_from_name(char *csid, char *name);
+static void _cluster_closedown(void);
 
 /* In tcp-comms.c */
-extern struct hash_table *sock_hash;
+extern struct dm_hash_table *sock_hash;
 
 static int add_internal_client(int fd, fd_callback_t callback)
 {
@@ -112,6 +117,9 @@ static int add_internal_client(int fd, fd_callback_t callback)
     client->callback = callback;
     add_client(client);
 
+    /* Set Close-on-exec */
+    fcntl(fd, F_SETFD, 1);
+
     return 0;
 }
 
@@ -123,27 +131,45 @@ static lg_lockspace_callbacks_t lock_callbacks;
 static void badsig_handler(int sig)
 {
     DEBUGLOG("got sig %d\n", sig);
-    cluster_closedown();
+    _cluster_closedown();
     exit(0);
 }
 
-static void sighup_handler(int sig)
+static void _reread_config(void)
 {
-    DEBUGLOG("got SIGHUP\n");
-
-    /* Re-read CCS node list */
-    get_all_cluster_nodes();
+        /* Re-read CCS node list */
+	DEBUGLOG("Re-reading CCS config\n");
+	get_all_cluster_nodes();
 }
 
-int init_cluster()
+static int _init_cluster(void)
 {
     int status;
     int ccs_h;
+    int port = 0;
+    char *portstr;
 
     /* Get cluster name from CCS */
-    /* TODO: is this right? */
-    ccs_h = ccs_connect();
+    ccs_h = ccs_force_connect(NULL, 0);
+    if (ccs_h < 0)
+    {
+	syslog(LOG_ERR, "Cannot login in to CCSD server\n");
+	return -1;
+    }
+
     ccs_get(ccs_h, "//cluster/@name", &cluster_name);
+    DEBUGLOG("got cluster name %s\n", cluster_name);
+
+    if (!ccs_get(ccs_h, "//cluster/clvm/@port", &portstr))
+    {
+	port = atoi(portstr);
+	free(portstr);
+	DEBUGLOG("got port number %d\n", port);
+
+	if (port <= 0 && port >= 65536)
+	    port = 0;
+    }
+
     ccs_disconnect(ccs_h);
 
     /* Block locking until we are logged in */
@@ -151,11 +177,12 @@ int init_cluster()
     pthread_mutex_lock(&lock_start_mutex);
     lock_start_flag = 1;
 
-    node_hash = hash_create(100);
-    lock_hash = hash_create(10);
+    node_hash = dm_hash_create(100);
+    lock_hash = dm_hash_create(10);
 
     /* Get all nodes from CCS */
-    get_all_cluster_nodes();
+    if (get_all_cluster_nodes())
+	return -1;
 
     /* Initialise GULM library */
     status = lg_initialize(&gulm_if, cluster_name, "clvmd");
@@ -174,7 +201,7 @@ int init_cluster()
     }
 
     /* Initialise the inter-node comms */
-    status = init_comms();
+    status = init_comms(port);
     if (status)
 	return status;
 
@@ -202,7 +229,7 @@ int init_cluster()
 	exit(status);
     }
 
-    /* Request a list of nodes, we can;t really do anything until
+    /* Request a list of nodes, we can't really do anything until
        this comes back */
     status = lg_core_nodelist(gulm_if);
     if (status)
@@ -215,18 +242,16 @@ int init_cluster()
     signal(SIGINT, badsig_handler);
     signal(SIGTERM, badsig_handler);
 
-    /* Re-read the node list on SIGHUP */
-    signal(SIGHUP, sighup_handler);
-
     return 0;
 }
 
-void cluster_closedown()
+static void _cluster_closedown(void)
 {
     DEBUGLOG("cluster_closedown\n");
+    in_shutdown = 1;
+    unlock_all();
     lg_lock_logout(gulm_if);
     lg_core_logout(gulm_if);
-    lg_core_shutdown(gulm_if);
     lg_release(gulm_if);
 }
 
@@ -237,6 +262,7 @@ static void drop_expired_locks(char *nodename)
     struct utsname nodeinfo;
     uint8_t mask[GIO_KEY_SIZE];
 
+    DEBUGLOG("Dropping expired locks for %s\n", nodename?nodename:"(null)");
     memset(mask, 0xff, GIO_KEY_SIZE);
 
     if (!nodename)
@@ -282,7 +308,9 @@ static int core_login_reply(void *misc, uint64_t gen, uint32_t error, uint32_t r
    if (error)
        exit(error);
 
-   current_corestate = corestate;
+   /* Get the current core state (for quorum) */
+   lg_core_corestate(gulm_if);
+
    return 0;
 }
 
@@ -309,18 +337,24 @@ static void set_node_state(struct node_info *ninfo, char *csid, uint8_t nodestat
 	    if (ninfo->state != NODE_DOWN)
 		num_nodes--;
 	    ninfo->state = NODE_DOWN;
-	    tcp_remove_client(csid);
 	}
     }
-    DEBUGLOG("set_node_state, '%s' state = %d, num_nodes=%d\n",
+    /* Gulm doesn't always send node DOWN events, so even if this a a node UP we must
+     * assume (ahem) that it prevously went down at some time. So we close
+     * the sockets here to make sure that we don't have any dead connections
+     * to that node.
+     */
+    tcp_remove_client(csid);
+
+    DEBUGLOG("set_node_state, '%s' state = %d num_nodes=%d\n",
 	     ninfo->name, ninfo->state, num_nodes);
 }
 
-static struct node_info *add_or_set_node(char *name, uint32_t ip, uint8_t state)
+static struct node_info *add_or_set_node(char *name, struct in6_addr *ip, uint8_t state)
 {
     struct node_info *ninfo;
 
-    ninfo = hash_lookup_binary(node_hash, (char *)&ip, MAX_CSID_LEN);
+    ninfo = dm_hash_lookup_binary(node_hash, (char *)ip, GULM_MAX_CSID_LEN);
     if (!ninfo)
     {
 	/* If we can't find that node then re-read the config file in case it
@@ -329,7 +363,7 @@ static struct node_info *add_or_set_node(char *name, uint32_t ip, uint8_t state)
 	get_all_cluster_nodes();
 
 	/* Now try again */
-	ninfo = hash_lookup_binary(node_hash, (char *)&ip, MAX_CSID_LEN);
+	ninfo = dm_hash_lookup_binary(node_hash, (char *)ip, GULM_MAX_CSID_LEN);
 	if (!ninfo)
 	{
 	    DEBUGLOG("Ignoring node %s, not part of the SAN cluster\n", name);
@@ -337,12 +371,17 @@ static struct node_info *add_or_set_node(char *name, uint32_t ip, uint8_t state)
 	}
     }
 
-    set_node_state(ninfo, (char *)&ip, state);
+    set_node_state(ninfo, (char *)ip, state);
 
     return ninfo;
 }
 
-static int core_nodelist(void *misc, lglcb_t type, char *name, uint32_t ip, uint8_t state)
+static void _get_our_csid(char *csid)
+{
+	get_our_gulm_csid(csid);
+}
+
+static int core_nodelist(void *misc, lglcb_t type, char *name, struct in6_addr *ip, uint8_t state)
 {
     DEBUGLOG("CORE nodelist\n");
 
@@ -354,7 +393,7 @@ static int core_nodelist(void *misc, lglcb_t type, char *name, uint32_t ip, uint
     {
 	if (type == lglcb_item)
 	{
-	    DEBUGLOG("Got nodelist, item: %s, %#x, %#x\n", name, ip, state);
+	    DEBUGLOG("Got nodelist, item: %s, %#x\n", name, state);
 
 	    add_or_set_node(name, ip, state);
 	}
@@ -362,14 +401,23 @@ static int core_nodelist(void *misc, lglcb_t type, char *name, uint32_t ip, uint
 	{
 	    if (type == lglcb_stop)
 	    {
-		char ourcsid[MAX_CSID_LEN];
+		char ourcsid[GULM_MAX_CSID_LEN];
 
 		DEBUGLOG("Got Nodelist, stop\n");
-		clvmd_cluster_init_completed();
+		if (gulm_quorate)
+		{
+			clvmd_cluster_init_completed();
+			init_state = INIT_DONE;
+		}
+		else
+		{
+			if (init_state == INIT_NOTDONE)
+				init_state = INIT_WAITQUORATE;
+		}
 
 		/* Mark ourself as up */
-		get_our_csid(ourcsid);
-		add_up_node(ourcsid);
+		_get_our_csid(ourcsid);
+		gulm_add_up_node(ourcsid);
 	    }
 	    else
 	    {
@@ -381,24 +429,29 @@ static int core_nodelist(void *misc, lglcb_t type, char *name, uint32_t ip, uint
     return 0;
 }
 
-static int core_statechange(void *misc, uint8_t corestate, uint32_t masterip, char *mastername)
+static int core_statechange(void *misc, uint8_t corestate, uint8_t quorate, struct in6_addr *masterip, char *mastername)
 {
-    DEBUGLOG("CORE Got statechange  corestate:%#x masterip:%#x mastername:%s\n",
-	     corestate, masterip, mastername);
+    DEBUGLOG("CORE Got statechange. quorate:%d, corestate:%x mastername:%s\n",
+	     quorate, corestate, mastername);
 
-    current_corestate = corestate;
+    gulm_quorate = quorate;
+    if (quorate && init_state == INIT_WAITQUORATE)
+    {
+	    clvmd_cluster_init_completed();
+	    init_state = INIT_DONE;
+    }
     return 0;
 }
 
-static int core_nodechange(void *misc, char *nodename, uint32_t nodeip, uint8_t nodestate)
+static int core_nodechange(void *misc, char *nodename, struct in6_addr *nodeip, uint8_t nodestate)
 {
     struct node_info *ninfo;
 
-    DEBUGLOG("CORE node change, name=%s, ip=%x, state = %d\n", nodename, nodeip, nodestate);
+    DEBUGLOG("CORE node change, name=%s, state = %d\n", nodename, nodestate);
 
     /* If we don't get nodeip here, try a lookup by name */
     if (!nodeip)
-	csid_from_name((char *)&nodeip, nodename);
+	_csid_from_name((char *)nodeip, nodename);
     if (!nodeip)
 	return 0;
 
@@ -443,14 +496,20 @@ static int lock_login_reply(void *misc, uint32_t error, uint8_t which)
     return 0;
 }
 
-static int lock_lock_state(void *misc, uint8_t *key, uint16_t keylen, uint8_t state, uint32_t flags, uint32_t error,
+static int lock_lock_state(void *misc, uint8_t *key, uint16_t keylen,
+			   uint64_t subid, uint64_t start, uint64_t stop,
+			   uint8_t state, uint32_t flags, uint32_t error,
 			   uint8_t *LVB, uint16_t LVBlen)
 {
     struct lock_wait *lwait;
 
     DEBUGLOG("LOCK lock state: %s, error = %d\n", key, error);
 
-    lwait = hash_lookup(lock_hash, key);
+    /* No waiting process to wake up when we are shutting down */
+    if (in_shutdown)
+	    return 0;
+
+    lwait = dm_hash_lookup(lock_hash, key);
     if (!lwait)
     {
 	DEBUGLOG("Can't find hash entry for resource %s\n", key);
@@ -495,22 +554,22 @@ int get_next_node_csid(void **context, char *csid)
     /* First node */
     if (!*context)
     {
-	*context = hash_get_first(node_hash);
+	*context = dm_hash_get_first(node_hash);
     }
     else
     {
-	*context = hash_get_next(node_hash, *context);
+	*context = dm_hash_get_next(node_hash, *context);
     }
     if (*context)
-	ninfo = hash_get_data(node_hash, *context);
+	ninfo = dm_hash_get_data(node_hash, *context);
 
     /* Find a node that is UP */
     while (*context && ninfo->state == NODE_DOWN)
     {
-	*context = hash_get_next(node_hash, *context);
+	*context = dm_hash_get_next(node_hash, *context);
 	if (*context)
 	{
-	    ninfo = hash_get_data(node_hash, *context);
+	    ninfo = dm_hash_get_data(node_hash, *context);
 	}
     }
 
@@ -519,19 +578,18 @@ int get_next_node_csid(void **context, char *csid)
 	return 0;
     }
 
-    memcpy(csid, hash_get_key(node_hash, *context), MAX_CSID_LEN);
+    memcpy(csid, dm_hash_get_key(node_hash, *context), GULM_MAX_CSID_LEN);
     return 1;
 }
 
-int name_from_csid(char *csid, char *name)
+int gulm_name_from_csid(char *csid, char *name)
 {
     struct node_info *ninfo;
 
-    ninfo = hash_lookup_binary(node_hash, csid, MAX_CSID_LEN);
+    ninfo = dm_hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
     if (!ninfo)
     {
-	sprintf(name, "UNKNOWN [%d.%d.%d.%d]",
-		csid[0], csid[1], csid[2], csid[3]);
+        sprintf(name, "UNKNOWN %s", print_csid(csid));
 	return -1;
     }
 
@@ -540,39 +598,46 @@ int name_from_csid(char *csid, char *name)
 }
 
 
-int csid_from_name(char *csid, char *name)
+static int _csid_from_name(char *csid, char *name)
 {
-    struct hash_node *hn;
+    struct dm_hash_node *hn;
     struct node_info *ninfo;
 
-    hash_iterate(hn, node_hash)
+    dm_hash_iterate(hn, node_hash)
     {
-	ninfo = hash_get_data(node_hash, hn);
+	ninfo = dm_hash_get_data(node_hash, hn);
 	if (strcmp(ninfo->name, name) == 0)
 	{
-	    memcpy(csid, hash_get_key(node_hash, hn), MAX_CSID_LEN);
+	    memcpy(csid, dm_hash_get_key(node_hash, hn), GULM_MAX_CSID_LEN);
 	    return 0;
 	}
     }
     return -1;
 }
 
-int get_num_nodes()
+static int _get_num_nodes()
 {
     DEBUGLOG("num_nodes = %d\n", num_nodes);
     return num_nodes;
 }
 
 /* Node is now known to be running a clvmd */
-void add_up_node(char *csid)
+void gulm_add_up_node(char *csid)
 {
     struct node_info *ninfo;
 
-    ninfo = hash_lookup_binary(node_hash, csid, MAX_CSID_LEN);
-    if (!ninfo)
+    ninfo = dm_hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
+    if (!ninfo) {
+	    DEBUGLOG("gulm_add_up_node no node_hash entry for csid %s\n", print_csid(csid));
 	return;
+    }
 
+    DEBUGLOG("gulm_add_up_node %s\n", ninfo->name);
+
+    if (ninfo->state == NODE_DOWN)
+	    num_nodes++;
     ninfo->state = NODE_CLVMD;
+
     return;
 
 }
@@ -581,7 +646,7 @@ void add_down_node(char *csid)
 {
     struct node_info *ninfo;
 
-    ninfo = hash_lookup_binary(node_hash, csid, MAX_CSID_LEN);
+    ninfo = dm_hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
     if (!ninfo)
 	return;
 
@@ -589,30 +654,42 @@ void add_down_node(char *csid)
        running clvmd - gulm may set it DOWN quite soon */
     if (ninfo->state == NODE_CLVMD)
 	ninfo->state = NODE_UP;
+    drop_expired_locks(ninfo->name);
     return;
 
 }
 
 /* Call a callback for each node, so the caller knows whether it's up or down */
-int cluster_do_node_callback(struct local_client *master_client,
-			     void (*callback)(struct local_client *, char *csid, int node_up))
+static int _cluster_do_node_callback(struct local_client *master_client,
+				     void (*callback)(struct local_client *, char *csid, int node_up))
 {
-    struct hash_node *hn;
+    struct dm_hash_node *hn;
     struct node_info *ninfo;
 
-    hash_iterate(hn, node_hash)
+    dm_hash_iterate(hn, node_hash)
     {
-	char csid[MAX_CSID_LEN];
+	char csid[GULM_MAX_CSID_LEN];
 	struct local_client *client;
 
-	ninfo = hash_get_data(node_hash, hn);
-	memcpy(csid, hash_get_key(node_hash, hn), MAX_CSID_LEN);
+	ninfo = dm_hash_get_data(node_hash, hn);
+	memcpy(csid, dm_hash_get_key(node_hash, hn), GULM_MAX_CSID_LEN);
 
 	DEBUGLOG("down_callback. node %s, state = %d\n", ninfo->name, ninfo->state);
 
-	client = hash_lookup_binary(sock_hash, csid, MAX_CSID_LEN);
-	if (client)
-	    callback(master_client, csid, ninfo->state == NODE_CLVMD);
+	client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
+	if (!client)
+	{
+	    /* If it's up but not connected, try to make contact */
+	    if (ninfo->state == NODE_UP)
+		    gulm_connect_csid(csid, &client);
+
+	    client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
+
+	}
+	if (ninfo->state != NODE_DOWN)
+		callback(master_client, csid, ninfo->state == NODE_CLVMD);
+
+
     }
     return 0;
 }
@@ -623,15 +700,13 @@ static int gulm_to_errno(int gulm_ret)
     switch (gulm_ret)
     {
     case lg_err_TryFailed:
-	errno = EAGAIN;
-	break;
-
     case lg_err_AlreadyPend:
-	errno = EBUSY;
+	    errno = EAGAIN;
+	    break;
 
 	/* More?? */
     default:
-	errno = EINVAL;
+	    errno = EINVAL;
     }
 
     return gulm_ret ? -1 : 0;
@@ -657,10 +732,11 @@ static int _lock_resource(char *resource, int mode, int flags, int *lockid)
     /* This needs to be converted from DLM/LVM2 value for GULM */
     if (flags == LCK_NONBLOCK) flags = lg_lock_flag_Try;
 
-    hash_insert(lock_hash, resource, &lwait);
+    dm_hash_insert(lock_hash, resource, &lwait);
     DEBUGLOG("lock_resource '%s', flags=%d, mode=%d\n", resource, flags, mode);
 
     status = lg_lock_state_req(gulm_if, resource, strlen(resource)+1,
+			       0, 0, 0,
 			       mode, flags, NULL, 0);
     if (status)
     {
@@ -672,7 +748,7 @@ static int _lock_resource(char *resource, int mode, int flags, int *lockid)
     pthread_cond_wait(&lwait.cond, &lwait.mutex);
     pthread_mutex_unlock(&lwait.mutex);
 
-    hash_remove(lock_hash, resource);
+    dm_hash_remove(lock_hash, resource);
     DEBUGLOG("lock-resource returning %d\n", lwait.status);
 
     return gulm_to_errno(lwait.status);
@@ -688,10 +764,11 @@ static int _unlock_resource(char *resource, int lockid)
     pthread_mutex_init(&lwait.mutex, NULL);
     pthread_mutex_lock(&lwait.mutex);
 
-    hash_insert(lock_hash, resource, &lwait);
+    dm_hash_insert(lock_hash, resource, &lwait);
 
     DEBUGLOG("unlock_resource %s\n", resource);
     status = lg_lock_state_req(gulm_if, resource, strlen(resource)+1,
+			       0, 0, 0,
 			       lg_lock_state_Unlock, 0, NULL, 0);
 
     if (status)
@@ -700,12 +777,17 @@ static int _unlock_resource(char *resource, int lockid)
 	return status;
     }
 
+    /* When we are shutting down, don't wait for unlocks
+       to be acknowledged, just do it. */
+    if (in_shutdown)
+	    return status;
+
     /* Wait for it to complete */
 
     pthread_cond_wait(&lwait.cond, &lwait.mutex);
     pthread_mutex_unlock(&lwait.mutex);
 
-    hash_remove(lock_hash, resource);
+    dm_hash_remove(lock_hash, resource);
 
     return gulm_to_errno(lwait.status);
 }
@@ -720,7 +802,7 @@ static int _unlock_resource(char *resource, int lockid)
    To aid unlocking, we store the lock mode in the lockid (as GULM
    doesn't use this).
 */
-int sync_lock(const char *resource, int mode, int flags, int *lockid)
+static int _sync_lock(const char *resource, int mode, int flags, int *lockid)
 {
     int status;
     char lock1[strlen(resource)+3];
@@ -736,7 +818,7 @@ int sync_lock(const char *resource, int mode, int flags, int *lockid)
 	if (status)
 	    goto out;
 
-	/* If we can't get this lock then bail out */
+	/* If we can't get this lock too then bail out */
 	status = _lock_resource(lock2, lg_lock_state_Exclusive, LCK_NONBLOCK, lockid);
         if (status == lg_err_TryFailed)
         {
@@ -748,10 +830,16 @@ int sync_lock(const char *resource, int mode, int flags, int *lockid)
 
     case LCK_READ:
 	status = _lock_resource(lock1, lg_lock_state_Shared, flags, lockid);
+	if (status)
+		goto out;
+	status = _unlock_resource(lock2, *lockid);
 	break;
 
     case LCK_WRITE:
 	status = _lock_resource(lock2, lg_lock_state_Exclusive, flags, lockid);
+	if (status)
+		goto out;
+	status = _unlock_resource(lock1, *lockid);
 	break;
 
     default:
@@ -764,7 +852,7 @@ int sync_lock(const char *resource, int mode, int flags, int *lockid)
     return status;
 }
 
-int sync_unlock(const char *resource, int lockid)
+static int _sync_unlock(const char *resource, int lockid)
 {
     int status = 0;
     char lock1[strlen(resource)+3];
@@ -778,36 +866,16 @@ int sync_unlock(const char *resource, int lockid)
 	   lockid == LCK_READ ||
 	   lockid == LCK_WRITE);
 
-    switch (lockid)
-    {
-    case LCK_EXCL:
-	status = _unlock_resource(lock1, lockid);
-	if (status)
-	    goto out;
-	status = _unlock_resource(lock2, lockid);
-	break;
+    status = _unlock_resource(lock1, lockid);
+    if (!status)
+	    status = _unlock_resource(lock2, lockid);
 
-    case LCK_READ:
-	status = _unlock_resource(lock1, lockid);
-	break;
-
-    case LCK_WRITE:
-	status = _unlock_resource(lock2, lockid);
-	break;
-    }
-
- out:
     return status;
 }
 
-int is_quorate()
+static int _is_quorate()
 {
-    if (current_corestate == lg_core_Slave ||
-	current_corestate == lg_core_Master ||
-	current_corestate == lg_core_Client)
-	return 1;
-    else
-	return 0;
+	return gulm_quorate;
 }
 
 /* Get all the cluster node names & IPs from CCS and
@@ -819,31 +887,43 @@ static int get_all_cluster_nodes()
     int ctree;
     char *nodename;
     int error;
+    int i;
 
     /* Open the config file */
-    ctree = ccs_connect();
-    if (ctree <= 0)
+    ctree = ccs_force_connect(NULL, 1);
+    if (ctree < 0)
     {
 	log_error("Error connecting to CCS");
 	return -1;
     }
 
-    error = ccs_get(ctree, "//nodes/node/@name", &nodename);
-    while (nodename)
+    for (i=1;;i++)
     {
-	char nodeip[MAX_CSID_LEN];
-	char *clvmflag;
+	char nodekey[256];
+	char nodeip[GULM_MAX_CSID_LEN];
+	int  clvmflag = 1;
+	char *clvmflagstr;
 	char key[256];
 
-	sprintf(key, "//nodes/node[@name=\"%s\"]/clvm", nodename);
-	ccs_get(ctree, key, &clvmflag);
+	sprintf(nodekey, "//cluster/clusternodes/clusternode[%d]/@name", i);
+	error = ccs_get(ctree, nodekey, &nodename);
+	if (error)
+	    break;
 
-	if ((get_ip_address(nodename, nodeip) == 0) && atoi(clvmflag))
+	sprintf(key, "//cluster/clusternodes/clusternode[@name=\"%s\"]/clvm", nodename);
+	if (!ccs_get(ctree, key, &clvmflagstr))
+	{
+	    clvmflag = atoi(clvmflagstr);
+	    free(clvmflagstr);
+	}
+
+	DEBUGLOG("Got node %s from ccs(clvmflag = %d)\n", nodename, clvmflag);
+	if ((get_ip_address(nodename, nodeip) == 0) && clvmflag)
 	{
 	    struct node_info *ninfo;
 
 	    /* If it's not in the list, then add it */
-	    ninfo = hash_lookup_binary(node_hash, nodeip, MAX_CSID_LEN);
+	    ninfo = dm_hash_lookup_binary(node_hash, nodeip, GULM_MAX_CSID_LEN);
 	    if (!ninfo)
 	    {
 		ninfo = malloc(sizeof(struct node_info));
@@ -856,16 +936,20 @@ static int get_all_cluster_nodes()
 		strcpy(ninfo->name, nodename);
 
 		ninfo->state = NODE_DOWN;
-		hash_insert_binary(node_hash, nodeip, MAX_CSID_LEN, ninfo);
+		dm_hash_insert_binary(node_hash, nodeip, GULM_MAX_CSID_LEN, ninfo);
 	    }
 	}
 	else
 	{
-	    DEBUGLOG("node %s has clvm disabled\n", nodename);
+		if (!clvmflag) {
+			DEBUGLOG("node %s has clvm disabled\n", nodename);
+		}
+		else {
+			DEBUGLOG("Cannot resolve host name %s\n", nodename);
+			log_err("Cannot resolve host name %s\n", nodename);
+		}
 	}
-	if (clvmflag) free(clvmflag);
 	free(nodename);
-	error = ccs_get(ctree, "//nodes/node/@name", &nodename);
     }
 
     /* Finished with config file */
@@ -874,7 +958,43 @@ static int get_all_cluster_nodes()
     return 0;
 }
 
-int gulm_fd(void)
+static int _get_main_cluster_fd(void)
 {
-    return lg_core_selector(gulm_if);
+	return get_main_gulm_cluster_fd();
+}
+
+static int _cluster_fd_callback(struct local_client *fd, char *buf, int len, char *csid, struct local_client **new_client)
+{
+	return cluster_fd_gulm_callback(fd, buf, len, csid, new_client);
+}
+
+static int _cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
+{
+	return gulm_cluster_send_message(buf, msglen, csid, errtext);
+}
+
+static struct cluster_ops _cluster_gulm_ops = {
+	.cluster_init_completed   = NULL,
+	.cluster_send_message     = _cluster_send_message,
+	.name_from_csid           = gulm_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              = gulm_add_up_node,
+	.reread_config            = _reread_config,
+	.cluster_closedown        = _cluster_closedown,
+	.sync_lock                = _sync_lock,
+	.sync_unlock              = _sync_unlock,
+};
+
+struct cluster_ops *init_gulm_cluster(void)
+{
+	if (!_init_cluster())
+		return &_cluster_gulm_ops;
+	else
+		return NULL;
 }

daemons/clvmd/clvmd-gulm.h

@@ -7,3 +7,6 @@ extern int gulm_fd(void);
 extern int get_ip_address(char *node, char *addr);
 extern void tcp_remove_client(char *csid);
 extern int alloc_client(int fd, char *csid, struct local_client **new_client);
+
+void gulm_add_up_node(char *csid);
+int gulm_name_from_csid(char *csid, char *name);

daemons/clvmd/clvmd.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -34,11 +34,13 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <getopt.h>
+#include <syslog.h>
 #include <errno.h>
 
 #include "clvmd-comms.h"
 #include "lvm-functions.h"
 #include "clvm.h"
+#include "version.h"
 #include "clvmd.h"
 #include "libdlm.h"
 #include "system-lv.h"
@@ -54,9 +56,9 @@
 
 /* The maximum size of a message that will fit into a packet. Anything bigger
    than this is sent via the system LV */
-#define MAX_INLINE_MESSAGE (MAX_CLUSTER_MESSAGE-sizeof(struct clvm_header))
+#define MAX_INLINE_MESSAGE (max_cluster_message-sizeof(struct clvm_header))
 
-#define ISLOCAL_CSID(c) (memcmp(c, our_csid, MAX_CSID_LEN) == 0)
+#define ISLOCAL_CSID(c) (memcmp(c, our_csid, max_csid_len) == 0)
 
 /* Head of the fd list. Also contains
    the cluster_socket details */
@@ -64,7 +66,12 @@ static struct local_client local_client_head;
 
 static unsigned short global_xid = 0;	/* Last transaction ID issued */
 
+static struct cluster_ops *clops = NULL;
+
 static char our_csid[MAX_CSID_LEN];
+static unsigned max_csid_len;
+static unsigned max_cluster_message;
+static unsigned max_cluster_member_name_len;
 
 /* Structure of items on the LVM thread list */
 struct lvm_thread_cmd {
@@ -80,11 +87,22 @@ struct lvm_thread_cmd {
 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 int quit = 0;
+static volatile sig_atomic_t quit = 0;
+static volatile sig_atomic_t reread_config = 0;
+static int child_pipe[2];
+
+/* Reasons the daemon failed initialisation */
+#define DFAIL_INIT       1
+#define DFAIL_LOCAL_SOCK 2
+#define DFAIL_CLUSTER_IF 3
+#define DFAIL_MALLOC     4
+#define SUCCESS          0
 
 /* Prototypes for code further down */
 static void sigusr2_handler(int sig);
+static void sighup_handler(int sig);
 static void sigterm_handler(int sig);
 static void send_local_reply(struct local_client *client, int status,
 			     int clientid);
@@ -129,6 +147,18 @@ static void usage(char *prog, FILE *file)
 	fprintf(file, "\n");
 }
 
+/* Called to signal the parent how well we got on during initialisation */
+static void child_init_signal(int status)
+{
+        if (child_pipe[1]) {
+	        write(child_pipe[1], &status, sizeof(status));
+		close(child_pipe[1]);
+	}
+	if (status)
+	        exit(status);
+}
+
+
 int main(int argc, char *argv[])
 {
 	int local_sock;
@@ -138,6 +168,7 @@ int main(int argc, char *argv[])
 	int debug = 0;
 	int cmd_timeout = DEFAULT_CMD_TIMEOUT;
 	sigset_t ss;
+	int using_gulm = 0;
 
 	/* Deal with command-line arguments */
 	opterr = 0;
@@ -166,7 +197,8 @@ int main(int argc, char *argv[])
 			break;
 
 		case 'V':
-			printf("\nCluster LVM Daemon version %d.%d.%d\n\n",
+		        printf("Cluster LVM daemon version: %s\n", LVM_VERSION);
+			printf("Protocol version:           %d.%d.%d\n",
 			       CLVMD_MAJOR_VERSION, CLVMD_MINOR_VERSION,
 			       CLVMD_PATCH_VERSION);
 			exit(1);
@@ -188,14 +220,14 @@ int main(int argc, char *argv[])
 	   but the cluster is not ready yet */
 	local_sock = open_local_sock();
 	if (local_sock < 0)
-		exit(2);
+		child_init_signal(DFAIL_LOCAL_SOCK);
 
 	/* Set up signal handlers, USR1 is for cluster change notifications (in cman)
 	   USR2 causes child threads to exit.
+	   HUP causes gulm version to re-read nodes list from CCS.
 	   PIPE should be ignored */
 	signal(SIGUSR2, sigusr2_handler);
-	signal(SIGTERM, sigterm_handler);
-	signal(SIGINT, sigterm_handler);
+	signal(SIGHUP,  sighup_handler);
 	signal(SIGPIPE, SIG_IGN);
 
 	/* Block SIGUSR2 in the main process */
@@ -207,31 +239,52 @@ int main(int argc, char *argv[])
 	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);
 	init_lvhash();
 
 	/* Start the cluster interface */
-	if (init_cluster()) {
+#ifdef USE_CMAN
+	if ((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_CLUSTER_MEMBER_NAME_LEN;
+		syslog(LOG_NOTICE, "Cluster LVM daemon started - connected to CMAN");
+	}
+#endif
+#ifdef USE_GULM
+	if (!clops)
+		if ((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;
+			using_gulm = 1;
+			syslog(LOG_NOTICE, "Cluster LVM daemon started - connected to GULM");
+		}
+#endif
+
+	if (!clops) {
 		DEBUGLOG("Can't initialise cluster interface\n");
 		log_error("Can't initialise cluster interface\n");
-		exit(5);
+		child_init_signal(DFAIL_CLUSTER_IF);
 	}
 	DEBUGLOG("Cluster ready, doing some more initialisation\n");
 
 	/* Save our CSID */
 	uname(&nodeinfo);
-	get_our_csid(our_csid);
+	clops->get_our_csid(our_csid);
 
 	/* Initialise the FD list head */
-	local_client_head.fd = get_main_cluster_fd();
+	local_client_head.fd = clops->get_main_cluster_fd();
 	local_client_head.type = CLUSTER_MAIN_SOCK;
-	local_client_head.callback = cluster_fd_callback;
+	local_client_head.callback = clops->cluster_fd_callback;
 
 	/* Add the local socket to the list */
 	newfd = malloc(sizeof(struct local_client));
 	if (!newfd)
-		exit(2);
+	        child_init_signal(DFAIL_MALLOC);
 
 	newfd->fd = local_sock;
+	newfd->removeme = 0;
 	newfd->type = LOCAL_RENDEZVOUS;
 	newfd->callback = local_rendezvous_callback;
 	newfd->next = local_client_head.next;
@@ -240,17 +293,21 @@ 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");
-	pthread_create(&lvm_thread, NULL, lvm_thread_fn, nodeinfo.nodename);
+	pthread_create(&lvm_thread, NULL, lvm_thread_fn, (void *)using_gulm);
 
-#ifndef USE_GULM
 	/* Tell the rest of the cluster our version number */
 	/* CMAN can do this immediately, gulm needs to wait until
 	   the core initialisation has finished and the node list
 	   has been gathered */
-	send_version_message();
-#endif
+	if (clops->cluster_init_completed)
+		clops->cluster_init_completed();
 
 	DEBUGLOG("clvmd ready for work\n");
+	child_init_signal(SUCCESS);
+
+	/* Try to shutdown neatly */
+	signal(SIGTERM, sigterm_handler);
+	signal(SIGINT, sigterm_handler);
 
 	/* Do some work */
 	main_loop(local_sock, cmd_timeout);
@@ -294,6 +351,7 @@ static int local_rendezvous_callback(struct local_client *thisfd, char *buf,
 		newfd->fd = client_fd;
 		newfd->type = LOCAL_SOCK;
 		newfd->xid = 0;
+		newfd->removeme = 0;
 		newfd->callback = local_sock_callback;
 		newfd->bits.localsock.replies = NULL;
 		newfd->bits.localsock.expected_replies = 0;
@@ -303,6 +361,7 @@ static int local_rendezvous_callback(struct local_client *thisfd, char *buf,
 		newfd->bits.localsock.threadid = 0;
 		newfd->bits.localsock.finished = 0;
 		newfd->bits.localsock.pipe_client = NULL;
+		newfd->bits.localsock.private = NULL;
 		newfd->bits.localsock.all_success = 1;
 		DEBUGLOG("Got new connection on fd %d\n", newfd->fd);
 		*new_client = newfd;
@@ -391,9 +450,9 @@ static void timedout_callback(struct local_client *client, char *csid,
 {
 	if (node_up) {
 		struct node_reply *reply;
-		char nodename[MAX_CLUSTER_MEMBER_NAME_LEN];
+		char nodename[max_cluster_member_name_len];
 
-		name_from_csid(csid, nodename);
+		clops->name_from_csid(csid, nodename);
 		DEBUGLOG("PJC: checking for a reply from %s\n", nodename);
 		pthread_mutex_lock(&client->bits.localsock.reply_mutex);
 
@@ -422,7 +481,7 @@ static void timedout_callback(struct local_client *client, char *csid,
 static void request_timed_out(struct local_client *client)
 {
 	DEBUGLOG("Request timed-out. padding\n");
-	cluster_do_node_callback(client, timedout_callback);
+	clops->cluster_do_node_callback(client, timedout_callback);
 
 	if (client->bits.localsock.num_replies !=
 	    client->bits.localsock.expected_replies) {
@@ -447,26 +506,54 @@ static void main_loop(int local_sock, int cmd_timeout)
 		int select_status;
 		struct local_client *thisfd;
 		struct timeval tv = { cmd_timeout, 0 };
-		int quorate = is_quorate();
+		int quorate = clops->is_quorate();
 
 		/* Wait on the cluster FD and all local sockets/pipes */
 		FD_ZERO(&in);
 		for (thisfd = &local_client_head; thisfd != NULL;
 		     thisfd = thisfd->next) {
+
+			if (thisfd->removeme)
+				continue;
+
 			/* if the cluster is not quorate then don't listen for new requests */
 			if ((thisfd->type != LOCAL_RENDEZVOUS &&
 			     thisfd->type != LOCAL_SOCK) || quorate)
 				FD_SET(thisfd->fd, &in);
 		}
 
-		if ((select_status = select(FD_SETSIZE, &in, NULL, NULL, &tv)) > 0) {
+		select_status = select(FD_SETSIZE, &in, NULL, NULL, &tv);
+
+		if (reread_config) {
+			int saved_errno = errno;
+
+			reread_config = 0;
+			if (clops->reread_config)
+				clops->reread_config();
+			errno = saved_errno;
+		}
+
+		if (select_status > 0) {
 			struct local_client *lastfd = NULL;
-			struct clvm_header *inheader;
 			char csid[MAX_CSID_LEN];
-			char buf[MAX_CLUSTER_MESSAGE];
+			char buf[max_cluster_message];
 
 			for (thisfd = &local_client_head; thisfd != NULL;
 			     thisfd = thisfd->next) {
+
+				if (thisfd->removeme) {
+					struct local_client *free_fd;
+					lastfd->next = thisfd->next;
+					free_fd = thisfd;
+					thisfd = lastfd;
+
+					DEBUGLOG("removeme set for fd %d\n", free_fd->fd);
+
+					/* Queue cleanup, this also frees the client struct */
+					add_to_lvmqueue(free_fd, NULL, 0, NULL);
+					break;
+				}
+
 				if (FD_ISSET(thisfd->fd, &in)) {
 					struct local_client *newfd;
 					int ret;
@@ -490,13 +577,15 @@ static void main_loop(int local_sock, int cmd_timeout)
 						    type == CLUSTER_INTERNAL)
 							goto closedown;
 
-						DEBUGLOG
-						    ("ret == %d, errno = %d. removing client\n",
-						     ret, errno);
+						DEBUGLOG("ret == %d, errno = %d. removing client\n",
+							 ret, errno);
 						lastfd->next = thisfd->next;
 						free_fd = thisfd;
 						thisfd = lastfd;
-						free(free_fd);
+						close(free_fd->fd);
+
+						/* Queue cleanup, this also frees the client struct */
+						add_to_lvmqueue(free_fd, NULL, 0, NULL);
 						break;
 					}
 
@@ -506,33 +595,6 @@ static void main_loop(int local_sock, int cmd_timeout)
 						thisfd->next = newfd;
 						break;
 					}
-
-					switch (thisfd->type) {
-					case CLUSTER_MAIN_SOCK:
-					case CLUSTER_DATA_SOCK:
-						inheader =
-						    (struct clvm_header *) buf;
-						ntoh_clvm(inheader);	/* Byteswap fields */
-						if (inheader->cmd ==
-						    CLVMD_CMD_REPLY)
-							    process_reply
-							    (inheader, ret,
-							     csid);
-						else
-							add_to_lvmqueue(thisfd,
-									inheader,
-									ret,
-									csid);
-						break;
-
-						/* All the work for these is done in the callback
-						   rightly or wrongly... */
-					case LOCAL_RENDEZVOUS:
-					case LOCAL_SOCK:
-					case THREAD_PIPE:
-					case CLUSTER_INTERNAL:
-						break;
-					}
 				}
 				lastfd = thisfd;
 			}
@@ -575,30 +637,69 @@ static void main_loop(int local_sock, int cmd_timeout)
 	}
 
       closedown:
-	cluster_closedown();
+	clops->cluster_closedown();
 	close(local_sock);
 }
 
-/* Fork into the background and detach from our parent process */
+/*
+ * Fork into the background and detach from our parent process.
+ * In the interests of user-friendliness we wait for the daemon
+ * to complete initialisation before returning its status
+ * the the user.
+ */
 static void be_daemon()
 {
-	pid_t pid;
+        pid_t pid;
+	int child_status;
 	int devnull = open("/dev/null", O_RDWR);
 	if (devnull == -1) {
 		perror("Can't open /dev/null");
 		exit(3);
 	}
 
+	pipe(child_pipe);
+
 	switch (pid = fork()) {
 	case -1:
 		perror("clvmd: can't fork");
 		exit(2);
 
-	case 0:		/* child */
+	case 0:		/* Child */
+	        close(child_pipe[0]);
 		break;
 
-	default:		/* Parent */
-		exit(0);
+	default:       /* Parent */
+		close(child_pipe[1]);
+		if (read(child_pipe[0], &child_status, sizeof(child_status)) !=
+		    sizeof(child_status)) {
+
+		        fprintf(stderr, "clvmd failed in initialisation\n");
+		        exit(DFAIL_INIT);
+		}
+		else {
+		        switch (child_status) {
+			case SUCCESS:
+			        break;
+			case DFAIL_INIT:
+			        fprintf(stderr, "clvmd failed in initialisation\n");
+				break;
+			case DFAIL_LOCAL_SOCK:
+			        fprintf(stderr, "clvmd could not create local socket\n");
+				fprintf(stderr, "Another clvmd is probably already running\n");
+				break;
+			case DFAIL_CLUSTER_IF:
+			        fprintf(stderr, "clvmd could not connect to cluster manager\n");
+				fprintf(stderr, "Consult syslog for more information\n");
+				break;
+			case DFAIL_MALLOC:
+			        fprintf(stderr, "clvmd failed, not enough memory\n");
+				break;
+			default:
+			        fprintf(stderr, "clvmd failed, error was %d\n", child_status);
+				break;
+			}
+			exit(child_status);
+		}
 	}
 
 	/* Detach ourself from the calling environment */
@@ -646,6 +747,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 
 		/* If the client went away in mid command then tidy up */
 		if (thisfd->bits.localsock.in_progress) {
+			pthread_kill(thisfd->bits.localsock.threadid, SIGUSR2);
 			pthread_mutex_lock(&thisfd->bits.localsock.mutex);
 			thisfd->bits.localsock.state = POST_COMMAND;
 			pthread_cond_signal(&thisfd->bits.localsock.cond);
@@ -659,10 +761,9 @@ static int read_from_local_sock(struct local_client *thisfd)
 		if (thisfd->bits.localsock.threadid) {
 			DEBUGLOG("Waiting for child thread\n");
 			pthread_mutex_lock(&thisfd->bits.localsock.mutex);
-			thisfd->bits.localsock.state = POST_COMMAND;
+			thisfd->bits.localsock.state = PRE_COMMAND;
 			pthread_cond_signal(&thisfd->bits.localsock.cond);
 			pthread_mutex_unlock(&thisfd->bits.localsock.mutex);
-			pthread_kill(thisfd->bits.localsock.threadid, SIGUSR2);
 
 			jstat =
 			    pthread_join(thisfd->bits.localsock.threadid,
@@ -717,6 +818,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 		struct local_client *newfd;
 		char csid[MAX_CSID_LEN];
 		struct clvm_header *inheader;
+		int status;
 
 		inheader = (struct clvm_header *) buffer;
 
@@ -727,7 +829,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 		if (thisfd->bits.localsock.in_progress) {
 			struct clvm_header reply;
 			reply.cmd = CLVMD_CMD_REPLY;
-			reply.status = -EBUSY;
+			reply.status = EBUSY;
 			reply.arglen = 0;
 			reply.flags = 0;
 			send_message(&reply, sizeof(reply), our_csid,
@@ -750,7 +852,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 		if (!thisfd->bits.localsock.cmd) {
 			struct clvm_header reply;
 			reply.cmd = CLVMD_CMD_REPLY;
-			reply.status = -ENOMEM;
+			reply.status = ENOMEM;
 			reply.arglen = 0;
 			reply.flags = 0;
 			send_message(&reply, sizeof(reply), our_csid,
@@ -791,13 +893,13 @@ static int read_from_local_sock(struct local_client *thisfd)
 		}
 
 		/* Check the node name for validity */
-		if (inheader->node[0] && csid_from_name(csid, inheader->node)) {
+		if (inheader->node[0] && clops->csid_from_name(csid, inheader->node)) {
 			/* Error, node is not in the cluster */
 			struct clvm_header reply;
 			DEBUGLOG("Unknown node: '%s'\n", inheader->node);
 
 			reply.cmd = CLVMD_CMD_REPLY;
-			reply.status = -ENOENT;
+			reply.status = ENOENT;
 			reply.flags = 0;
 			reply.arglen = 0;
 			send_message(&reply, sizeof(reply), our_csid,
@@ -828,7 +930,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 			close(comms_pipe[1]);
 
 			reply.cmd = CLVMD_CMD_REPLY;
-			reply.status = -ENOMEM;
+			reply.status = ENOMEM;
 			reply.arglen = 0;
 			reply.flags = 0;
 			send_message(&reply, sizeof(reply), our_csid,
@@ -839,6 +941,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 		DEBUGLOG("creating pipe, [%d, %d]\n", comms_pipe[0],
 			 comms_pipe[1]);
 		newfd->fd = comms_pipe[0];
+		newfd->removeme = 0;
 		newfd->type = THREAD_PIPE;
 		newfd->callback = local_pipe_callback;
 		newfd->next = thisfd->next;
@@ -863,8 +966,10 @@ static int read_from_local_sock(struct local_client *thisfd)
 		/* Run the pre routine */
 		thisfd->bits.localsock.in_progress = TRUE;
 		thisfd->bits.localsock.state = PRE_COMMAND;
-		pthread_create(&thisfd->bits.localsock.threadid, NULL,
+		DEBUGLOG("Creating pre&post thread\n");
+		status = pthread_create(&thisfd->bits.localsock.threadid, NULL,
 			       pre_and_post_thread, thisfd);
+		DEBUGLOG("Created pre&post thread, state = %d\n", status);
 	}
 	return len;
 }
@@ -921,7 +1026,7 @@ static int distribute_command(struct local_client *thisfd)
 		/* if node is empty then do it on the whole cluster */
 		if (inheader->node[0] == '\0') {
 			thisfd->bits.localsock.expected_replies =
-			    get_num_nodes();
+			    clops->get_num_nodes();
 			thisfd->bits.localsock.num_replies = 0;
 			thisfd->bits.localsock.sent_time = time(NULL);
 			thisfd->bits.localsock.in_progress = TRUE;
@@ -942,7 +1047,7 @@ static int distribute_command(struct local_client *thisfd)
                         /* Do it on a single node */
 			char csid[MAX_CSID_LEN];
 
-			if (csid_from_name(csid, inheader->node)) {
+			if (clops->csid_from_name(csid, inheader->node)) {
 				/* This has already been checked so should not happen */
 				return 0;
 			} else {
@@ -952,7 +1057,7 @@ static int distribute_command(struct local_client *thisfd)
 				thisfd->bits.localsock.in_progress = TRUE;
 
 				/* Are we the requested node ?? */
-				if (memcmp(csid, our_csid, MAX_CSID_LEN) == 0) {
+				if (memcmp(csid, our_csid, max_csid_len) == 0) {
 					DEBUGLOG("Doing command on local node only\n");
 					add_to_lvmqueue(thisfd, inheader, len, NULL);
 				} else {
@@ -984,17 +1089,17 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 			    char *csid)
 {
 	char *replyargs;
-	char nodename[MAX_CLUSTER_MEMBER_NAME_LEN];
+	char nodename[max_cluster_member_name_len];
 	int replylen = 0;
-	int buflen = MAX_CLUSTER_MESSAGE - sizeof(struct clvm_header) - 1;
+	int buflen = max_cluster_message - sizeof(struct clvm_header) - 1;
 	int status;
 	int msg_malloced = 0;
 
 	/* Get the node name as we /may/ need it later */
-	name_from_csid(csid, nodename);
+	clops->name_from_csid(csid, nodename);
 
-	DEBUGLOG("process_remote_command %d for clientid 0x%x on node %s\n",
-		 msg->cmd, msg->clientid, nodename);
+	DEBUGLOG("process_remote_command %d for clientid 0x%x XID %d on node %s\n",
+		 msg->cmd, msg->clientid, msg->xid, nodename);
 
 	/* Is the data to be found in the system LV ? */
 	if (msg->flags & CLVMD_FLAG_SYSTEMLV) {
@@ -1016,7 +1121,7 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 
 				/* Return a failure response */
 				head.cmd = CLVMD_CMD_REPLY;
-				head.status = -EFBIG;
+				head.status = EFBIG;
 				head.flags = 0;
 				head.clientid = msg->clientid;
 				head.arglen = 0;
@@ -1033,7 +1138,7 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 			     msg->arglen);
 			/* Return a failure response */
 			head.cmd = CLVMD_CMD_REPLY;
-			head.status = -ENOMEM;
+			head.status = ENOMEM;
 			head.flags = 0;
 			head.clientid = msg->clientid;
 			head.arglen = 0;
@@ -1057,7 +1162,7 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 	if (msg->cmd == CLVMD_CMD_VERSION) {
 		int *version_nums = (int *) msg->args;
 		char node[256];
-		name_from_csid(csid, node);
+		clops->name_from_csid(csid, node);
 		DEBUGLOG("Remote node %s is version %d.%d.%d\n",
 			 node,
 			 ntohl(version_nums[0]),
@@ -1078,17 +1183,17 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 			byebyemsg.flags = 0;
 			byebyemsg.arglen = 0;
 			byebyemsg.clientid = 0;
-			cluster_send_message(&byebyemsg, sizeof(byebyemsg),
+			clops->cluster_send_message(&byebyemsg, sizeof(byebyemsg),
 					     our_csid,
 					     "Error Sending GOAWAY message");
 		} else {
-			add_up_node(csid);
+			clops->add_up_node(csid);
 		}
 		return;
 	}
 
 	/* Allocate a default reply buffer */
-	replyargs = malloc(MAX_CLUSTER_MESSAGE - sizeof(struct clvm_header));
+	replyargs = malloc(max_cluster_message - sizeof(struct clvm_header));
 
 	if (replyargs != NULL) {
 		/* Run the command */
@@ -1096,7 +1201,7 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 		    do_command(NULL, msg, msglen, &replyargs, buflen,
 			       &replylen);
 	} else {
-		status = -ENOMEM;
+		status = ENOMEM;
 	}
 
 	/* If it wasn't a reply, then reply */
@@ -1127,11 +1232,10 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 
 				/* If System LV operation failed then report it as EFBIG but only do it
 				   if the data buffer has something in it. */
-				if (system_lv_write_data
-				    (aggreply,
-				     replylen + sizeof(struct clvm_header)) < 0
+				if (system_lv_write_data(aggreply,
+							 replylen + sizeof(struct clvm_header)) < 0
 				    && replylen > 0)
-					agghead->status = -EFBIG;
+					agghead->status = EFBIG;
 
 				send_message(agghead,
 					     sizeof(struct clvm_header), csid,
@@ -1147,7 +1251,7 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 				agghead->node[0] = '\0';
 				send_message(aggreply,
 					     sizeof(struct clvm_header) +
-					     replylen + 2, csid, fd,
+					     replylen, csid, fd,
 					     "Error sending command reply");
 			}
 		} else {
@@ -1156,7 +1260,7 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 			DEBUGLOG("Error attempting to realloc return buffer\n");
 			/* Return a failure response */
 			head.cmd = CLVMD_CMD_REPLY;
-			head.status = -ENOMEM;
+			head.status = ENOMEM;
 			head.flags = 0;
 			head.clientid = msg->clientid;
 			head.arglen = 0;
@@ -1188,13 +1292,13 @@ static void add_reply_to_list(struct local_client *client, int status,
 	reply = malloc(sizeof(struct node_reply));
 	if (reply) {
 		reply->status = status;
-		name_from_csid(csid, reply->node);
+		clops->name_from_csid(csid, reply->node);
 		DEBUGLOG("Reply from node %s: %d bytes\n", reply->node, len);
 
 		if (len > 0) {
 			reply->replymsg = malloc(len);
 			if (!reply->replymsg) {
-				reply->status = -ENOMEM;
+				reply->status = ENOMEM;
 			} else {
 				memcpy(reply->replymsg, buf, len);
 			}
@@ -1238,6 +1342,11 @@ static void *pre_and_post_thread(void *arg)
 
 	DEBUGLOG("in sub thread: client = %p\n", client);
 
+	/* Don't start until the LVM thread is ready */
+	pthread_mutex_lock(&lvm_start_mutex);
+	pthread_mutex_unlock(&lvm_start_mutex);
+	DEBUGLOG("Sub thread ready for work.\n");
+
 	/* Ignore SIGUSR1 (handled by master process) but enable
 	   SIGUSR2 (kills subthreads) */
 	sigemptyset(&ss);
@@ -1273,13 +1382,12 @@ static void *pre_and_post_thread(void *arg)
 
 		DEBUGLOG("Got post command condition...\n");
 
+		/* POST function must always run, even if the client aborts */
+		status = 0;
 		do_post_command(client);
 
 		write(pipe_fd, &status, sizeof(int));
 
-		if (client->bits.localsock.finished)
-			break;
-
 		DEBUGLOG("Waiting for next pre command\n");
 
 		pthread_mutex_lock(&client->bits.localsock.mutex);
@@ -1292,7 +1400,8 @@ static void *pre_and_post_thread(void *arg)
 		DEBUGLOG("Got pre command condition...\n");
 	}
 	DEBUGLOG("Subthread finished\n");
-	return (void *) 0;
+	pthread_exit((void *) 0);
+	return 0;
 }
 
 /* Process a command on the local node and store the result */
@@ -1300,8 +1409,8 @@ static int process_local_command(struct clvm_header *msg, int msglen,
 				 struct local_client *client,
 				 unsigned short xid)
 {
-	char *replybuf = malloc(MAX_CLUSTER_MESSAGE);
-	int buflen = MAX_CLUSTER_MESSAGE - sizeof(struct clvm_header) - 1;
+	char *replybuf = malloc(max_cluster_message);
+	int buflen = max_cluster_message - sizeof(struct clvm_header) - 1;
 	int replylen = 0;
 	int status;
 
@@ -1383,9 +1492,10 @@ static void send_local_reply(struct local_client *client, int status, int fd)
 	replybuf = malloc(message_len);
 
 	clientreply = (struct clvm_header *) replybuf;
-	clientreply->status = -status;
+	clientreply->status = status;
 	clientreply->cmd = CLVMD_CMD_REPLY;
 	clientreply->node[0] = '\0';
+	clientreply->flags = 0;
 
 	ptr = clientreply->args;
 
@@ -1397,6 +1507,9 @@ static void send_local_reply(struct local_client *client, int status, int fd)
 		strcpy(ptr, thisreply->node);
 		ptr += strlen(thisreply->node) + 1;
 
+		if (thisreply->status)
+			clientreply->flags |= CLVMD_FLAG_NODEERRS;
+
 		*(int *) ptr = thisreply->status;
 		ptr += sizeof(int);
 
@@ -1465,7 +1578,8 @@ static void send_version_message()
 	version_nums[1] = htonl(CLVMD_MINOR_VERSION);
 	version_nums[2] = htonl(CLVMD_PATCH_VERSION);
 
-	cluster_send_message(message, sizeof(message), NULL,
+	hton_clvm(msg);
+	clops->cluster_send_message(message, sizeof(message), NULL,
 			     "Error Sending version number");
 }
 
@@ -1477,8 +1591,8 @@ static int send_message(void *buf, int msglen, char *csid, int fd,
 
 	/* Send remote messages down the cluster socket */
 	if (csid == NULL || !ISLOCAL_CSID(csid)) {
-		hton_clvm((struct clvm_header *) buf);	/* Byte swap if necessary */
-		return cluster_send_message(buf, msglen, csid, errtext);
+		hton_clvm((struct clvm_header *) buf);
+		return clops->cluster_send_message(buf, msglen, csid, errtext);
 	} else {
 		int ptr = 0;
 
@@ -1498,6 +1612,14 @@ static int send_message(void *buf, int msglen, char *csid, int fd,
 
 static int process_work_item(struct lvm_thread_cmd *cmd)
 {
+	/* If msg is NULL then this is a cleanup request */
+	if (cmd->msg == NULL) {
+		DEBUGLOG("process_work_item: free fd %d\n", cmd->client->fd);
+		cmd_client_cleanup(cmd->client);
+		free(cmd->client);
+		return 0;
+	}
+
 	if (!cmd->remote) {
 		DEBUGLOG("process_work_item: local\n");
 		process_local_command(cmd->msg, cmd->msglen, cmd->client,
@@ -1517,9 +1639,12 @@ static void *lvm_thread_fn(void *arg)
 {
 	struct list *cmdl, *tmp;
 	sigset_t ss;
+	int using_gulm = (int)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");
-	pthread_mutex_lock(&lvm_thread_mutex);
 
 	/* Ignore SIGUSR1 & 2 */
 	sigemptyset(&ss);
@@ -1528,8 +1653,10 @@ static void *lvm_thread_fn(void *arg)
 	pthread_sigmask(SIG_BLOCK, &ss, NULL);
 
 	/* Initialise the interface to liblvm */
-	init_lvm();
-	pthread_mutex_unlock(&lvm_thread_mutex);
+	init_lvm(using_gulm);
+
+	/* Allow others to get moving */
+	pthread_mutex_unlock(&lvm_start_mutex);
 
 	/* Now wait for some actual work */
 	for (;;) {
@@ -1548,7 +1675,8 @@ static void *lvm_thread_fn(void *arg)
 			pthread_mutex_unlock(&lvm_thread_mutex);
 
 			process_work_item(cmd);
-			free(cmd->msg);
+			if (cmd->msg)
+				free(cmd->msg);
 			free(cmd);
 
 			pthread_mutex_lock(&lvm_thread_mutex);
@@ -1565,21 +1693,26 @@ static int add_to_lvmqueue(struct local_client *client, struct clvm_header *msg,
 
 	cmd = malloc(sizeof(struct lvm_thread_cmd));
 	if (!cmd)
-		return -ENOMEM;
+		return ENOMEM;
 
-	cmd->msg = malloc(msglen);
-	if (!cmd->msg) {
-		log_error("Unable to allocate buffer space\n");
-		free(cmd);
-		return -1;
+	if (msglen) {
+		cmd->msg = malloc(msglen);
+		if (!cmd->msg) {
+			log_error("Unable to allocate buffer space\n");
+			free(cmd);
+			return -1;
+		}
+		memcpy(cmd->msg, msg, msglen);
+	}
+	else {
+		cmd->msg = NULL;
 	}
-
 	cmd->client = client;
 	cmd->msglen = msglen;
 	cmd->xid = client->xid;
-	memcpy(cmd->msg, msg, msglen);
+
 	if (csid) {
-		memcpy(cmd->csid, csid, MAX_CSID_LEN);
+		memcpy(cmd->csid, csid, max_csid_len);
 		cmd->remote = 1;
 	} else {
 		cmd->remote = 0;
@@ -1610,6 +1743,8 @@ static int open_local_sock()
 		log_error("Can't create local socket: %m");
 		return -1;
 	}
+	/* Set Close-on-exec */
+	fcntl(local_socket, F_SETFD, 1);
 
 	memset(&sockaddr, 0, sizeof(sockaddr));
 	memcpy(sockaddr.sun_path, CLVMD_SOCKNAME, sizeof(CLVMD_SOCKNAME));
@@ -1630,11 +1765,24 @@ static int open_local_sock()
 	return local_socket;
 }
 
+void process_message(struct local_client *client, char *buf, int len, char *csid)
+{
+	struct clvm_header *inheader;
+
+	inheader = (struct clvm_header *) buf;
+	ntoh_clvm(inheader);	/* Byteswap fields */
+	if (inheader->cmd == CLVMD_CMD_REPLY)
+		process_reply(inheader, len, csid);
+	else
+		add_to_lvmqueue(client, inheader, len, csid);
+}
+
+
 static void check_all_callback(struct local_client *client, char *csid,
 			       int node_up)
 {
 	if (!node_up)
-		add_reply_to_list(client, -EHOSTDOWN, csid, "CLVMD not running",
+		add_reply_to_list(client, EHOSTDOWN, csid, "CLVMD not running",
 				  18);
 }
 
@@ -1644,7 +1792,7 @@ static void check_all_callback(struct local_client *client, char *csid,
 static int check_all_clvmds_running(struct local_client *client)
 {
 	DEBUGLOG("check_all_clvmds_running\n");
-	return cluster_do_node_callback(client, check_all_callback);
+	return clops->cluster_do_node_callback(client, check_all_callback);
 }
 
 /* Return a local_client struct given a client ID.
@@ -1681,7 +1829,6 @@ static void ntoh_clvm(struct clvm_header *hdr)
 static void sigusr2_handler(int sig)
 {
 	DEBUGLOG("SIGUSR2 received\n");
-	pthread_exit((void *) -1);
 	return;
 }
 
@@ -1691,3 +1838,20 @@ static void sigterm_handler(int sig)
 	quit = 1;
 	return;
 }
+
+static void sighup_handler(int sig)
+{
+        DEBUGLOG("got SIGHUP\n");
+	reread_config = 1;
+}
+
+int sync_lock(const char *resource, int mode, int flags, int *lockid)
+{
+	return clops->sync_lock(resource, mode, flags, lockid);
+}
+
+int sync_unlock(const char *resource, int lockid)
+{
+	return clops->sync_unlock(resource, lockid);
+}
+

daemons/clvmd/clvmd.h

@@ -86,6 +86,7 @@ struct local_client {
 	struct local_client *next;
 	unsigned short xid;
 	fd_callback_t callback;
+	uint8_t removeme;
 
 	union {
 		struct localsock_bits localsock;
@@ -95,7 +96,7 @@ struct local_client {
 };
 
 #ifdef DEBUG
-#define DEBUGLOG(fmt, args...) fprintf(stderr, "CLVMD[%d]: %ld ", getpid(), time(NULL) ); fprintf(stderr, fmt, ## args)
+#define DEBUGLOG(fmt, args...) {time_t P; time(&P); fprintf(stderr, "CLVMD[%x]: %.15s ", (int)pthread_self(), ctime(&P)+4 ); fprintf(stderr, fmt, ## args);}
 #else
 #define DEBUGLOG(fmt, args...)
 #endif
@@ -111,9 +112,13 @@ extern int do_command(struct local_client *client, struct clvm_header *msg,
 /* Pre and post command routines are called only on the local node */
 extern int do_pre_command(struct local_client *client);
 extern int do_post_command(struct local_client *client);
-
+extern void cmd_client_cleanup(struct local_client *client);
 extern int add_client(struct local_client *new_client);
 
 extern void clvmd_cluster_init_completed(void);
+extern void process_message(struct local_client *client, char *buf, int len, char *csid);
+
+int sync_lock(const char *resource, int mode, int flags, int *lockid);
+int sync_unlock(const char *resource, int lockid);
 
 #endif

daemons/clvmd/cnxman-socket.h

@@ -63,8 +63,8 @@
 
 
 /* Maximum size of a cluster message */
-#define MAX_CLUSTER_MESSAGE          1500
-#define MAX_CLUSTER_MEMBER_NAME_LEN   255
+#define CMAN_MAX_CLUSTER_MESSAGE          1500
+#define CMAN_MAX_CLUSTER_MEMBER_NAME_LEN   255
 #define MAX_BARRIER_NAME_LEN           33
 #define MAX_SA_ADDR_LEN                12
 #define MAX_CLUSTER_NAME_LEN           16
@@ -105,6 +105,7 @@
 #define MSG_MULTICAST 0x080000	/* Message was sent to all nodes in the cluster
 				 */
 #define MSG_ALLINT    0x100000	/* Send out of all interfaces */
+#define MSG_REPLYEXP  0x200000	/* Reply is expected */
 
 typedef enum { NODESTATE_REMOTEMEMBER, NODESTATE_JOINING, NODESTATE_MEMBER,
 	       NODESTATE_DEAD } nodestate_t;
@@ -146,7 +147,7 @@ struct cl_cluster_node {
 	unsigned int leave_reason;
 	unsigned int incarnation;
 	nodestate_t state;
-	char name[MAX_CLUSTER_MEMBER_NAME_LEN];
+	char name[CMAN_MAX_CLUSTER_MEMBER_NAME_LEN];
 	unsigned char votes;
 };
 

daemons/clvmd/libclvm.c

@@ -1,446 +0,0 @@
-/*
- * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004 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
- */
-
-/* library functions for Cluster LVM Daemon */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/socket.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <sys/time.h>
-#include <sys/ioctl.h>
-#include <sys/utsname.h>
-#include <syslog.h>
-#include <netinet/in.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <signal.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <search.h>
-#include <errno.h>
-
-#include "clvm.h"
-#include "libclvm.h"
-
-/* CLVM in hex! */
-#define LVM_SIGNATURE 0x434C564D
-
-#define MAX_CLUSTER_MEMBER_NAME_LEN 255
-
-/* NOTE: the LVMD uses the socket FD as the client ID, this means
-   that any client that calls fork() will inherit the context of
-   it's parent. */
-static int clvmd_sock = -1;
-
-static int open_local_sock(void)
-{
-	int local_socket;
-	struct sockaddr_un sockaddr;
-
-	/* Open local socket */
-	local_socket = socket(PF_UNIX, SOCK_STREAM, 0);
-	if (local_socket < 0) {
-		perror("Can't create local socket");
-		return -1;
-	}
-
-	fcntl(local_socket, F_SETFD, !FD_CLOEXEC);
-
-	strcpy(sockaddr.sun_path, CLVMD_SOCKNAME);
-	sockaddr.sun_family = AF_UNIX;
-	if (connect
-	    (local_socket, (struct sockaddr *) &sockaddr, sizeof(sockaddr))) {
-		int saved_errno = errno;
-
-		close(local_socket);
-
-		errno = saved_errno;
-		return -1;
-	}
-	return local_socket;
-}
-
-/* Send a request and return the status */
-static int send_request(char *inbuf, int inlen, char **retbuf)
-{
-	char outbuf[PIPE_BUF];
-	struct clvm_header *outheader = (struct clvm_header *) outbuf;
-	int len;
-	int off;
-	fd_set fds;
-
-	FD_ZERO(&fds);
-	FD_SET(clvmd_sock, &fds);
-
-	/* Send it to CLVMD */
-	if (write(clvmd_sock, inbuf, inlen) != inlen) {
-		perror("Error writing to CLVMD");
-		return -1;
-	}
-
-	/* Get the response */
-	if ((len = read(clvmd_sock, outbuf, sizeof(struct clvm_header))) < 0) {
-		perror("Error reading CLVMD");
-		return -1;
-	}
-	if (len == 0) {
-		fprintf(stderr, "EOF reading CLVMD");
-		errno = ENOTCONN;
-		return -1;
-	}
-
-	/* Allocate buffer */
-	*retbuf = malloc(len + outheader->arglen);
-	if (!*retbuf) {
-		errno = ENOMEM;
-		return -1;
-	}
-
-	/* Copy the header */
-	memcpy(*retbuf, outbuf, len);
-	outheader = (struct clvm_header *) *retbuf;
-
-	/* Read the returned values */
-	off = 1;		/* we've already read the first byte */
-
-	while (off < outheader->arglen && len > 0) {
-		len = read(clvmd_sock, outheader->args + off, PIPE_BUF);
-		if (len > 0)
-			off += len;
-	}
-
-	/* Was it an error ? */
-	if (outheader->status < 0) {
-		errno = -outheader->status;
-		return -2;
-	}
-	return 0;
-}
-
-/* Build the structure header and parse-out wildcard node names */
-static void build_header(struct clvm_header *head, int cmd, const char *node,
-			 void *data, int len)
-{
-	head->cmd = cmd;
-	head->status = 0;
-	head->flags = 0;
-	head->clientid = 0;
-	head->arglen = len;
-	if (node) {
-		/* Allow a couple of special node names:
-		   "*" for all nodes,
-		   "." for the local node only
-		 */
-		if (strcmp(node, "*") == 0) {
-			head->node[0] = '\0';
-		} else if (strcmp(node, ".") == 0) {
-			head->node[0] = '\0';
-			head->flags = CLVMD_FLAG_LOCAL;
-		} else {
-			strcpy(head->node, node);
-		}
-	} else {
-		head->node[0] = '\0';
-	}
-}
-
-/* Send a message to a(or all) node(s) in the cluster */
-int lvm_cluster_write(char cmd, char *node, void *data, int len)
-{
-	char outbuf[sizeof(struct clvm_header) + len + strlen(node) + 1];
-	char *retbuf = NULL;
-	int status;
-	struct clvm_header *head = (struct clvm_header *) outbuf;
-
-	if (clvmd_sock == -1)
-		clvmd_sock = open_local_sock();
-	if (clvmd_sock == -1)
-		return -1;
-
-	build_header(head, cmd, node, data, len);
-	memcpy(head->node + strlen(head->node) + 1, data, len);
-
-	status =
-	    send_request(outbuf,
-			 sizeof(struct clvm_header) + strlen(head->node) + len,
-			 &retbuf);
-	if (retbuf)
-		free(retbuf);
-
-	return status;
-}
-
-/* API: Send a message to a(or all) node(s) in the cluster
-   and wait for replies */
-int lvm_cluster_request(char cmd, const char *node, void *data, int len,
-			lvm_response_t ** response, int *num)
-{
-	char outbuf[sizeof(struct clvm_header) + len + strlen(node) + 1];
-	int *outptr;
-	char *inptr;
-	char *retbuf = NULL;
-	int status;
-	int i;
-	int num_responses = 0;
-	struct clvm_header *head = (struct clvm_header *) outbuf;
-	lvm_response_t *rarray;
-
-	*num = 0;
-
-	if (clvmd_sock == -1)
-		clvmd_sock = open_local_sock();
-	if (clvmd_sock == -1)
-		return -1;
-
-	build_header(head, cmd, node, data, len);
-	memcpy(head->node + strlen(head->node) + 1, data, len);
-
-	status =
-	    send_request(outbuf,
-			 sizeof(struct clvm_header) + strlen(head->node) + len,
-			 &retbuf);
-	if (status == 0 || status == -2) {
-		/* Count the number of responses we got */
-		head = (struct clvm_header *) retbuf;
-		inptr = head->args;
-		while (inptr[0]) {
-			num_responses++;
-			inptr += strlen(inptr) + 1;
-			inptr += sizeof(int);
-			inptr += strlen(inptr) + 1;
-		}
-
-		/* Allocate response array. With an extra pair of INTs on the front to sanity
-		   check the pointer when we are given it back to free */
-		outptr =
-		    malloc(sizeof(lvm_response_t) * num_responses +
-			   sizeof(int) * 2);
-		if (!outptr) {
-			if (retbuf)
-				free(retbuf);
-			errno = ENOMEM;
-			return -1;
-		}
-
-		*response = (lvm_response_t *) (outptr + 2);
-		outptr[0] = LVM_SIGNATURE;
-		outptr[1] = num_responses;
-		rarray = *response;
-
-		/* Unpack the response into an lvm_response_t array */
-		inptr = head->args;
-		i = 0;
-		while (inptr[0]) {
-			strcpy(rarray[i].node, inptr);
-			inptr += strlen(inptr) + 1;
-
-			rarray[i].status = *(int *) inptr;
-			inptr += sizeof(int);
-
-			rarray[i].response = malloc(strlen(inptr) + 1);
-			if (rarray[i].response == NULL) {
-				/* Free up everything else and return error */
-				int j;
-				for (j = 0; j < i; j++)
-					free(rarray[i].response);
-				free(outptr);
-				errno = ENOMEM;
-				return -1;
-			}
-
-			strcpy(rarray[i].response, inptr);
-			rarray[i].len = strlen(inptr);
-			inptr += strlen(inptr) + 1;
-			i++;
-		}
-		*num = num_responses;
-		*response = rarray;
-	}
-
-	if (retbuf)
-		free(retbuf);
-	return status;
-}
-
-/* API: Free reply array */
-int lvm_cluster_free_request(lvm_response_t * response)
-{
-	int *ptr = (int *) response - 2;
-	int i;
-	int num;
-
-	/* Check it's ours to free */
-	if (response == NULL || *ptr != LVM_SIGNATURE) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	num = ptr[1];
-	for (i = 0; i < num; i++) {
-		free(response[i].response);
-	}
-	free(ptr);
-
-	return 0;
-}
-
-/* These are a "higher-level" API providing black-box lock/unlock
-   functions for cluster LVM...maybe */
-
-/* Set by lock(), used by unlock() */
-static int num_responses;
-static lvm_response_t *response;
-
-int lvm_lock_for_cluster(char scope, char *name, int verbosity)
-{
-	int status;
-	int i;
-	char *args;
-	int len;
-
-	if (name) {
-		len = strlen(name) + 2;
-		args = alloca(len);
-		strcpy(args + 1, name);
-	} else {
-		len = 2;
-		args = alloca(len);
-		args[1] = '\0';
-	}
-	args[0] = scope;
-
-	status = lvm_cluster_request(CLVMD_CMD_LOCK,
-				     "", args, len, &response, &num_responses);
-
-	/* If any nodes were down then display them and return an error */
-	for (i = 0; i < num_responses; i++) {
-		if (response[i].status == -EHOSTDOWN) {
-			if (verbosity)
-				fprintf(stderr,
-					"clvmd not running on node %s\n",
-					response[i].node);
-			status = -1;
-		}
-	}
-
-	/* If there was an error then free the memory now as the caller won't
-	   want to do the unlock */
-	if (status) {
-		int saved_errno = errno;
-		lvm_cluster_free_request(response);
-		num_responses = 0;
-		errno = saved_errno;
-	}
-	return status;
-}
-
-int lvm_unlock_for_cluster(char scope, char *name, int verbosity)
-{
-	int status;
-	int i;
-	int len;
-	int failed;
-	int num_unlock_responses;
-	char *args;
-	lvm_response_t *unlock_response;
-
-	/* We failed - this should not have been called */
-	if (num_responses == 0)
-		return 0;
-
-	if (name) {
-		len = strlen(name) + 2;
-		args = alloca(len);
-		strcpy(args + 1, name);
-	} else {
-		len = 2;
-		args = alloca(len);
-		args[1] = '\0';
-	}
-	args[0] = scope;
-
-	/* See if it failed anywhere */
-	failed = 0;
-	for (i = 0; i < num_responses; i++) {
-		if (response[i].status != 0)
-			failed++;
-	}
-
-	/* If it failed on any nodes then we only unlock on
-	   the nodes that succeeded */
-	if (failed) {
-		for (i = 0; i < num_responses; i++) {
-			/* Unlock the ones that succeeded */
-			if (response[i].status == 0) {
-				status = lvm_cluster_request(CLVMD_CMD_UNLOCK,
-							     response[i].node,
-							     args, len,
-							     &unlock_response,
-							     &num_unlock_responses);
-				if (status) {
-					if (verbosity)
-						fprintf(stderr,
-							"cluster command to node %s failed: %s\n",
-							response[i].node,
-							strerror(errno));
-				} else if (unlock_response[0].status != 0) {
-					if (verbosity > 1)
-						fprintf(stderr,
-							"unlock on node %s failed: %s\n",
-							response[i].node,
-							strerror(unlock_response
-								 [0].status));
-				}
-				lvm_cluster_free_request(unlock_response);
-			} else {
-				if (verbosity)
-					fprintf(stderr,
-						"command on node %s failed: '%s' - will be left locked\n",
-						response[i].node,
-						strerror(response[i].status));
-			}
-		}
-	} else {
-		/* All OK, we can do a full cluster unlock */
-		status = lvm_cluster_request(CLVMD_CMD_UNLOCK,
-					     "",
-					     args, len,
-					     &unlock_response,
-					     &num_unlock_responses);
-		if (status) {
-			if (verbosity > 1)
-				fprintf(stderr, "cluster command failed: %s\n",
-					strerror(errno));
-		} else {
-			for (i = 0; i < num_unlock_responses; i++) {
-				if (unlock_response[i].status != 0) {
-					if (verbosity > 1)
-						fprintf(stderr,
-							"unlock on node %s failed: %s\n",
-							response[i].node,
-							strerror(unlock_response
-								 [0].status));
-				}
-			}
-		}
-		lvm_cluster_free_request(unlock_response);
-	}
-	lvm_cluster_free_request(response);
-
-	return 0;
-}

daemons/clvmd/libclvm.h

@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004 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
- */
-
-#ifndef _LIBCLVM_H
-#define _LIBCLVM_H
-
-typedef struct lvm_response {
-	char node[255];
-	char *response;
-	int status;
-	int len;
-
-} lvm_response_t;
-
-extern int lvm_cluster_request(char cmd, const char *node, void *data, int len,
-			       lvm_response_t ** response, int *num);
-extern int lvm_cluster_write(char cmd, char *node, void *data, int len);
-extern int lvm_cluster_free_request(lvm_response_t * response);
-
-/* The "high-level" API */
-extern int lvm_lock_for_cluster(char scope, char *name, int verbosity);
-extern int lvm_unlock_for_cluster(char scope, char *name, int verbosity);
-
-#endif

daemons/clvmd/lvm-functions.c

@@ -31,6 +31,9 @@
 #include <syslog.h>
 #include <assert.h>
 
+#include "libdevmapper.h"
+#include "list.h"
+#include "lvm-types.h"
 #include "libdlm.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
@@ -41,11 +44,11 @@
 #include "toolcontext.h"
 #include "log.h"
 #include "activate.h"
-#include "hash.h"
 #include "locking.h"
 
 static struct cmd_context *cmd = NULL;
-static struct hash_table *lv_hash = NULL;
+static struct dm_hash_table *lv_hash = NULL;
+static pthread_mutex_t lv_hash_lock;
 
 struct lv_info {
 	int lock_id;
@@ -57,7 +60,9 @@ static int get_current_lock(char *resource)
 {
 	struct lv_info *lvi;
 
-	lvi = hash_lookup(lv_hash, resource);
+	pthread_mutex_lock(&lv_hash_lock);
+	lvi = dm_hash_lookup(lv_hash, resource);
+	pthread_mutex_unlock(&lv_hash_lock);
 	if (lvi) {
 		return lvi->lock_mode;
 	} else {
@@ -68,12 +73,15 @@ static int get_current_lock(char *resource)
 /* Called at shutdown to tidy the lockspace */
 void unlock_all()
 {
-	struct hash_node *v;
-	hash_iterate(v, lv_hash) {
-		struct lv_info *lvi = hash_get_data(lv_hash, v);
+	struct dm_hash_node *v;
 
-		sync_unlock(hash_get_key(lv_hash, v), lvi->lock_id);
+	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);
 	}
+	pthread_mutex_unlock(&lv_hash_lock);
 }
 
 /* Gets a real lock and keeps the info in the hash table */
@@ -85,7 +93,9 @@ int hold_lock(char *resource, int mode, int flags)
 
 	flags &= LKF_NOQUEUE;	/* Only LKF_NOQUEUE is valid here */
 
-	lvi = hash_lookup(lv_hash, resource);
+	pthread_mutex_lock(&lv_hash_lock);
+	lvi = dm_hash_lookup(lv_hash, resource);
+	pthread_mutex_unlock(&lv_hash_lock);
 	if (lvi) {
 		/* Already exists - convert it */
 		status =
@@ -113,7 +123,9 @@ int hold_lock(char *resource, int mode, int flags)
 			DEBUGLOG("hold_lock. lock at %d failed: %s\n", mode,
 				 strerror(errno));
 		} else {
-			hash_insert(lv_hash, resource, lvi);
+		        pthread_mutex_lock(&lv_hash_lock);
+			dm_hash_insert(lv_hash, resource, lvi);
+			pthread_mutex_unlock(&lv_hash_lock);
 		}
 		errno = saved_errno;
 	}
@@ -127,8 +139,9 @@ int hold_unlock(char *resource)
 	int status;
 	int saved_errno;
 
-	lvi = hash_lookup(lv_hash, resource);
-
+	pthread_mutex_lock(&lv_hash_lock);
+	lvi = dm_hash_lookup(lv_hash, resource);
+	pthread_mutex_unlock(&lv_hash_lock);
 	if (!lvi) {
 		DEBUGLOG("hold_unlock, lock not already held\n");
 		return 0;
@@ -137,7 +150,9 @@ int hold_unlock(char *resource)
 	status = sync_unlock(resource, lvi->lock_id);
 	saved_errno = errno;
 	if (!status) {
-		hash_remove(lv_hash, resource);
+	    	pthread_mutex_lock(&lv_hash_lock);
+		dm_hash_remove(lv_hash, resource);
+		pthread_mutex_unlock(&lv_hash_lock);
 		free(lvi);
 	} else {
 		DEBUGLOG("hold_unlock. unlock failed(%d): %s\n", status,
@@ -155,11 +170,12 @@ int hold_unlock(char *resource)
 */
 
 /* Activate LV exclusive or non-exclusive */
-static int do_activate_lv(char *resource, int mode)
+static int do_activate_lv(char *resource, unsigned char lock_flags, int mode)
 {
 	int oldmode;
 	int status;
 	int activate_lv;
+	int exclusive = 0;
 	struct lvinfo lvi;
 
 	/* Is it already open ? */
@@ -176,16 +192,20 @@ static int do_activate_lv(char *resource, int mode)
 		return 0;	/* Success, we did nothing! */
 
 	/* Do we need to activate exclusively? */
-	if (activate_lv == 2)
+	if ((activate_lv == 2) || (mode == LKM_EXMODE)) {
+		exclusive = 1;
 		mode = LKM_EXMODE;
+	}
 
-	/* OK, try to get the lock */
-	status = hold_lock(resource, mode, LKF_NOQUEUE);
-	if (status)
-		return errno;
+	/* Try to get the lock if it's a clustered volume group */
+	if (lock_flags & LCK_CLUSTER_VG) {
+		status = hold_lock(resource, mode, LKF_NOQUEUE);
+		if (status)
+			return errno;
+	}
 
 	/* If it's suspended then resume it */
-	if (!lv_info_by_lvid(cmd, resource, &lvi))
+	if (!lv_info_by_lvid(cmd, resource, &lvi, 0))
 		return EIO;
 
 	if (lvi.suspended)
@@ -193,7 +213,7 @@ static int do_activate_lv(char *resource, int mode)
 			return EIO;
 
 	/* Now activate it */
-	if (!lv_activate(cmd, resource))
+	if (!lv_activate(cmd, resource, exclusive))
 		return EIO;
 
 	return 0;
@@ -231,7 +251,7 @@ static int do_suspend_lv(char *resource)
 	}
 
 	/* Only suspend it if it exists */
-	if (!lv_info_by_lvid(cmd, resource, &lvi))
+	if (!lv_info_by_lvid(cmd, resource, &lvi, 0))
 		return EIO;
 
 	if (lvi.exists) {
@@ -242,14 +262,14 @@ static int do_suspend_lv(char *resource)
 	return 0;
 }
 
-static int do_deactivate_lv(char *resource)
+static int do_deactivate_lv(char *resource, unsigned char lock_flags)
 {
 	int oldmode;
 	int status;
 
 	/* Is it open ? */
 	oldmode = get_current_lock(resource);
-	if (oldmode == -1) {
+	if (oldmode == -1 && (lock_flags & LCK_CLUSTER_VG)) {
 		DEBUGLOG("do_deactivate_lock, lock not already held\n");
 		return 0;	/* We don't need to do anything */
 	}
@@ -257,9 +277,11 @@ static int do_deactivate_lv(char *resource)
 	if (!lv_deactivate(cmd, resource))
 		return EIO;
 
-	status = hold_unlock(resource);
-	if (status)
-		return errno;
+	if (lock_flags & LCK_CLUSTER_VG) {
+		status = hold_unlock(resource);
+		if (status)
+			return errno;
+	}
 
 	return 0;
 }
@@ -270,7 +292,7 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 {
 	int status = 0;
 
-	DEBUGLOG("do_lock_lv: resource '%s', cmd = 0x%x, flags = %d\n",
+	DEBUGLOG("do_lock_lv: resource '%s', cmd = 0x%x, flags = %x\n",
 		 resource, command, lock_flags);
 
 	if (!cmd->config_valid || config_files_changed(cmd)) {
@@ -283,7 +305,7 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 
 	switch (command) {
 	case LCK_LV_EXCLUSIVE:
-		status = do_activate_lv(resource, LKM_EXMODE);
+		status = do_activate_lv(resource, lock_flags, LKM_EXMODE);
 		break;
 
 	case LCK_LV_SUSPEND:
@@ -296,11 +318,11 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 		break;
 
 	case LCK_LV_ACTIVATE:
-		status = do_activate_lv(resource, LKM_CRMODE);
+		status = do_activate_lv(resource, lock_flags, LKM_CRMODE);
 		break;
 
 	case LCK_LV_DEACTIVATE:
-		status = do_deactivate_lv(resource);
+		status = do_deactivate_lv(resource, lock_flags);
 		break;
 
 	default:
@@ -310,7 +332,7 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 	}
 
 	/* clean the pool for another command */
-	pool_empty(cmd->mem);
+	dm_pool_empty(cmd->mem);
 
 	DEBUGLOG("Command return is %d\n", status);
 	return status;
@@ -350,7 +372,7 @@ int post_lock_lv(unsigned char command, unsigned char lock_flags,
 		if (oldmode == LKM_PWMODE) {
 			struct lvinfo lvi;
 
-			if (!lv_info_by_lvid(cmd, resource, &lvi))
+			if (!lv_info_by_lvid(cmd, resource, &lvi, 0))
 				return EIO;
 
 			if (lvi.exists) {
@@ -375,6 +397,44 @@ int do_check_lvm1(char *vgname)
 	return status == 1 ? 0 : EBUSY;
 }
 
+
+/* Only called at gulm startup. Drop any leftover VG or P_orphan locks
+   that might be hanging around if we died for any reason
+*/
+static void drop_vg_locks()
+{
+	char vg[128];
+	char line[255];
+	FILE *vgs =
+	    popen
+	    ("lvm pvs --nolocking --noheadings -o vg_name", "r");
+
+	sync_unlock("P_orphans", LCK_EXCL);
+
+	if (!vgs)
+		return;
+
+	while (fgets(line, sizeof(line), vgs)) {
+		char *vgend;
+		char *vgstart;
+
+		if (line[strlen(line)-1] == '\n')
+			line[strlen(line)-1] = '\0';
+
+		vgstart = line + strspn(line, " ");
+		vgend = vgstart + strcspn(vgstart, " ");
+		*vgend = '\0';
+
+		if (strncmp(vgstart, "WARNING:", 8) == 0)
+			continue;
+
+		sprintf(vg, "V_%s", vgstart);
+		sync_unlock(vg, LCK_EXCL);
+
+	}
+	fclose(vgs);
+}
+
 /*
  * Ideally, clvmd should be started before any LVs are active
  * but this may not be the case...
@@ -382,21 +442,24 @@ int do_check_lvm1(char *vgname)
  */
 static void *get_initial_state()
 {
-	char lv[64], vg[64], flags[25];
+	char lv[64], vg[64], flags[25], vg_flags[25];
 	char uuid[65];
 	char line[255];
 	FILE *lvs =
 	    popen
-	    ("/sbin/lvm lvs --nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr",
+	    ("lvm lvs --nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr,vg_attr",
 	     "r");
 
 	if (!lvs)
 		return NULL;
 
 	while (fgets(line, sizeof(line), lvs)) {
-		if (sscanf(line, "%s %s %s\n", vg, lv, flags) == 3) {
+	        if (sscanf(line, "%s %s %s %s\n", vg, lv, flags, vg_flags) == 4) {
+
 			/* States: s:suspended a:active S:dropped snapshot I:invalid snapshot */
-			if (flags[4] == 'a' || flags[4] == 's') {	/* is it active or suspended? */
+		        if (strlen(vg) == 38 &&                         /* is is a valid UUID ? */
+			    (flags[4] == 'a' || flags[4] == 's') &&	/* is it active or suspended? */
+			    vg_flags[5] == 'c') {			/* is it clustered ? */
 				/* Convert hyphen-separated UUIDs into one */
 				memcpy(&uuid[0], &vg[0], 6);
 				memcpy(&uuid[6], &vg[7], 4);
@@ -423,14 +486,39 @@ static void *get_initial_state()
 	return NULL;
 }
 
+/* This checks some basic cluster-LVM configuration stuff */
+static void check_config()
+{
+	int locking_type;
+
+	locking_type = find_config_int(cmd->cft->root, "global/locking_type", 1);
+
+	if (locking_type == 3) /* compiled-in cluster support */
+		return;
+
+	if (locking_type == 2) { /* External library, check name */
+		const char *libname;
+
+		libname = find_config_str(cmd->cft->root, "global/locking_library",
+					  "");
+		if (strstr(libname, "liblvm2clusterlock.so"))
+			return;
+
+		log_error("Incorrect LVM locking library specified in lvm.conf, cluster operations may not work.");
+		return;
+	}
+	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 = hash_create(100);
+	lv_hash = dm_hash_create(100);
+	pthread_mutex_init(&lv_hash_lock, NULL);
 }
 
 /* Called to initialise the LVM context of the daemon */
-int init_lvm(void)
+int init_lvm(int using_gulm)
 {
 	if (!(cmd = create_toolcontext(NULL))) {
 		log_error("Failed to allocate command context");
@@ -441,6 +529,13 @@ int init_lvm(void)
 	init_syslog(LOG_DAEMON);
 	init_debug(_LOG_ERR);
 
+	/* Check lvm.conf is setup for cluster-LVM */
+	check_config();
+
+	/* Remove any non-LV locks that may have been left around */
+	if (using_gulm)
+		drop_vg_locks();
+
 	get_initial_state();
 
 	return 1;

daemons/clvmd/lvm-functions.h

@@ -25,7 +25,7 @@ extern int do_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
 extern int post_lock_lv(unsigned char lock_cmd, unsigned char lock_flags,
 			char *resource);
 extern int do_check_lvm1(char *vgname);
-extern int init_lvm(void);
+extern int init_lvm(int using_gulm);
 extern void init_lvhash(void);
 
 extern int hold_unlock(char *resource);

daemons/clvmd/system-lv.c

@@ -42,7 +42,9 @@
 #include "list.h"
 #include "locking.h"
 #include "system-lv.h"
+#include "clvm.h"
 #include "clvmd-comms.h"
+#include "clvmd.h"
 #ifdef HAVE_CCS
 #include "ccs.h"
 #endif

daemons/clvmd/tcp-comms.c

@@ -2,6 +2,7 @@
 *******************************************************************************
 **
 **  Copyright (C) Sistina Software, Inc.  2002-2003  All rights reserved.
+**  Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
 **
 *******************************************************************************
 ******************************************************************************/
@@ -34,56 +35,31 @@
 #include <netdb.h>
 #include <assert.h>
 
-#include "ccs.h"
+#include "libdevmapper.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
 #include "clvmd.h"
 #include "clvmd-gulm.h"
-#include "hash.h"
 
 #define DEFAULT_TCP_PORT 21064
 
 static int listen_fd = -1;
 static int tcp_port;
-struct hash_table *sock_hash;
+struct dm_hash_table *sock_hash;
 
-static int get_tcp_port(int default_port);
 static int get_our_ip_address(char *addr, int *family);
 static int read_from_tcpsock(struct local_client *fd, char *buf, int len, char *csid,
 			     struct local_client **new_client);
 
 /* Called by init_cluster() to open up the listening socket */
-// TODO: IPv6 compat.
-int init_comms()
+int init_comms(unsigned short port)
 {
-    struct sockaddr *addr = NULL;
-    struct sockaddr_in addr4;
-    struct sockaddr_in6 addr6;
-    int    addr_len;
-    int    family;
-    char   address[MAX_CSID_LEN];
+    struct sockaddr_in6 addr;
 
-    sock_hash = hash_create(100);
-    tcp_port = get_tcp_port(DEFAULT_TCP_PORT);
+    sock_hash = dm_hash_create(100);
+    tcp_port = port ? port : DEFAULT_TCP_PORT;
 
-    /* Get IP address and IP type */
-    get_our_ip_address(address, &family);
-    if (family == AF_INET)
-    {
-	memcpy(&addr4.sin_addr, addr, sizeof(struct in_addr));
-	addr = (struct sockaddr *)&addr4;
-	addr4.sin_port = htons(tcp_port);
-	addr_len = sizeof(addr4);
-    }
-    else
-    {
-	memcpy(&addr6.sin6_addr, addr, sizeof(struct in6_addr));
-	addr = (struct sockaddr *)&addr6;
-	addr6.sin6_port = htons(tcp_port);
-	addr_len = sizeof(addr6);
-    }
-
-    listen_fd = socket(family, SOCK_STREAM, 0);
+    listen_fd = socket(AF_INET6, SOCK_STREAM, 0);
 
     if (listen_fd < 0)
     {
@@ -93,13 +69,16 @@ int init_comms()
     {
 	int one = 1;
 	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int));
+	setsockopt(listen_fd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(int));
     }
 
-    addr->sa_family = family;
+    memset(&addr, 0, sizeof(addr)); // Bind to INADDR_ANY
+    addr.sin6_family = AF_INET6;
+    addr.sin6_port = htons(tcp_port);
 
-    if (bind(listen_fd, addr, addr_len) < 0)
+    if (bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
     {
-	DEBUGLOG("Can't bind to port\n");
+	DEBUGLOG("Can't bind to port: %s\n", strerror(errno));
 	syslog(LOG_ERR, "Can't bind to port %d, is clvmd already running ?", tcp_port);
 	close(listen_fd);
 	return -1;
@@ -107,6 +86,9 @@ int init_comms()
 
     listen(listen_fd, 5);
 
+    /* Set Close-on-exec */
+    fcntl(listen_fd, F_SETFD, 1);
+
     return 0;
 }
 
@@ -119,19 +101,23 @@ void tcp_remove_client(char *csid)
        job of clvmd.c whch will do the job when it notices the
        other end has gone. We just need to remove the client(s) from
        the hash table so we don't try to use it for sending any more */
-    client = hash_lookup_binary(sock_hash, csid, MAX_CSID_LEN);
+    client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
     if (client)
     {
-	hash_remove_binary(sock_hash, csid, MAX_CSID_LEN);
+	dm_hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
+	client->removeme = 1;
+	close(client->fd);
     }
 
     /* Look for a mangled one too */
     csid[0] ^= 0x80;
 
-    client = hash_lookup_binary(sock_hash, csid, MAX_CSID_LEN);
+    client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
     if (client)
     {
-	hash_remove_binary(sock_hash, csid, MAX_CSID_LEN);
+	dm_hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
+	client->removeme = 1;
+	close(client->fd);
     }
 
     /* Put it back as we found it */
@@ -142,7 +128,7 @@ int alloc_client(int fd, char *csid, struct local_client **new_client)
 {
     struct local_client *client;
 
-    DEBUGLOG("alloc_client %d csid = [%d.%d.%d.%d]\n", fd,csid[0],csid[1],csid[2],csid[3]);
+    DEBUGLOG("alloc_client %d csid = %s\n", fd, print_csid(csid));
 
     /* Create a local_client and return it */
     client = malloc(sizeof(struct local_client));
@@ -160,7 +146,7 @@ int alloc_client(int fd, char *csid, struct local_client **new_client)
 	*new_client = client;
 
     /* Add to our list of node sockets */
-    if (hash_lookup_binary(sock_hash, csid, MAX_CSID_LEN))
+    if (dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN))
     {
 	DEBUGLOG("alloc_client mangling CSID for second connection\n");
 	/* This is a duplicate connection but we can't close it because
@@ -173,7 +159,7 @@ int alloc_client(int fd, char *csid, struct local_client **new_client)
 
         /* If it still exists then kill the connection as we should only
            ever have one incoming connection from each node */
-        if (hash_lookup_binary(sock_hash, csid, MAX_CSID_LEN))
+        if (dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN))
         {
 	    DEBUGLOG("Multiple incoming connections from node\n");
             syslog(LOG_ERR, " Bogus incoming connection from %d.%d.%d.%d\n", csid[0],csid[1],csid[2],csid[3]);
@@ -183,26 +169,26 @@ int alloc_client(int fd, char *csid, struct local_client **new_client)
             return -1;
         }
     }
-    hash_insert_binary(sock_hash, csid, MAX_CSID_LEN, client);
+    dm_hash_insert_binary(sock_hash, csid, GULM_MAX_CSID_LEN, client);
 
     return 0;
 }
 
-int get_main_cluster_fd()
+int get_main_gulm_cluster_fd()
 {
     return listen_fd;
 }
 
 
 /* Read on main comms (listen) socket, accept it */
-int cluster_fd_callback(struct local_client *fd, char *buf, int len, char *csid,
+int cluster_fd_gulm_callback(struct local_client *fd, char *buf, int len, char *csid,
 			struct local_client **new_client)
 {
     int newfd;
-    struct sockaddr_in addr;
+    struct sockaddr_in6 addr;
     socklen_t addrlen = sizeof(addr);
     int status;
-    char name[MAX_CLUSTER_MEMBER_NAME_LEN];
+    char name[GULM_MAX_CLUSTER_MEMBER_NAME_LEN];
 
     DEBUGLOG("cluster_fd_callback\n");
     *new_client = NULL;
@@ -218,22 +204,20 @@ int cluster_fd_callback(struct local_client *fd, char *buf, int len, char *csid,
 
     /* Check that the client is a member of the cluster
        and reject if not.
-       // FIXME: IPv4 specific
     */
-    if (name_from_csid((char *)&addr.sin_addr.s_addr, name) < 0)
+    if (gulm_name_from_csid((char *)&addr.sin6_addr, name) < 0)
     {
-	char *ip = (char *)&addr.sin_addr.s_addr;
-	syslog(LOG_ERR, "Got connect from non-cluster node %d.%d.%d.%d\n",
-	       ip[0], ip[1], ip[2], ip[3]);
-	DEBUGLOG("Got connect from non-cluster node %d.%d.%d.%d\n",
-		 ip[0], ip[1], ip[2], ip[3]);
+	syslog(LOG_ERR, "Got connect from non-cluster node %s\n",
+	       print_csid((char *)&addr.sin6_addr));
+	DEBUGLOG("Got connect from non-cluster node %s\n",
+		 print_csid((char *)&addr.sin6_addr));
 	close(newfd);
 
 	errno = EAGAIN;
 	return -1;
     }
 
-    status = alloc_client(newfd, (char *)&addr.sin_addr.s_addr, new_client);
+    status = alloc_client(newfd, (char *)&addr.sin6_addr, new_client);
     if (status)
     {
 	DEBUGLOG("cluster_fd_callback, alloc_client failed, status = %d\n", status);
@@ -246,22 +230,62 @@ int cluster_fd_callback(struct local_client *fd, char *buf, int len, char *csid,
     return newfd;
 }
 
+/* Try to get at least 'len' bytes from the socket */
+static int really_read(int fd, char *buf, int len)
+{
+	int got, offset;
+
+	got = offset = 0;
+
+	do {
+		got = read(fd, buf+offset, len-offset);
+		DEBUGLOG("really_read. got %d bytes\n", got);
+		offset += got;
+	} while (got > 0 && offset < len);
+
+	if (got < 0)
+		return got;
+	else
+		return offset;
+}
+
 
 static int read_from_tcpsock(struct local_client *client, char *buf, int len, char *csid,
 			     struct local_client **new_client)
 {
-    struct sockaddr_in addr;
+    struct sockaddr_in6 addr;
     socklen_t slen = sizeof(addr);
+    struct clvm_header *header = (struct clvm_header *)buf;
     int status;
+    uint32_t arglen;
 
     DEBUGLOG("read_from_tcpsock fd %d\n", client->fd);
     *new_client = NULL;
 
     /* Get "csid" */
     getpeername(client->fd, (struct sockaddr *)&addr, &slen);
-    memcpy(csid, &addr.sin_addr.s_addr, MAX_CSID_LEN);
+    memcpy(csid, &addr.sin6_addr, GULM_MAX_CSID_LEN);
 
-    status = read(client->fd, buf, len);
+    /* Read just the header first, then get the rest if there is any.
+     * Stream sockets, sigh.
+     */
+    status = really_read(client->fd, buf, sizeof(struct clvm_header));
+    if (status > 0)
+    {
+	    int status2;
+
+	    arglen = ntohl(header->arglen);
+
+	    /* Get the rest */
+	    if (arglen && arglen < GULM_MAX_CLUSTER_MESSAGE)
+	    {
+		    status2 = really_read(client->fd, buf+status, arglen);
+		    if (status2 > 0)
+			    status += status2;
+		    else
+			    status = status2;
+	    }
+    }
 
     DEBUGLOG("read_from_tcpsock, status = %d(errno = %d)\n", status, errno);
 
@@ -270,30 +294,36 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
     if (status == 0 ||
 	(status < 0 && errno != EAGAIN && errno != EINTR))
     {
-	char remcsid[MAX_CSID_LEN];
+	char remcsid[GULM_MAX_CSID_LEN];
 
-	memcpy(remcsid, csid, MAX_CSID_LEN);
+	memcpy(remcsid, csid, GULM_MAX_CSID_LEN);
 	close(client->fd);
 
 	/* If the csid was mangled, then make sure we remove the right entry */
 	if (client->bits.net.flags)
 	    remcsid[0] ^= 0x80;
-	hash_remove_binary(sock_hash, remcsid, MAX_CSID_LEN);
+	dm_hash_remove_binary(sock_hash, remcsid, GULM_MAX_CSID_LEN);
 
 	/* Tell cluster manager layer */
 	add_down_node(remcsid);
     }
+    else {
+	    gulm_add_up_node(csid);
+	    /* Send it back to clvmd */
+	    process_message(client, buf, status, csid);
+    }
     return status;
 }
 
-static int connect_csid(char *csid, struct local_client **newclient)
+int gulm_connect_csid(char *csid, struct local_client **newclient)
 {
     int fd;
-    struct sockaddr_in addr;
+    struct sockaddr_in6 addr;
     int status;
+    int one = 1;
 
     DEBUGLOG("Connecting socket\n");
-    fd = socket(PF_INET, SOCK_STREAM, 0);
+    fd = socket(PF_INET6, SOCK_STREAM, 0);
 
     if (fd < 0)
     {
@@ -301,19 +331,29 @@ static int connect_csid(char *csid, struct local_client **newclient)
 	return -1;
     }
 
-    addr.sin_family = AF_INET;
-    memcpy(&addr.sin_addr.s_addr, csid, MAX_CSID_LEN);
-    addr.sin_port = htons(tcp_port);
+    addr.sin6_family = AF_INET6;
+    memcpy(&addr.sin6_addr, csid, GULM_MAX_CSID_LEN);
+    addr.sin6_port = htons(tcp_port);
 
     DEBUGLOG("Connecting socket %d\n", fd);
-    if (connect(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0)
+    if (connect(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in6)) < 0)
     {
-	syslog(LOG_ERR, "Unable to connect to remote node: %m");
+	/* "Connection refused" is "normal" because clvmd may not yet be running
+	 * on that node.
+	 */
+	if (errno != ECONNREFUSED)
+	{
+	    syslog(LOG_ERR, "Unable to connect to remote node: %m");
+	}
 	DEBUGLOG("Unable to connect to remote node: %s\n", strerror(errno));
 	close(fd);
 	return -1;
     }
 
+    /* Set Close-on-exec */
+    fcntl(fd, F_SETFD, 1);
+    setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(int));
+
     status = alloc_client(fd, csid, newclient);
     if (status)
 	close(fd);
@@ -321,7 +361,7 @@ static int connect_csid(char *csid, struct local_client **newclient)
 	add_client(*newclient);
 
     /* If we can connect to it, it must be running a clvmd */
-    add_up_node(csid);
+    gulm_add_up_node(csid);
     return status;
 }
 
@@ -330,21 +370,21 @@ static int tcp_send_message(void *buf, int msglen, unsigned char *csid, const ch
 {
     int status;
     struct local_client *client;
-    char ourcsid[MAX_CSID_LEN];
+    char ourcsid[GULM_MAX_CSID_LEN];
 
     assert(csid);
 
-    DEBUGLOG("tcp_send_message, csid = [%d.%d.%d.%d], msglen = %d\n", csid[0],csid[1],csid[2],csid[3], msglen);
+    DEBUGLOG("tcp_send_message, csid = %s, msglen = %d\n", print_csid(csid), msglen);
 
     /* Don't connect to ourself */
-    get_our_csid(ourcsid);
-    if (memcmp(csid, ourcsid, MAX_CSID_LEN) == 0)
+    get_our_gulm_csid(ourcsid);
+    if (memcmp(csid, ourcsid, GULM_MAX_CSID_LEN) == 0)
 	return msglen;
 
-    client = hash_lookup_binary(sock_hash, csid, MAX_CSID_LEN);
+    client = dm_hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
     if (!client)
     {
-	status = connect_csid(csid, &client);
+	status = gulm_connect_csid(csid, &client);
 	if (status)
 	    return -1;
     }
@@ -354,7 +394,7 @@ static int tcp_send_message(void *buf, int msglen, unsigned char *csid, const ch
 }
 
 
-int cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
+int gulm_cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
 {
     int status=0;
 
@@ -364,7 +404,7 @@ int cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
     if (!csid)
     {
 	void *context = NULL;
-	char loop_csid[MAX_CSID_LEN];
+	char loop_csid[GULM_MAX_CSID_LEN];
 
 	/* Loop round all gulm-known nodes */
 	while (get_next_node_csid(&context, loop_csid))
@@ -383,62 +423,24 @@ int cluster_send_message(void *buf, int msglen, char *csid, const char *errtext)
     return status;
 }
 
-static int get_tcp_port(int default_port)
-{
-    int ccs_handle;
-    int port = default_port;
-    char *portstr;
-
-    ccs_handle = ccs_connect();
-    if (ccs_handle)
-    {
-	return port;
-    }
-
-    if (!ccs_get(ccs_handle, "//clvm/@port", &portstr))
-    {
-	port = atoi(portstr);
-	free(portstr);
-
-	if (port <= 0 && port >= 65536)
-	    port = default_port;
-    }
-    ccs_disconnect(ccs_handle);
-
-    DEBUGLOG("Using port %d for communications\n", port);
-    return port;
-}
-
 /* To get our own IP address we get the locally bound address of the
    socket that's talking to GULM in the assumption(eek) that it will
    be on the "right" network in a multi-homed system */
 static int get_our_ip_address(char *addr, int *family)
 {
-    /* Use a sockaddr_in6 to make sure it's big enough */
-    struct sockaddr_in6 saddr;
-    int socklen = sizeof(saddr);
+	struct utsname info;
+
+	uname(&info);
+	get_ip_address(info.nodename, addr);
 
-    if (!getsockname(gulm_fd(), (struct sockaddr *)&saddr, &socklen))
-    {
-	if (saddr.sin6_family == AF_INET6)
-	{
-	    memcpy(addr, &saddr.sin6_addr, sizeof(saddr.sin6_addr));
-	}
-	else
-	{
-	    struct sockaddr_in *sin4 = (struct sockaddr_in *)&saddr;
-	    memcpy(addr, &sin4->sin_addr, sizeof(sin4->sin_addr));
-	}
 	return 0;
-    }
-    return -1;
 }
 
 /* Public version of above for those that don't care what protocol
    we're using */
-void get_our_csid(char *csid)
+void get_our_gulm_csid(char *csid)
 {
-    static char our_csid[MAX_CSID_LEN];
+    static char our_csid[GULM_MAX_CSID_LEN];
     static int got_csid = 0;
 
     if (!got_csid)
@@ -451,7 +453,15 @@ void get_our_csid(char *csid)
 	    got_csid = 1;
 	}
     }
-    memcpy(csid, our_csid, MAX_CSID_LEN);
+    memcpy(csid, our_csid, GULM_MAX_CSID_LEN);
+}
+
+static void map_v4_to_v6(struct in_addr *ip4, struct in6_addr *ip6)
+{
+   ip6->s6_addr32[0] = 0;
+   ip6->s6_addr32[1] = 0;
+   ip6->s6_addr32[2] = htonl(0xffff);
+   ip6->s6_addr32[3] = ip4->s_addr;
 }
 
 /* Get someone else's IP address from DNS */
@@ -459,7 +469,7 @@ int get_ip_address(char *node, char *addr)
 {
     struct hostent *he;
 
-    memset(addr, 0, MAX_CSID_LEN);
+    memset(addr, 0, GULM_MAX_CSID_LEN);
 
     // TODO: what do we do about multi-homed hosts ???
     // CCSs ip_interfaces solved this but some bugger removed it.
@@ -467,14 +477,29 @@ int get_ip_address(char *node, char *addr)
     /* Try IPv6 first. The man page for gethostbyname implies that
        it will lookup ip6 & ip4 names, but it seems not to */
     he = gethostbyname2(node, AF_INET6);
-    if (!he)
+    if (he)
+    {
+	memcpy(addr, he->h_addr_list[0],
+	       he->h_length);
+    }
+    else
+    {
 	he = gethostbyname2(node, AF_INET);
-    if (!he)
-	return -1;
-
-    /* For IPv4 address just use the lower 4 bytes */
-    memcpy(&addr, he->h_addr_list[0],
-	   he->h_length);
+	if (!he)
+	    return -1;
+	map_v4_to_v6((struct in_addr *)he->h_addr_list[0], (struct in6_addr *)addr);
+    }
 
     return 0;
 }
+
+char *print_csid(char *csid)
+{
+    static char buf[128];
+    int *icsid = (int *)csid;
+
+    sprintf(buf, "[%x.%x.%x.%x]",
+	    icsid[0],icsid[1],icsid[2],icsid[3]);
+
+    return buf;
+}

daemons/clvmd/tcp-comms.h

@@ -1,7 +1,13 @@
 #include <netinet/in.h>
 
-#define MAX_CLUSTER_MESSAGE 1600
-#define MAX_CSID_LEN sizeof(struct in6_addr)
-#define MAX_CLUSTER_MEMBER_NAME_LEN 128
+#define GULM_MAX_CLUSTER_MESSAGE 1600
+#define GULM_MAX_CSID_LEN sizeof(struct in6_addr)
+#define GULM_MAX_CLUSTER_MEMBER_NAME_LEN 128
 
-extern int init_comms(void);
+extern int init_comms(unsigned short);
+extern char *print_csid(char *);
+int get_main_gulm_cluster_fd(void);
+int cluster_fd_gulm_callback(struct local_client *fd, char *buf, int len, char *csid, struct local_client **new_client);
+int gulm_cluster_send_message(void *buf, int msglen, char *csid, const char *errtext);
+void get_our_gulm_csid(char *csid);
+int gulm_connect_csid(char *csid, struct local_client **newclient);

daemons/dmeventd/.exported_symbols

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

daemons/dmeventd/Makefile.in

@@ -0,0 +1,51 @@
+#
+# Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+#
+# This file is part of the device-mapper userspace tools.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU 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@
+
+TARGETS = dmevent dmeventd
+INSTALL_TYPE = install_dynamic
+
+SOURCES = noop.c
+CLEAN_TARGETS = dmevent.o dmeventd.o
+
+ifeq ("@LIB_SUFFIX@","dylib")
+  LIB_SHARED = libdmeventdnoop.dylib
+else
+  LIB_SHARED = libdmeventdnoop.so
+endif
+ 
+LDFLAGS += -ldl -ldevmapper -lmultilog
+
+include ../make.tmpl
+
+libdmeventdnoop.so: noop.o
+
+dmevent: dmevent.o $(interfacedir)/libdevmapper.$(LIB_SUFFIX) $(top_srcdir)/lib/event/libdmevent.$(LIB_SUFFIX)
+	$(CC) -o $@ dmevent.o $(LDFLAGS) \
+	      -L$(interfacedir) -L$(DESTDIR)/lib -L$(top_srcdir)/lib/event -L$(top_srcdir)/multilog $(LIBS)
+
+dmeventd: dmeventd.o $(interfacedir)/libdevmapper.$(LIB_SUFFIX) $(top_srcdir)/lib/event/libdmevent.$(LIB_SUFFIX)
+	$(CC) -o $@ dmeventd.o $(LDFLAGS) \
+	      -L$(interfacedir) -L$(DESTDIR)/lib -L$(top_srcdir)/lib/event -L$(top_srcdir)/multilog -lpthread -ldmevent $(LIBS)
+
+install: $(INSTALL_TYPE)
+
+.PHONY: install_dynamic
+
+install_dynamic: dmeventd
+	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) dmeventd $(sbindir)/dmeventd
+

daemons/dmeventd/dmevent.c

@@ -0,0 +1,240 @@
+/*
+ * Copyright (C) 2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "libdevmapper.h"
+#include "libdm-event.h"
+#include "libmultilog.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/file.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dlfcn.h>
+
+static enum event_type events = ALL_ERRORS; /* All until we can distinguish. */
+static char default_dso_name[] = "noop";  /* default DSO is noop */
+static int default_reg = 1;		 /* default action is register */
+static uint32_t timeout;
+
+struct event_ops {
+int (*dm_register_for_event)(char *dso_name, char *device,
+			     enum event_type event_types);
+int (*dm_unregister_for_event)(char *dso_name, char *device,
+			       enum event_type event_types);
+int (*dm_get_registered_device)(char **dso_name, char **device,
+				enum event_type *event_types, int next);
+int (*dm_set_event_timeout)(char *device, uint32_t time);
+int (*dm_get_event_timeout)(char *device, uint32_t *time);
+};
+
+/* Display help. */
+static void print_usage(char *name)
+{
+	char *cmd = strrchr(name, '/');
+
+	cmd = cmd ? cmd + 1 : name;
+	printf("Usage::\n"
+	       "%s [options] <device>\n"
+	       "\n"
+	       "Options:\n"
+	       "  -d <dso>           Specify the DSO to use.\n"
+	       "  -h                 Print this usage.\n"
+	       "  -l                 List registered devices.\n"
+	       "  -r                 Register for event (default).\n"
+	       "  -t <timeout>       (un)register for timeout event.\n"
+	       "  -u                 Unregister for event.\n"
+	       "\n", cmd);
+}
+
+/* Parse command line arguments. */
+static int parse_argv(int argc, char **argv, char **dso_name_arg,
+		      char **device_arg, int *reg, int *list)
+{
+	int c;
+	const char *options = "d:hlrt:u";
+
+	while ((c = getopt(argc, argv, options)) != -1) {
+		switch (c) {
+		case 'd':
+			*dso_name_arg = optarg;
+			break;
+		case 'h':
+			print_usage(argv[0]);
+			exit(EXIT_SUCCESS);
+		case 'l':
+			*list = 1;
+			break;
+		case 'r':
+			*reg = 1;
+			break;
+		case 't':
+			events = TIMEOUT;
+			if (sscanf(optarg, "%"SCNu32, &timeout) != 1){
+				fprintf(stderr, "invalid timeout '%s'\n",
+					optarg);
+				timeout = 0;
+			}
+			break;
+		case 'u':
+			*reg = 0;
+			break;
+		default:
+			fprintf(stderr, "Unknown option '%c'.\n"
+				"Try '-h' for help.\n", c);
+
+			return 0;
+		}
+	}
+
+	if (optind >= argc) {
+		if (!*list) {
+			fprintf(stderr, "You need to specify a device.\n");
+			return 0;
+		}
+	} else 
+		*device_arg = argv[optind];
+
+	return 1;
+}
+
+
+static int lookup_symbol(void *dl, void **symbol, const char *name)
+{
+	if ((*symbol = dlsym(dl, name)))
+		return 1;
+
+	fprintf(stderr, "error looking up %s symbol: %s\n", name, dlerror());
+
+	return 0;
+}
+
+static int lookup_symbols(void *dl, struct event_ops *e)
+{
+	return lookup_symbol(dl, (void *) &e->dm_register_for_event,
+			     "dm_register_for_event") &&
+	       lookup_symbol(dl, (void *) &e->dm_unregister_for_event,
+			     "dm_unregister_for_event") &&
+	       lookup_symbol(dl, (void *) &e->dm_get_registered_device,
+			     "dm_get_registered_device") &&
+	       lookup_symbol(dl, (void *) &e->dm_set_event_timeout,
+			     "dm_set_event_timeout") &&
+	       lookup_symbol(dl, (void *) &e->dm_get_event_timeout,
+			     "dm_get_event_timeout");
+}
+
+int main(int argc, char **argv)
+{
+	void *dl;
+	struct event_ops e;
+	int list = 0, next = 0, ret, reg = default_reg;
+	char *device, *device_arg = NULL, *dso_name, *dso_name_arg = NULL;
+
+	if (!parse_argv(argc, argv, &dso_name_arg, &device_arg, &reg, &list))
+		exit(EXIT_FAILURE);
+
+	if (device_arg) {
+		if (!(device = strdup(device_arg)))
+			exit(EXIT_FAILURE);
+	} else
+		device = NULL;
+
+	if (dso_name_arg) {
+		if (!(dso_name = strdup(dso_name_arg)))
+			exit(EXIT_FAILURE);
+	} else {
+		if (!(dso_name = strdup(default_dso_name)))
+			exit(EXIT_FAILURE);
+	}
+
+	/* FIXME: use -v/-q options to set this */
+	multilog_add_type(standard, NULL);
+	multilog_init_verbose(standard, _LOG_DEBUG);
+
+	if (!(dl = dlopen("libdmevent.so", RTLD_NOW))){
+		fprintf(stderr, "Cannot dlopen libdmevent.so: %s\n", dlerror());
+		goto out;
+	}
+	if (!(lookup_symbols(dl, &e)))
+		goto out;
+	if (list) {
+		while (1) {
+			if ((ret= e.dm_get_registered_device(&dso_name,
+							     &device,
+							     &events, next)))
+				break;
+			printf("%s %s 0x%x", dso_name, device, events);
+			if (events & TIMEOUT){
+				if ((ret = e.dm_get_event_timeout(device,
+							  	  &timeout))) {
+					ret = EXIT_FAILURE;
+					goto out;
+				}
+				printf(" %"PRIu32"\n", timeout);
+			} else
+				printf("\n");
+			if (device_arg)
+				break;
+
+			next = 1;
+		}
+
+		ret = (ret && device_arg) ? EXIT_FAILURE : EXIT_SUCCESS;
+		goto out;
+	}
+
+	if ((ret = reg ? e.dm_register_for_event(dso_name, device, events) :
+			 e.dm_unregister_for_event(dso_name, device, events))) {
+		fprintf(stderr, "Failed to %sregister %s: %s\n",
+			reg ? "": "un", device, strerror(-ret));
+		ret = EXIT_FAILURE;
+	} else {
+		if (reg && (events & TIMEOUT) &&
+		    ((ret = e.dm_set_event_timeout(device, timeout)))){
+			fprintf(stderr, "Failed to set timeout for %s: %s\n",
+				device, strerror(-ret));
+			ret = EXIT_FAILURE;
+		} else {
+			printf("%s %sregistered successfully.\n",
+			       device, reg ? "" : "un");
+			ret = EXIT_SUCCESS;
+		}
+	}
+
+   out:
+	multilog_del_type(standard);
+
+	if (device)
+		free(device);
+	if (dso_name)
+		free(dso_name);
+
+	exit(ret);
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * Emacs will notice this stuff at the end of the file and automatically
+ * adjust the settings for this buffer only.  This must remain at the end
+ * of the file.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-file-style: "linux"
+ * End:
+ */

daemons/dmeventd/mktestdevices

@@ -0,0 +1,12 @@
+#!/bin/sh
+#
+# Create test devices for dmeventd
+#
+
+trap "rm -f /tmp/tmp.$$" 0 1 2 3 15
+
+echo "0 1024 zero" > /tmp/tmp.$$
+dmsetup create test /tmp/tmp.$$
+dmsetup create test1 /tmp/tmp.$$
+
+kill -15 $$

daemons/dmeventd/noop.c

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "libdm-event.h"
+#include "libmultilog.h"
+
+
+void process_event(char *device, enum event_type event)
+{
+	log_err("[%s] %s(%d) - Device: %s, Event %d\n",
+		__FILE__, __func__, __LINE__, device, event);
+}
+
+int register_device(char *device)
+{
+	log_err("[%s] %s(%d) - Device: %s\n",
+		__FILE__, __func__, __LINE__, device);
+
+	return 1;
+}
+
+int unregister_device(char *device)
+{
+	log_err("[%s] %s(%d) - Device: %s\n",
+		__FILE__, __func__, __LINE__, device);
+
+	return 1;
+}

doc/example.conf

@@ -27,8 +27,18 @@ devices {
     # the device will be accepted or rejected (ignored).  Devices that
     # don't match any patterns are accepted.
 
-    # Remember to run vgscan after you change this parameter to ensure 
-    # that the cache file gets regenerated (see below).
+    # Be careful if there there are symbolic links or multiple filesystem 
+    # entries for the same device as each name is checked separately against
+    # the list of patterns.  The effect is that if any name matches any 'a'
+    # pattern, the device is accepted; otherwise if any name matches any 'r'
+    # pattern it is rejected; otherwise it is accepted.
+
+    # Don't have more than one filter line active at once: only one gets used.
+
+    # Run vgscan after you change this parameter to ensure that
+    # the cache file gets regenerated (see below).
+    # If it doesn't do what you expect, check the output of 'vgscan -vvvv'.
+
 
     # By default we accept every block device:
     filter = [ "a/.*/" ]
@@ -252,11 +262,10 @@ activation {
 #
 # metadata {
     # Default number of copies of metadata to hold on each PV.  0, 1 or 2.
-    # It's best to leave this at 2.
-    # You might want to override it from the command line with 0 or 1 
+    # You might want to override it from the command line with 0 
     # when running pvcreate on new PVs which are to be added to large VGs.
 
-    # pvmetadatacopies = 2
+    # pvmetadatacopies = 1
 
     # Approximate default size of on-disk metadata areas in sectors.
     # You should increase this if you have large volume groups or

doc/tagging.txt

@@ -0,0 +1,165 @@
+Tagging aims
+============
+  1) Ability to attach an unordered list of tags to LVM metadata objects.
+  2) Ability to add or remove tags easily.
+  3) Ability to select LVM objects for processing according to presence/absence
+     of specific tags.
+  4) Ability to control through the config file which VGs/LVs are activated 
+     on different machines using names or tags.
+  5) Ability to overlay settings from different config files e.g. override
+     some settings in a global config file locally.
+
+Clarifications
+==============
+  1) Tag character set: A-Za-z0-9_+.- 
+     Can't start with hyphen & max length is 128 (NAME_LEN).
+  2) LVM object types that can be tagged:
+       VG, LV, LV segment
+       PV - tags are stored in VG metadata so disappear when PV becomes orphaned
+     Snapshots can't be tagged, but their origin may be.
+  3) A tag can be used in place of any command line LVM object reference that
+     accepts (a) a list of objects; or (b) a single object as long as the
+     tag expands to a single object.  This is not supported everywhere yet.
+     Duplicate arguments in a list after argument expansion may get removed 
+     retaining the first copy of each argument.
+  4) Wherever there may be ambiguity of argument type, a tag must be prefixed 
+     by '@'; elsewhere an '@' prefix is optional.
+  5) LVM1 objects cannot be tagged, as the disk format doesn't support it.
+  6) Tags can be added or removed with --addtag or --deltag.
+
+Config file Extensions
+======================
+  To define host tags in config file:
+
+  tags {
+  	# Set a tag with the hostname
+	hosttags = 1
+
+	tag1 { }
+
+  	tag2 {
+		# If no exact match, tag is not set.
+		host_list = [ "hostname", "dbase" ]
+	}
+  }
+
+Activation config file example
+==============================
+  activation {
+      volume_list = [ "vg1/lvol0", "@database" ]
+  }
+
+  Matches against vgname, vgname/lvname or @tag set in *metadata*.
+  @* matches exactly against *any* tag set on the host.
+  The VG or LV only gets activated if a metadata tag matches.
+  The default if there is no match is not to activate.
+  If volume_list is not present and any tags are defined on the host 
+  then it only activates if a host tag matches a metadata tag.
+  If volume_list is not present and no tags are defined on the host 
+  then it does activate.
+
+Multiple config files
+=====================
+  (a) lvm.conf
+  (b) lvm_<host_tag>.conf
+
+  At startup, load lvm.conf.
+  Process tag settings.
+  If any host tags were defined, load lvm_tag.conf for each tag, if present.
+
+  When searching for a specific config file entry, search order is (b)
+  then (a), stopping at the first match.  
+  Within (b) use reverse order tags got set, so file for last tag set is
+  searched first.
+  New tags set in (b) *do* trigger additional config file loads. 
+
+Usage Examples
+==============
+  1) Simple activation control via metadata with static config files
+
+  lvm.conf:  (Identical on every machine - global settings)
+    tags {
+      hostname_tags = 1
+    }
+
+  From any machine in the cluster, add db1 to the list of machines that
+  activate vg1/lvol2:
+
+  lvchange --tag @db1 vg1/lvol2
+  (followed by lvchange -ay to actually activate it)
+
+
+  2) Multiple hosts.  
+
+    Activate vg1 only on the database hosts, db1 and db2.
+    Activate vg2 only on the fileserver host fs1.
+    Activate nothing initially on the fileserver backup host fsb1, but be
+    prepared for it to take over from fs1.
+
+  Option (i) - centralised admin, static configuration replicated between hosts  
+    # Add @database tag to vg1's metadata
+    vgchange --tag @database vg1
+
+    # Add @fileserver tag to vg2's metadata
+    vgchange --tag @fileserver vg2
+
+    lvm.conf:  (Identical on every machine)
+      tags {
+        database {
+          host_list = [ "db1", "db2" ]
+        }
+        fileserver {
+	  host_list = [ "fs1" ]
+        }
+        fileserverbackup {
+          host_list = [ "fsb1" ]
+        }
+      }
+
+      activation {
+        # Only activate if host has a tag that matches a metadata tag
+        volume_list = [ "@*" ]
+      }
+  
+  In the event of the fileserver host going down, vg2 can be brought up
+  on fsb1 by running *on any node* 'vgchange --tag @fileserverbackup vg2'
+  followed by 'vgchange -ay vg2'
+  
+  
+  Option (ii) - localised admin & configuation
+  (i.e. each host holds *locally* which classes of volumes to activate)
+    # Add @database tag to vg1's metadata
+    vgchange --tag @database vg1
+  
+    # Add @fileserver tag to vg2's metadata
+    vgchange --tag @fileserver vg2
+  
+    lvm.conf:  (Identical on every machine - global settings)
+      tags {
+        hosttags = 1
+      }
+  
+    lvm_db1.conf: (only needs to be on db1 - could be symlink to lvm_db.conf)
+      activation {
+        volume_list = [ "@database" ]
+      }
+  
+    lvm_db2.conf: (only needs to be on db2 - could be symlink to lvm_db.conf)
+      activation {
+        volume_list = [ "@database" ]
+      }
+  
+    lvm_fs1.conf: (only needs to be on fs1 - could be symlink to lvm_fs.conf)
+      activation {
+        volume_list = [ "@fileserver" ]
+      }
+  
+    If fileserver goes down, to bring a spare machine fsb1 in as fileserver,
+    create lvm_fsb1.conf on fsb1 (or symlink to lvm_fs.conf):
+
+      activation {
+        volume_list = [ "@fileserver" ]
+      }
+
+    and run 'vgchange -ay vg2' or 'vgchange -ay @fileserver'
+

include/.symlinks

@@ -6,9 +6,7 @@
 ../lib/commands/toolcontext.h
 ../lib/config/config.h
 ../lib/config/defaults.h
-../lib/datastruct/bitset.h
 ../lib/datastruct/btree.h
-../lib/datastruct/hash.h
 ../lib/datastruct/list.h
 ../lib/datastruct/lvm-types.h
 ../lib/datastruct/str_list.h
@@ -23,6 +21,7 @@
 ../lib/filters/filter.h
 ../lib/format1/format1.h
 ../lib/format_pool/format_pool.h
+../lib/format_text/archiver.h
 ../lib/format_text/format-text.h
 ../lib/format_text/text_export.h
 ../lib/format_text/text_import.h
@@ -31,19 +30,19 @@
 ../lib/log/log.h
 ../lib/metadata/lv_alloc.h
 ../lib/metadata/metadata.h
+../lib/metadata/pv_alloc.h
 ../lib/metadata/segtype.h
-../lib/mm/dbg_malloc.h
 ../lib/mm/memlock.h
-../lib/mm/pool.h
 ../lib/mm/xlate.h
 ../lib/misc/crc.h
 ../lib/misc/intl.h
 ../lib/misc/lib.h
+../lib/misc/lvm-exec.h
 ../lib/misc/lvm-file.h
 ../lib/misc/lvm-string.h
-../lib/misc/selinux.h
 ../lib/misc/sharedlib.h
 ../lib/regex/matcher.h
 ../lib/report/report.h
 ../lib/uuid/uuid.h
 ../po/pogen.h
+../tools/version.h

lib/Makefile.in

@@ -1,6 +1,6 @@
 #
 # Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
-# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+# Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
 #
 # This file is part of the LVM2.
 #
@@ -37,12 +37,11 @@ SOURCES =\
 	cache/lvmcache.c \
 	commands/toolcontext.c \
 	config/config.c \
-	datastruct/bitset.c \
 	datastruct/btree.c \
-	datastruct/hash.c \
 	datastruct/str_list.c \
 	device/dev-cache.c \
 	device/dev-io.c \
+	device/dev-md.c \
 	device/device.c \
 	display/display.c \
 	error/errseg.c \
@@ -53,6 +52,7 @@ SOURCES =\
 	filters/filter-md.c \
 	filters/filter.c \
 	format_text/archive.c \
+	format_text/archiver.c \
 	format_text/export.c \
 	format_text/flags.c \
 	format_text/format-text.c \
@@ -69,14 +69,15 @@ SOURCES =\
 	metadata/merge.c \
 	metadata/metadata.c \
 	metadata/mirror.c \
+	metadata/pv_manip.c \
 	metadata/pv_map.c \
 	metadata/segtype.c \
 	metadata/snapshot_manip.c \
 	misc/crc.c \
+	misc/lvm-exec.c \
 	misc/lvm-file.c \
 	misc/lvm-string.c \
 	mm/memlock.c \
-	mm/pool.c \
 	regex/matcher.c \
 	regex/parse_rx.c \
 	regex/ttree.c \
@@ -120,10 +121,6 @@ ifeq ("@MIRRORS@", "internal")
   SOURCES += mirror/mirrored.c
 endif
 
-ifeq ("@DEBUG@", "yes")
-  SOURCES += mm/dbg_malloc.c
-endif
-
 ifeq ("@DEVMAPPER@", "yes")
   SOURCES +=\
 	activate/dev_manager.c \
@@ -136,10 +133,6 @@ ifeq ("@HAVE_LIBDL@", "yes")
 	misc/sharedlib.c
 endif
 
-ifeq ("@HAVE_SELINUX@", "yes")
-  SOURCES += misc/selinux.c
-endif
-
 LIB_STATIC = liblvm.a
 
 $(SUBDIRS): $(LIB_STATIC)

lib/activate/activate.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
- * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -19,13 +19,14 @@
 #include "memlock.h"
 #include "display.h"
 #include "fs.h"
+#include "lvm-exec.h"
 #include "lvm-file.h"
 #include "lvm-string.h"
-#include "pool.h"
 #include "toolcontext.h"
 #include "dev_manager.h"
 #include "str_list.h"
 #include "config.h"
+#include "filter.h"
 
 #include <limits.h>
 #include <fcntl.h>
@@ -78,12 +79,13 @@ int target_present(const char *target_name)
 {
 	return 0;
 }
-int lv_info(const struct logical_volume *lv, struct lvinfo *info)
+int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, struct lvinfo *info,
+	    int with_open_count)
 {
 	return 0;
 }
 int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
-		    struct lvinfo *info)
+		    struct lvinfo *info, int with_open_count)
 {
 	return 0;
 }
@@ -129,11 +131,11 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
 {
 	return 1;
 }
-int lv_activate(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
 	return 1;
 }
-int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
 	return 1;
 }
@@ -143,6 +145,12 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
 	return 1;
 }
 
+int pv_uses_vg(struct cmd_context *cmd, struct physical_volume *pv,
+               struct volume_group *vg)
+{
+	return 0;
+}
+
 void activation_exit(void)
 {
 	return;
@@ -256,53 +264,28 @@ int library_version(char *version, size_t size)
 	if (!activation())
 		return 0;
 
-	if (!dm_get_library_version(version, size))
-		return 0;
-	return 1;
+	return dm_get_library_version(version, size);
 }
 
 int driver_version(char *version, size_t size)
 {
-	int r = 0;
-	struct dm_task *dmt;
-
 	if (!activation())
 		return 0;
 
 	log_very_verbose("Getting driver version");
-	if (!(dmt = dm_task_create(DM_DEVICE_VERSION))) {
-		stack;
-		return 0;
-	}
 
-	if (!dm_task_run(dmt))
-		log_error("Failed to get driver version");
-
-	if (!dm_task_get_driver_version(dmt, version, size))
-		goto out;
-
-	r = 1;
-
-      out:
-	dm_task_destroy(dmt);
-
-	return r;
+	return dm_driver_version(version, size);
 }
 
-int target_present(const char *target_name)
+static int _target_present(const char *target_name)
 {
 	int r = 0;
 	struct dm_task *dmt;
 	struct dm_versions *target, *last_target;
 
-	if (!activation())
-		return 0;
-
 	log_very_verbose("Getting target version for %s", target_name);
-	if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS))) {
-		stack;
-		return 0;
-	}
+	if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS)))
+		return_0;
 
 	if (!dm_task_run(dmt)) {
 		log_debug("Failed to get %s target version", target_name);
@@ -329,26 +312,56 @@ int target_present(const char *target_name)
 	return r;
 }
 
-/*
- * Returns 1 if info structure populated, else 0 on failure.
- */
-static int _lv_info(const struct logical_volume *lv, int mknodes,
-		    struct lvinfo *info)
+int target_present(const char *target_name, int use_modprobe)
 {
-	int r;
-	struct dev_manager *dm;
-	struct dm_info dminfo;
+#ifdef MODPROBE_CMD
+	char module[128];
+#endif
 
 	if (!activation())
 		return 0;
 
-	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
-		stack;
-		return 0;
-	}
+#ifdef MODPROBE_CMD
+	if (use_modprobe) {
+		if (_target_present(target_name))
+			return 1;
 
-	if (!(r = dev_manager_info(dm, lv, mknodes, &dminfo)))
-		stack;
+		if (lvm_snprintf(module, sizeof(module), "dm-%s", target_name)
+		    < 0) {
+			log_error("target_present module name too long: %s",
+				  target_name);
+			return 0;
+		}
+
+		if (!exec_cmd(MODPROBE_CMD, module, "", ""))
+			return_0;
+	}
+#endif
+
+	return _target_present(target_name);
+}
+
+/*
+ * Returns 1 if info structure populated, else 0 on failure.
+ */
+static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv, int with_mknodes,
+		    struct lvinfo *info, int with_open_count)
+{
+	struct dm_info dminfo;
+	char *name;
+
+	if (!activation())
+		return 0;
+
+	if (!(name = build_dm_name(cmd->mem, lv->vg->name, lv->name, NULL)))
+		return_0;
+
+	log_debug("Getting device info for %s", name);
+	if (!dev_manager_info(lv->vg->cmd->mem, name, lv, with_mknodes,
+			      with_open_count, &dminfo)) {
+		dm_pool_free(cmd->mem, name);
+		return_0;
+	}
 
 	info->exists = dminfo.exists;
 	info->suspended = dminfo.suspended;
@@ -356,25 +369,28 @@ static int _lv_info(const struct logical_volume *lv, int mknodes,
 	info->major = dminfo.major;
 	info->minor = dminfo.minor;
 	info->read_only = dminfo.read_only;
+	info->live_table = dminfo.live_table;
+	info->inactive_table = dminfo.inactive_table;
 
-	dev_manager_destroy(dm);
-	return r;
+	dm_pool_free(cmd->mem, name);
+	return 1;
 }
 
-int lv_info(const struct logical_volume *lv, struct lvinfo *info)
+int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, struct lvinfo *info,
+	    int with_open_count)
 {
-	return _lv_info(lv, 0, info);
+	return _lv_info(cmd, lv, 0, info, with_open_count);
 }
 
 int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
-		    struct lvinfo *info)
+		    struct lvinfo *info, int with_open_count)
 {
 	struct logical_volume *lv;
 
-	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
 		return 0;
 
-	return _lv_info(lv, 0, info);
+	return _lv_info(cmd, lv, 0, info, with_open_count);
 }
 
 /*
@@ -388,10 +404,8 @@ int lv_snapshot_percent(struct logical_volume *lv, float *percent)
 	if (!activation())
 		return 0;
 
-	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
-		stack;
-		return 0;
-	}
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
+		return_0;
 
 	if (!(r = dev_manager_snapshot_percent(dm, lv, percent)))
 		stack;
@@ -402,7 +416,7 @@ int lv_snapshot_percent(struct logical_volume *lv, float *percent)
 }
 
 /* FIXME Merge with snapshot_percent */
-int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
+int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv, int wait, float *percent,
 		      uint32_t *event_nr)
 {
 	int r;
@@ -412,18 +426,14 @@ int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
 	if (!activation())
 		return 0;
 
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
+	if (!lv_info(cmd, lv, &info, 0))
+		return_0;
 
 	if (!info.exists)
 		return 0;
 
-	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
-		stack;
-		return 0;
-	}
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
+		return_0;
 
 	if (!(r = dev_manager_mirror_percent(dm, lv, wait, percent, event_nr)))
 		stack;
@@ -433,11 +443,11 @@ int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
 	return r;
 }
 
-static int _lv_active(struct logical_volume *lv)
+static int _lv_active(struct cmd_context *cmd, struct logical_volume *lv)
 {
 	struct lvinfo info;
 
-	if (!lv_info(lv, &info)) {
+	if (!lv_info(cmd, lv, &info, 0)) {
 		stack;
 		return -1;
 	}
@@ -445,11 +455,11 @@ static int _lv_active(struct logical_volume *lv)
 	return info.exists;
 }
 
-static int _lv_open_count(struct logical_volume *lv)
+static int _lv_open_count(struct cmd_context *cmd, struct logical_volume *lv)
 {
 	struct lvinfo info;
 
-	if (!lv_info(lv, &info)) {
+	if (!lv_info(cmd, lv, &info, 1)) {
 		stack;
 		return -1;
 	}
@@ -457,16 +467,13 @@ static int _lv_open_count(struct logical_volume *lv)
 	return info.open_count;
 }
 
-/* FIXME Need to detect and handle an lv rename */
 static int _lv_activate_lv(struct logical_volume *lv)
 {
 	int r;
 	struct dev_manager *dm;
 
-	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
-		stack;
-		return 0;
-	}
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
+		return_0;
 
 	if (!(r = dev_manager_activate(dm, lv)))
 		stack;
@@ -475,15 +482,28 @@ static int _lv_activate_lv(struct logical_volume *lv)
 	return r;
 }
 
+static int _lv_preload(struct logical_volume *lv)
+{
+	int r;
+	struct dev_manager *dm;
+
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
+		return_0;
+
+	if (!(r = dev_manager_preload(dm, lv)))
+		stack;
+
+	dev_manager_destroy(dm);
+	return r;
+}
+
 static int _lv_deactivate(struct logical_volume *lv)
 {
 	int r;
 	struct dev_manager *dm;
 
-	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
-		stack;
-		return 0;
-	}
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
+		return_0;
 
 	if (!(r = dev_manager_deactivate(dm, lv)))
 		stack;
@@ -497,10 +517,8 @@ static int _lv_suspend_lv(struct logical_volume *lv)
 	int r;
 	struct dev_manager *dm;
 
-	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
-		stack;
-		return 0;
-	}
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
+		return_0;
 
 	if (!(r = dev_manager_suspend(dm, lv)))
 		stack;
@@ -515,17 +533,15 @@ static int _lv_suspend_lv(struct logical_volume *lv)
  */
 int lvs_in_vg_activated(struct volume_group *vg)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 	int count = 0;
 
 	if (!activation())
 		return 0;
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & VISIBLE_LV)
-			count += (_lv_active(lv) == 1);
+	list_iterate_items(lvl, &vg->lvs) {
+		if (lvl->lv->status & VISIBLE_LV)
+			count += (_lv_active(vg->cmd, lvl->lv) == 1);
 	}
 
 	return count;
@@ -533,17 +549,15 @@ int lvs_in_vg_activated(struct volume_group *vg)
 
 int lvs_in_vg_opened(struct volume_group *vg)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 	int count = 0;
 
 	if (!activation())
 		return 0;
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & VISIBLE_LV)
-			count += (_lv_open_count(lv) > 0);
+	list_iterate_items(lvl, &vg->lvs) {
+		if (lvl->lv->status & VISIBLE_LV)
+			count += (_lv_open_count(vg->cmd, lvl->lv) > 0);
 	}
 
 	return count;
@@ -558,7 +572,8 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 	if (!activation())
 		return 1;
 
-	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+	/* Use precommitted metadata if present */
+	if (!(lv = lv_from_lvid(cmd, lvid_s, 1)))
 		return 0;
 
 	if (test_mode()) {
@@ -566,14 +581,20 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
 		return 1;
 	}
 
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
+	if (!lv_info(cmd, lv, &info, 0))
+		return_0;
 
 	if (!info.exists || info.suspended)
 		return error_if_not_suspended ? 0 : 1;
 
+	/* If VG was precommitted, preload devices for the LV */
+	if ((lv->vg->status & PRECOMMITTED)) {
+		if (!_lv_preload(lv)) {
+			/* FIXME Revert preloading */
+			return_0;
+		}
+	}
+
 	memlock_inc();
 	if (!_lv_suspend_lv(lv)) {
 		memlock_dec();
@@ -604,7 +625,7 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 	if (!activation())
 		return 1;
 
-	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
 		return 0;
 
 	if (test_mode()) {
@@ -612,10 +633,8 @@ static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
 		return 1;
 	}
 
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
+	if (!lv_info(cmd, lv, &info, 0))
+		return_0;
 
 	if (!info.exists || !info.suspended)
 		return error_if_not_active ? 0 : 1;
@@ -649,7 +668,7 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
 	if (!activation())
 		return 1;
 
-	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
 		return 0;
 
 	if (test_mode()) {
@@ -657,16 +676,14 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
 		return 1;
 	}
 
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
+	if (!lv_info(cmd, lv, &info, 1))
+		return_0;
 
 	if (!info.exists)
 		return 1;
 
 	if (info.open_count && (lv->status & VISIBLE_LV)) {
-		log_error("LV %s/%s in use: not removing", lv->vg->name,
+		log_error("LV %s/%s in use: not deactivating", lv->vg->name,
 			  lv->name);
 		return 0;
 	}
@@ -688,7 +705,7 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
 	if (!activation())
 		goto activate;
 
-	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
 		return 0;
 
 	if (!_passes_activation_filter(cmd, lv)) {
@@ -703,7 +720,8 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
 	return 1;
 }
 
-static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
+static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
+			int exclusive, int filter)
 {
 	struct logical_volume *lv;
 	struct lvinfo info;
@@ -712,7 +730,7 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
 	if (!activation())
 		return 1;
 
-	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+	if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
 		return 0;
 
 	if (filter && !_passes_activation_filter(cmd, lv)) {
@@ -726,14 +744,15 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
 		return 1;
 	}
 
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
+	if (!lv_info(cmd, lv, &info, 0))
+		return_0;
 
-	if (info.exists && !info.suspended)
+	if (info.exists && !info.suspended && info.live_table)
 		return 1;
 
+	if (exclusive)
+		lv->status |= ACTIVATE_EXCL;
+
 	memlock_inc();
 	r = _lv_activate_lv(lv);
 	memlock_dec();
@@ -743,15 +762,15 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
 }
 
 /* Activate LV */
-int lv_activate(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
-	return _lv_activate(cmd, lvid_s, 0);
+	return _lv_activate(cmd, lvid_s, exclusive, 0);
 }
 
 /* Activate LV only if it passes filter */
-int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
-	return _lv_activate(cmd, lvid_s, 1);
+	return _lv_activate(cmd, lvid_s, exclusive, 1);
 }
 
 int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
@@ -760,15 +779,13 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
 	int r = 1;
 
 	if (!lv) {
-		r = dev_manager_mknodes();
+		r = dm_mknodes(NULL);
 		fs_unlock();
 		return r;
 	}
 
-	if (!_lv_info(lv, 1, &info)) {
-		stack;
-		return 0;
-	}
+	if (!_lv_info(cmd, lv, 1, &info, 0))
+		return_0;
 
 	if (info.exists)
 		r = dev_manager_lv_mknodes(lv);
@@ -780,6 +797,34 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
 	return r;
 }
 
+/*
+ * Does PV use VG somewhere in its construction?
+ * Returns 1 on failure.
+ */
+int pv_uses_vg(struct cmd_context *cmd, struct physical_volume *pv,
+               struct volume_group *vg)
+{
+	struct dev_manager *dm;
+	int r;
+
+	if (!activation())
+		return 0;
+
+	if (!dm_is_dm_major(MAJOR(pv->dev->dev)))
+		return 0;
+
+	if (!(dm = dev_manager_create(cmd, vg->name))) {
+		stack;
+		return 1;
+	}
+
+	r = dev_manager_device_uses_vg(dm, pv->dev, vg);
+
+	dev_manager_destroy(dm);
+
+	return r;
+}
+
 void activation_exit(void)
 {
 	dev_manager_exit();

lib/activate/activate.h

@@ -18,10 +18,6 @@
 
 #include "metadata.h"
 
-#ifdef DEVMAPPER_SUPPORT
-#  include <libdevmapper.h>
-#endif
-
 struct lvinfo {
 	int exists;
 	int suspended;
@@ -29,6 +25,8 @@ struct lvinfo {
 	int major;
 	int minor;
 	int read_only;
+	int live_table;
+	int inactive_table;
 };
 
 void set_activation(int activation);
@@ -38,7 +36,7 @@ int driver_version(char *version, size_t size);
 int library_version(char *version, size_t size);
 int lvm1_present(struct cmd_context *cmd);
 
-int target_present(const char *target_name);
+int target_present(const char *target_name, int use_modprobe);
 
 void activation_exit(void);
 
@@ -46,8 +44,9 @@ int lv_suspend(struct cmd_context *cmd, const char *lvid_s);
 int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s);
 int lv_resume(struct cmd_context *cmd, const char *lvid_s);
 int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s);
-int lv_activate(struct cmd_context *cmd, const char *lvid_s);
-int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s);
+int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive);
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s,
+			    int exclusive);
 int lv_deactivate(struct cmd_context *cmd, const char *lvid_s);
 
 int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv);
@@ -55,9 +54,10 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv);
 /*
  * Returns 1 if info structure has been populated, else 0.
  */
-int lv_info(const struct logical_volume *lv, struct lvinfo *info);
+int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, struct lvinfo *info,
+	    int with_open_count);
 int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
-		    struct lvinfo *info);
+		    struct lvinfo *info, int with_open_count);
 
 /*
  * Returns 1 if activate_lv has been set: 1 = activate; 0 = don't.
@@ -69,7 +69,7 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
  * Returns 1 if percent has been set, else 0.
  */
 int lv_snapshot_percent(struct logical_volume *lv, float *percent);
-int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
+int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv, int wait, float *percent,
 		      uint32_t *event_nr);
 
 /*
@@ -78,6 +78,10 @@ int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
 int lvs_in_vg_activated(struct volume_group *vg);
 int lvs_in_vg_opened(struct volume_group *vg);
 
-int lv_setup_cow_store(struct logical_volume *lv);
+/*
+ * Returns 1 if PV has a dependency tree that uses anything in VG.
+ */
+int pv_uses_vg(struct cmd_context *cmd, struct physical_volume *pv,
+	       struct volume_group *vg);
 
 #endif

lib/activate/dev_manager.h

@@ -17,9 +17,11 @@
 #define _LVM_DEV_MANAGER_H
 
 struct logical_volume;
+struct volume_group;
 struct cmd_context;
 struct dev_manager;
 struct dm_info;
+struct device;
 
 /*
  * Constructor and destructor.
@@ -35,8 +37,9 @@ void dev_manager_exit(void);
  * (eg, an origin is created before its snapshot, but is not
  * unsuspended until the snapshot is also created.)
  */
-int dev_manager_info(struct dev_manager *dm, const struct logical_volume *lv,
-		     int mknodes, struct dm_info *info);
+int dev_manager_info(struct dm_pool *mem, const char *name,
+		     const struct logical_volume *lv,
+		     int mknodes, int with_open_count, struct dm_info *info);
 int dev_manager_snapshot_percent(struct dev_manager *dm,
 				 struct logical_volume *lv, float *percent);
 int dev_manager_mirror_percent(struct dev_manager *dm,
@@ -44,15 +47,18 @@ int dev_manager_mirror_percent(struct dev_manager *dm,
 			       float *percent, uint32_t *event_nr);
 int dev_manager_suspend(struct dev_manager *dm, struct logical_volume *lv);
 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_deactivate(struct dev_manager *dm, struct logical_volume *lv);
 
 int dev_manager_lv_mknodes(const struct logical_volume *lv);
 int dev_manager_lv_rmnodes(const struct logical_volume *lv);
-int dev_manager_mknodes(void);
 
 /*
  * Put the desired changes into effect.
  */
 int dev_manager_execute(struct dev_manager *dm);
 
+int dev_manager_device_uses_vg(struct dev_manager *dm, struct device *dev,
+			       struct volume_group *vg);
+
 #endif

lib/activate/fs.c

@@ -20,16 +20,11 @@
 #include "lvm-file.h"
 #include "memlock.h"
 
-#ifdef HAVE_SELINUX
-#  include "selinux.h"
-#endif
-
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <limits.h>
 #include <dirent.h>
-#include <libdevmapper.h>
 
 static int _mk_dir(const char *dev_dir, const char *vg_name)
 {
@@ -65,10 +60,10 @@ static int _rm_dir(const char *dev_dir, const char *vg_name)
 		return 0;
 	}
 
-	log_very_verbose("Removing directory %s", vg_path);
-
-	if (is_empty_dir(vg_path))
+	if (dir_exists(vg_path) && is_empty_dir(vg_path)) {
+		log_very_verbose("Removing directory %s", vg_path);
 		rmdir(vg_path);
+	}
 
 	return 1;
 }
@@ -180,7 +175,7 @@ static int _mk_link(const char *dev_dir, const char *vg_name,
 	}
 
 #ifdef HAVE_SELINUX
-        if (!set_selinux_context(lv_path)) {
+        if (!dm_set_selinux_context(lv_path, S_IFLNK)) {
                 stack;
                 return 0;
         }
@@ -202,9 +197,9 @@ static int _rm_link(const char *dev_dir, const char *vg_name,
 	}
 
 	if (lstat(lv_path, &buf) || !S_ISLNK(buf.st_mode)) {
-		if (errno != ENOENT)
-			log_error("%s not symbolic link - not removing",
-				  lv_path);
+		if (errno == ENOENT)
+			return 1;
+		log_error("%s not symbolic link - not removing", lv_path);
 		return 0;
 	}
 
@@ -283,7 +278,7 @@ static int _stack_fs_op(fs_op_t type, const char *dev_dir, const char *vg_name,
 	    strlen(dev) + strlen(old_lv_name) + 5;
 	char *pos;
 
-	if (!(fsp = dbg_malloc(sizeof(*fsp) + len))) {
+	if (!(fsp = dm_malloc(sizeof(*fsp) + len))) {
 		log_error("No space to stack fs operation");
 		return 0;
 	}
@@ -312,7 +307,7 @@ static void _pop_fs_ops(void)
 		_do_fs_op(fsp->type, fsp->dev_dir, fsp->vg_name, fsp->lv_name,
 			  fsp->dev, fsp->old_lv_name);
 		list_del(&fsp->list);
-		dbg_free(fsp);
+		dm_free(fsp);
 	}
 }
 

lib/activate/targets.h

@@ -19,7 +19,16 @@
 struct dev_manager;
 struct lv_segment;
 
-int compose_areas_line(struct dev_manager *dm, struct lv_segment *seg,                                 char *params, size_t paramsize, int *pos,
-		                        int start_area, int areas);
+int compose_areas_line(struct dev_manager *dm, struct lv_segment *seg,
+		       char *params, size_t paramsize, int *pos,
+		       int start_area, int areas);
+
+int add_areas_line(struct dev_manager *dm, struct lv_segment *seg,
+                   struct dm_tree_node *node, int start_area, int areas);
+
+int build_dev_string(struct dev_manager *dm, char *dlid, char *devbuf,
+		     size_t bufsize, const char *desc);
+
+char *build_dlid(struct dev_manager *dm, const char *lvid, const char *layer);
 
 #endif

lib/cache/lvmcache.c

@@ -16,7 +16,6 @@
 
 #include "lib.h"
 #include "lvmcache.h"
-#include "hash.h"
 #include "toolcontext.h"
 #include "dev-cache.h"
 #include "metadata.h"
@@ -24,10 +23,10 @@
 #include "memlock.h"
 #include "str_list.h"
 
-static struct hash_table *_pvid_hash = NULL;
-static struct hash_table *_vgid_hash = NULL;
-static struct hash_table *_vgname_hash = NULL;
-static struct hash_table *_lock_hash = NULL;
+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 int _has_scanned = 0;
 static int _vgs_locked = 0;
@@ -36,16 +35,16 @@ int lvmcache_init(void)
 {
 	list_init(&_vginfos);
 
-	if (!(_vgname_hash = hash_create(128)))
+	if (!(_vgname_hash = dm_hash_create(128)))
 		return 0;
 
-	if (!(_vgid_hash = hash_create(128)))
+	if (!(_vgid_hash = dm_hash_create(128)))
 		return 0;
 
-	if (!(_pvid_hash = hash_create(128)))
+	if (!(_pvid_hash = dm_hash_create(128)))
 		return 0;
 
-	if (!(_lock_hash = hash_create(128)))
+	if (!(_lock_hash = dm_hash_create(128)))
 		return 0;
 
 	return 1;
@@ -58,25 +57,24 @@ void lvmcache_lock_vgname(const char *vgname, int read_only)
 		return;
 	}
 
-	if (!hash_insert(_lock_hash, vgname, (void *) 1))
+	if (!dm_hash_insert(_lock_hash, vgname, (void *) 1))
 		log_error("Cache locking failure for %s", vgname);
 
 	_vgs_locked++;
 }
 
-static int _vgname_is_locked(const char *vgname) __attribute__ ((unused));
-static int _vgname_is_locked(const char *vgname)
+int vgname_is_locked(const char *vgname)
 {
 	if (!_lock_hash)
 		return 0;
 
-	return hash_lookup(_lock_hash, vgname) ? 1 : 0;
+	return dm_hash_lookup(_lock_hash, vgname) ? 1 : 0;
 }
 
 void lvmcache_unlock_vgname(const char *vgname)
 {
 	/* FIXME: Clear all CACHE_LOCKED flags in this vg */
-	hash_remove(_lock_hash, vgname);
+	dm_hash_remove(_lock_hash, vgname);
 
 	/* FIXME Do this per-VG */
 	if (!--_vgs_locked)
@@ -95,7 +93,7 @@ struct lvmcache_vginfo *vginfo_from_vgname(const char *vgname)
 	if (!_vgname_hash)
 		return NULL;
 
-	if (!(vginfo = hash_lookup(_vgname_hash, vgname)))
+	if (!(vginfo = dm_hash_lookup(_vgname_hash, vgname)))
 		return NULL;
 
 	return vginfo;
@@ -104,10 +102,31 @@ struct lvmcache_vginfo *vginfo_from_vgname(const char *vgname)
 const struct format_type *fmt_from_vgname(const char *vgname)
 {
 	struct lvmcache_vginfo *vginfo;
+	struct lvmcache_info *info;
+	struct label *label;
+	struct list *devh, *tmp;
+	struct list devs;
+	struct device_list *devl;
 
 	if (!(vginfo = vginfo_from_vgname(vgname)))
 		return NULL;
 
+	/* 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) {
+		devl = dm_malloc(sizeof(*devl));
+		devl->dev = info->dev;
+		list_add(&devs, &devl->list);
+	}
+
+	list_iterate_safe(devh, tmp, &devs) {
+		devl = list_item(devh, struct device_list);
+		label_read(devl->dev, &label);
+		list_del(&devl->list);
+		dm_free(devl);
+	}
+
 	return vginfo->fmt;
 }
 
@@ -123,7 +142,7 @@ struct lvmcache_vginfo *vginfo_from_vgid(const char *vgid)
 	strncpy(&id[0], vgid, ID_LEN);
 	id[ID_LEN] = '\0';
 
-	if (!(vginfo = hash_lookup(_vgid_hash, id)))
+	if (!(vginfo = dm_hash_lookup(_vgid_hash, id)))
 		return NULL;
 
 	return vginfo;
@@ -140,7 +159,7 @@ struct lvmcache_info *info_from_pvid(const char *pvid)
 	strncpy(&id[0], pvid, ID_LEN);
 	id[ID_LEN] = '\0';
 
-	if (!(info = hash_lookup(_pvid_hash, id)))
+	if (!(info = dm_hash_lookup(_pvid_hash, id)))
 		return NULL;
 
 	return info;
@@ -156,7 +175,7 @@ static void _rescan_entry(struct lvmcache_info *info)
 
 static int _scan_invalid(void)
 {
-	hash_iter(_pvid_hash, (iterate_fn) _rescan_entry);
+	dm_hash_iter(_pvid_hash, (dm_hash_iterate_fn) _rescan_entry);
 
 	return 1;
 }
@@ -166,7 +185,6 @@ int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)
 	struct label *label;
 	struct dev_iter *iter;
 	struct device *dev;
-	struct list *fmth;
 	struct format_type *fmt;
 
 	static int _scanning_in_progress = 0;
@@ -188,7 +206,7 @@ int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)
 		goto out;
 	}
 
-	if (!(iter = dev_iter_create(cmd->filter))) {
+	if (!(iter = dev_iter_create(cmd->filter, (full_scan == 2) ? 1: 0))) {
 		log_error("dev_iter creation failed");
 		goto out;
 	}
@@ -201,8 +219,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(fmth, &cmd->formats) {
-		fmt = list_item(fmth, struct format_type);
+	list_iterate_items(fmt, &cmd->formats) {
 		if (fmt->ops->scan && !fmt->ops->scan(fmt))
 			goto out;
 	}
@@ -229,7 +246,7 @@ struct list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan)
 
 	list_iterate_items(vgi, &_vginfos) {
 		if (!str_list_add(cmd->mem, vgnames, 
-				  pool_strdup(cmd->mem, vgi->vgname))) {
+				  dm_pool_strdup(cmd->mem, vgi->vgname))) {
 			log_error("strlist allocation failed");
 			return NULL;
 		}
@@ -266,7 +283,7 @@ struct device *device_from_pvid(struct cmd_context *cmd, struct id *pvid)
 	if (memlock())
 		return NULL;
 
-	lvmcache_label_scan(cmd, 1);
+	lvmcache_label_scan(cmd, 2);
 
 	/* Try again */
 	if ((info = info_from_pvid((char *) pvid))) {
@@ -288,13 +305,13 @@ static void _drop_vginfo(struct lvmcache_info *info)
 	}
 
 	if (info->vginfo && list_empty(&info->vginfo->infos)) {
-		hash_remove(_vgname_hash, info->vginfo->vgname);
+		dm_hash_remove(_vgname_hash, info->vginfo->vgname);
 		if (info->vginfo->vgname)
-			dbg_free(info->vginfo->vgname);
+			dm_free(info->vginfo->vgname);
 		if (*info->vginfo->vgid)
-			hash_remove(_vgid_hash, info->vginfo->vgid);
+			dm_hash_remove(_vgid_hash, info->vginfo->vgid);
 		list_del(&info->vginfo->list);
-		dbg_free(info->vginfo);
+		dm_free(info->vginfo);
 	}
 
 	info->vginfo = NULL;
@@ -304,13 +321,13 @@ static void _drop_vginfo(struct lvmcache_info *info)
 void lvmcache_del(struct lvmcache_info *info)
 {
 	if (info->dev->pvid[0] && _pvid_hash)
-		hash_remove(_pvid_hash, info->dev->pvid);
+		dm_hash_remove(_pvid_hash, info->dev->pvid);
 
 	_drop_vginfo(info);
 
 	info->label->labeller->ops->destroy_label(info->label->labeller,
 						info->label); 
-	dbg_free(info);
+	dm_free(info);
 
 	return;
 } */
@@ -320,10 +337,10 @@ static int _lvmcache_update_pvid(struct lvmcache_info *info, const char *pvid)
 	if (!strcmp(info->dev->pvid, pvid))
 		return 1;
 	if (*info->dev->pvid) {
-		hash_remove(_pvid_hash, info->dev->pvid);
+		dm_hash_remove(_pvid_hash, info->dev->pvid);
 	}
 	strncpy(info->dev->pvid, pvid, sizeof(info->dev->pvid));
-	if (!hash_insert(_pvid_hash, pvid, info)) {
+	if (!dm_hash_insert(_pvid_hash, pvid, info)) {
 		log_error("_lvmcache_update: pvid insertion failed: %s", pvid);
 		return 0;
 	}
@@ -338,13 +355,13 @@ static int _lvmcache_update_vgid(struct lvmcache_info *info, const char *vgid)
 		return 1;
 
 	if (info->vginfo && *info->vginfo->vgid)
-		hash_remove(_vgid_hash, info->vginfo->vgid);
+		dm_hash_remove(_vgid_hash, info->vginfo->vgid);
 	if (!vgid)
 		return 1;
 
 	strncpy(info->vginfo->vgid, vgid, sizeof(info->vginfo->vgid));
 	info->vginfo->vgid[sizeof(info->vginfo->vgid) - 1] = '\0';
-	if (!hash_insert(_vgid_hash, info->vginfo->vgid, info->vginfo)) {
+	if (!dm_hash_insert(_vgid_hash, info->vginfo->vgid, info->vginfo)) {
 		log_error("_lvmcache_update: vgid hash insertion failed: %s",
 			  info->vginfo->vgid);
 		return 0;
@@ -372,22 +389,22 @@ int lvmcache_update_vgname(struct lvmcache_info *info, const char *vgname)
 
 	/* Get existing vginfo or create new one */
 	if (!(vginfo = vginfo_from_vgname(vgname))) {
-		if (!(vginfo = dbg_malloc(sizeof(*vginfo)))) {
+		if (!(vginfo = dm_malloc(sizeof(*vginfo)))) {
 			log_error("lvmcache_update_vgname: list alloc failed");
 			return 0;
 		}
 		memset(vginfo, 0, sizeof(*vginfo));
-		if (!(vginfo->vgname = dbg_strdup(vgname))) {
-			dbg_free(vginfo);
+		if (!(vginfo->vgname = dm_strdup(vgname))) {
+			dm_free(vginfo);
 			log_error("cache vgname alloc failed for %s", vgname);
 			return 0;
 		}
 		list_init(&vginfo->infos);
-		if (!hash_insert(_vgname_hash, vginfo->vgname, vginfo)) {
+		if (!dm_hash_insert(_vgname_hash, vginfo->vgname, vginfo)) {
 			log_error("cache_update: vg hash insertion failed: %s",
 				  vginfo->vgname);
-			dbg_free(vginfo->vgname);
-			dbg_free(vginfo);
+			dm_free(vginfo->vgname);
+			dm_free(vginfo);
 			return 0;
 		}
 		/* Ensure orphans appear last on list_iterate */
@@ -403,23 +420,24 @@ int lvmcache_update_vgname(struct lvmcache_info *info, const char *vgname)
 	/* FIXME Check consistency of list! */
 	vginfo->fmt = info->fmt;
 
+	log_debug("lvmcache: %s now %s%s", dev_name(info->dev),
+		  *vgname ? "in VG " : "orphaned", vgname);
+
 	return 1;
 }
 
 int lvmcache_update_vg(struct volume_group *vg)
 {
-	struct list *pvh;
-	struct physical_volume *pv;
+	struct pv_list *pvl;
 	struct lvmcache_info *info;
 	char pvid_s[ID_LEN + 1];
 	int vgid_updated = 0;
 
 	pvid_s[sizeof(pvid_s) - 1] = '\0';
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
-		strncpy(pvid_s, (char *) &pv->id, sizeof(pvid_s) - 1);
-		/* FIXME Could pv->dev->pvid ever be different? */
+	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))) {
 			lvmcache_update_vgname(info, vg->name);
 			if (!vgid_updated) {
@@ -454,7 +472,7 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 			stack;
 			return NULL;
 		}
-		if (!(info = dbg_malloc(sizeof(*info)))) {
+		if (!(info = dm_malloc(sizeof(*info)))) {
 			log_error("lvmcache_info allocation failed");
 			label_destroy(label);
 			return NULL;
@@ -475,17 +493,36 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 						 pvid, dev_name(dev),
 						 dev_name(existing->dev));
 				return NULL;
+			} else if (dm_is_dm_major(MAJOR(existing->dev->dev)) &&
+				   !dm_is_dm_major(MAJOR(dev->dev))) {
+				log_very_verbose("Ignoring duplicate PV %s on "
+						 "%s - using dm %s",
+						 pvid, dev_name(dev),
+						 dev_name(existing->dev));
+				return NULL;
 			} else if (MAJOR(existing->dev->dev) != md_major() &&
 				   MAJOR(dev->dev) == md_major())
 				log_very_verbose("Duplicate PV %s on %s - "
 						 "using md %s", pvid,
 						 dev_name(existing->dev),
 						 dev_name(dev));
+			else if (!dm_is_dm_major(MAJOR(existing->dev->dev)) &&
+				 dm_is_dm_major(MAJOR(dev->dev)))
+				log_very_verbose("Duplicate PV %s on %s - "
+						 "using dm %s", pvid,
+						 dev_name(existing->dev),
+						 dev_name(dev));
+			/* FIXME If both dm, check dependencies */
+			//else if (dm_is_dm_major(MAJOR(existing->dev->dev)) &&
+				 //dm_is_dm_major(MAJOR(dev->dev)))
+				 //
 			else
 				log_error("Found duplicate PV %s: using %s not "
 					  "%s", pvid, dev_name(dev),
 					  dev_name(existing->dev));
 		}
+		/* Switch over to new preferred device */
+		existing->dev = dev;
 		info = existing;
 		/* Has labeller changed? */
 		if (info->label->labeller != labeller) {
@@ -505,7 +542,7 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 
 	if (!_lvmcache_update_pvid(info, pvid_s)) {
 		if (!existing) {
-			dbg_free(info);
+			dm_free(info);
 			label_destroy(label);
 		}
 		return NULL;
@@ -513,9 +550,9 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 
 	if (!lvmcache_update_vgname(info, vgname)) {
 		if (!existing) {
-			hash_remove(_pvid_hash, pvid_s);
+			dm_hash_remove(_pvid_hash, pvid_s);
 			strcpy(info->dev->pvid, "");
-			dbg_free(info);
+			dm_free(info);
 			label_destroy(label);
 		}
 		return NULL;
@@ -534,14 +571,14 @@ static void _lvmcache_destroy_entry(struct lvmcache_info *info)
 		list_del(&info->list);
 	strcpy(info->dev->pvid, "");
 	label_destroy(info->label);
-	dbg_free(info);
+	dm_free(info);
 }
 
 static void _lvmcache_destroy_vgnamelist(struct lvmcache_vginfo *vginfo)
 {
 	if (vginfo->vgname)
-		dbg_free(vginfo->vgname);
-	dbg_free(vginfo);
+		dm_free(vginfo->vgname);
+	dm_free(vginfo);
 }
 
 static void _lvmcache_destroy_lockname(int present)
@@ -551,29 +588,31 @@ static void _lvmcache_destroy_lockname(int present)
 
 void lvmcache_destroy(void)
 {
+	log_verbose("Wiping internal VG cache");
+
 	_has_scanned = 0;
 
 	if (_vgid_hash) {
-		hash_destroy(_vgid_hash);
+		dm_hash_destroy(_vgid_hash);
 		_vgid_hash = NULL;
 	}
 
 	if (_pvid_hash) {
-		hash_iter(_pvid_hash, (iterate_fn) _lvmcache_destroy_entry);
-		hash_destroy(_pvid_hash);
+		dm_hash_iter(_pvid_hash, (dm_hash_iterate_fn) _lvmcache_destroy_entry);
+		dm_hash_destroy(_pvid_hash);
 		_pvid_hash = NULL;
 	}
 
 	if (_vgname_hash) {
-		hash_iter(_vgname_hash,
-			  (iterate_fn) _lvmcache_destroy_vgnamelist);
-		hash_destroy(_vgname_hash);
+		dm_hash_iter(_vgname_hash,
+			  (dm_hash_iterate_fn) _lvmcache_destroy_vgnamelist);
+		dm_hash_destroy(_vgname_hash);
 		_vgname_hash = NULL;
 	}
 
 	if (_lock_hash) {
-		hash_iter(_lock_hash, (iterate_fn) _lvmcache_destroy_lockname);
-		hash_destroy(_lock_hash);
+		dm_hash_iter(_lock_hash, (dm_hash_iterate_fn) _lvmcache_destroy_lockname);
+		dm_hash_destroy(_lock_hash);
 		_lock_hash = NULL;
 	}
 

lib/cache/lvmcache.h

@@ -36,9 +36,10 @@ struct volume_group;
 struct lvmcache_vginfo {
 	struct list list;	/* Join these vginfos together */
 	struct list infos;	/* List head for lvmcache_infos */
+	const struct format_type *fmt;
 	char *vgname;		/* "" == orphan */
 	char vgid[ID_LEN + 1];
-	const struct format_type *fmt;
+	char _padding[7];
 };
 
 struct lvmcache_info {
@@ -56,7 +57,8 @@ struct lvmcache_info {
 int lvmcache_init(void);
 void lvmcache_destroy(void);
 
-/* Set full_scan to 1 to reread every filtered device label */
+/* Set full_scan to 1 to reread every filtered device label or
+ * 2 to rescan /dev for new devices */
 int lvmcache_label_scan(struct cmd_context *cmd, int full_scan);
 
 /* Add/delete a device */
@@ -79,6 +81,7 @@ struct lvmcache_vginfo *vginfo_from_vgid(const char *vgid);
 struct lvmcache_info *info_from_pvid(const char *pvid);
 struct device *device_from_pvid(struct cmd_context *cmd, struct id *pvid);
 int vgs_locked(void);
+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 */

lib/commands/toolcontext.c

@@ -16,7 +16,6 @@
 
 #include "lib.h"
 #include "toolcontext.h"
-#include "pool.h"
 #include "metadata.h"
 #include "defaults.h"
 #include "lvm-string.h"
@@ -35,6 +34,8 @@
 #include "str_list.h"
 #include "segtype.h"
 #include "lvmcache.h"
+#include "dev-cache.h"
+#include "archiver.h"
 
 #ifdef HAVE_LIBDL
 #include "sharedlib.h"
@@ -181,6 +182,12 @@ static int _process_config(struct cmd_context *cmd)
 		return 0;
 	}
 
+	if (*cmd->proc_dir && !dir_exists(cmd->proc_dir)) {
+		log_error("Warning: proc dir %s not found - some checks will be bypassed",
+			  cmd->proc_dir);
+		cmd->proc_dir[0] = '\0';
+	}
+
 	/* activation? */
 	cmd->default_settings.activation = find_config_int(cmd->cft->root,
 							   "global/activation",
@@ -205,7 +212,7 @@ static int _process_config(struct cmd_context *cmd)
 
 static int _set_tag(struct cmd_context *cmd, const char *tag)
 {
-	log_very_verbose("Setting host tag: %s", pool_strdup(cmd->libmem, tag));
+	log_very_verbose("Setting host tag: %s", dm_pool_strdup(cmd->libmem, tag));
 
 	if (!str_list_add(cmd->libmem, &cmd->tags, tag)) {
 		log_error("_set_tag: str_list_add %s failed", tag);
@@ -315,7 +322,7 @@ static int _load_config_file(struct cmd_context *cmd, const char *tag)
 		return 0;
 	}
 
-	if (!(cfl = pool_alloc(cmd->libmem, sizeof(*cfl)))) {
+	if (!(cfl = dm_pool_alloc(cmd->libmem, sizeof(*cfl)))) {
 		log_error("config_tree_list allocation failed");
 		return 0;
 	}
@@ -487,6 +494,24 @@ static int _init_dev_cache(struct cmd_context *cmd)
 		}
 	}
 
+	if (!(cn = find_config_node(cmd->cft->root, "devices/loopfiles")))
+		return 1;
+
+	for (cv = cn->v; cv; cv = cv->next) {
+		if (cv->type != CFG_STRING) {
+			log_error("Invalid string in config file: "
+				  "devices/loopfiles");
+			return 0;
+		}
+
+		if (!dev_cache_add_loopfile(cv->v.str)) {
+			log_error("Failed to add loopfile %s to internal "
+				  "device cache", cv->v.str);
+			return 0;
+		}
+	}
+
+
 	return 1;
 }
 
@@ -519,8 +544,8 @@ static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
 
 	/* regex filter. Optional. */
 	if (!(cn = find_config_node(cmd->cft->root, "devices/filter")))
-		log_debug("devices/filter not found in config file: no regex "
-			  "filter installed");
+		log_very_verbose("devices/filter not found in config file: "
+				 "no regex filter installed");
 
 	else if (!(filters[nr_filt++] = regex_filter_create(cn->v))) {
 		log_error("Failed to create regex device filter");
@@ -537,6 +562,7 @@ static struct dev_filter *_init_filter_components(struct cmd_context *cmd)
 	/* md component filter. Optional, non-critical. */
 	if (find_config_bool(cmd->cft->root, "devices/md_component_detection",
 			     DEFAULT_MD_COMPONENT_DETECTION)) {
+		init_md_filtering(1);
 		if ((filters[nr_filt] = md_filter_create()))
 			nr_filt++;
 	}
@@ -595,7 +621,6 @@ static int _init_formats(struct cmd_context *cmd)
 	const char *format;
 
 	struct format_type *fmt;
-	struct list *fmth;
 
 #ifdef HAVE_LIBDL
 	const struct config_node *cn;
@@ -662,8 +687,7 @@ static int _init_formats(struct cmd_context *cmd)
 	format = find_config_str(cmd->cft->root, "global/format",
 				 DEFAULT_FORMAT);
 
-	list_iterate(fmth, &cmd->formats) {
-		fmt = list_item(fmth, struct format_type);
+	list_iterate_items(fmt, &cmd->formats) {
 		if (!strcasecmp(fmt->name, format) ||
 		    (fmt->alias && !strcasecmp(fmt->alias, format))) {
 			cmd->default_settings.fmt = fmt;
@@ -775,13 +799,76 @@ static int _init_hostname(struct cmd_context *cmd)
 		return 0;
 	}
 
-	if (!(cmd->hostname = pool_strdup(cmd->libmem, uts.nodename))) {
-		log_error("_init_hostname: pool_strdup failed");
+	if (!(cmd->hostname = dm_pool_strdup(cmd->libmem, uts.nodename))) {
+		log_error("_init_hostname: dm_pool_strdup failed");
 		return 0;
 	}
 
-	if (!(cmd->kernel_vsn = pool_strdup(cmd->libmem, uts.release))) {
-		log_error("_init_hostname: pool_strdup kernel_vsn failed");
+	if (!(cmd->kernel_vsn = dm_pool_strdup(cmd->libmem, uts.release))) {
+		log_error("_init_hostname: dm_pool_strdup kernel_vsn failed");
+		return 0;
+	}
+
+	return 1;
+}
+
+static int _init_backup(struct cmd_context *cmd)
+{
+	uint32_t days, min;
+	char default_dir[PATH_MAX];
+	const char *dir;
+
+	if (!cmd->sys_dir) {
+		log_warn("WARNING: Metadata changes will NOT be backed up");
+		backup_init(cmd, "");
+		archive_init(cmd, "", 0, 0);
+		return 1;
+	}
+
+	/* set up archiving */
+	cmd->default_settings.archive =
+	    find_config_bool(cmd->cft->root, "backup/archive",
+			     DEFAULT_ARCHIVE_ENABLED);
+
+	days = (uint32_t) find_config_int(cmd->cft->root, "backup/retain_days",
+					  DEFAULT_ARCHIVE_DAYS);
+
+	min = (uint32_t) find_config_int(cmd->cft->root, "backup/retain_min",
+					 DEFAULT_ARCHIVE_NUMBER);
+
+	if (lvm_snprintf
+	    (default_dir, sizeof(default_dir), "%s/%s", cmd->sys_dir,
+	     DEFAULT_ARCHIVE_SUBDIR) == -1) {
+		log_err("Couldn't create default archive path '%s/%s'.",
+			cmd->sys_dir, DEFAULT_ARCHIVE_SUBDIR);
+		return 0;
+	}
+
+	dir = find_config_str(cmd->cft->root, "backup/archive_dir",
+			      default_dir);
+
+	if (!archive_init(cmd, dir, days, min)) {
+		log_debug("backup_init failed.");
+		return 0;
+	}
+
+	/* set up the backup */
+	cmd->default_settings.backup =
+	    find_config_bool(cmd->cft->root, "backup/backup",
+			     DEFAULT_BACKUP_ENABLED);
+
+	if (lvm_snprintf
+	    (default_dir, sizeof(default_dir), "%s/%s", cmd->sys_dir,
+	     DEFAULT_BACKUP_SUBDIR) == -1) {
+		log_err("Couldn't create default backup path '%s/%s'.",
+			cmd->sys_dir, DEFAULT_BACKUP_SUBDIR);
+		return 0;
+	}
+
+	dir = find_config_str(cmd->cft->root, "backup/backup_dir", default_dir);
+
+	if (!backup_init(cmd, dir)) {
+		log_debug("backup_init failed.");
 		return 0;
 	}
 
@@ -806,7 +893,7 @@ struct cmd_context *create_toolcontext(struct arg *the_args)
 
 	init_syslog(DEFAULT_LOG_FACILITY);
 
-	if (!(cmd = dbg_malloc(sizeof(*cmd)))) {
+	if (!(cmd = dm_malloc(sizeof(*cmd)))) {
 		log_error("Failed to allocate command context");
 		return NULL;
 	}
@@ -824,10 +911,15 @@ struct cmd_context *create_toolcontext(struct arg *the_args)
 		goto error;
 
 	/* Create system directory if it doesn't already exist */
-	if (*cmd->sys_dir && !create_dir(cmd->sys_dir))
+	if (*cmd->sys_dir && !create_dir(cmd->sys_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 "
+			  "or empty string.");
 		goto error;
+	}
 
-	if (!(cmd->libmem = pool_create(4 * 1024))) {
+	if (!(cmd->libmem = dm_pool_create("library", 4 * 1024))) {
 		log_error("Library memory pool creation failed");
 		return 0;
 	}
@@ -858,7 +950,7 @@ struct cmd_context *create_toolcontext(struct arg *the_args)
 	if (!_init_filters(cmd))
 		goto error;
 
-	if (!(cmd->mem = pool_create(4 * 1024))) {
+	if (!(cmd->mem = dm_pool_create("command", 4 * 1024))) {
 		log_error("Command memory pool creation failed");
 		return 0;
 	}
@@ -871,13 +963,16 @@ struct cmd_context *create_toolcontext(struct arg *the_args)
 	if (!_init_segtypes(cmd))
 		goto error;
 
+	if (!_init_backup(cmd))
+		goto error;
+
 	cmd->current_settings = cmd->default_settings;
 
 	cmd->config_valid = 1;
 	return cmd;
 
       error:
-	dbg_free(cmd);
+	dm_free(cmd);
 	return NULL;
 }
 
@@ -981,21 +1076,22 @@ void destroy_toolcontext(struct cmd_context *cmd)
 	if (cmd->dump_filter)
 		persistent_filter_dump(cmd->filter);
 
-	activation_exit();
+	archive_exit(cmd);
+	backup_exit(cmd);
 	lvmcache_destroy();
 	label_exit();
 	_destroy_segtypes(&cmd->segtypes);
 	_destroy_formats(&cmd->formats);
 	cmd->filter->destroy(cmd->filter);
-	pool_destroy(cmd->mem);
+	dm_pool_destroy(cmd->mem);
 	dev_cache_exit();
 	_destroy_tags(cmd);
 	_destroy_tag_configs(cmd);
-	pool_destroy(cmd->libmem);
-	dbg_free(cmd);
+	dm_pool_destroy(cmd->libmem);
+	dm_free(cmd);
 
 	release_log_memory();
-	dump_memory();
+	activation_exit();
 	fin_log();
 	fin_syslog();
 

lib/commands/toolcontext.h

@@ -17,7 +17,6 @@
 #define _LVM_TOOLCONTEXT_H
 
 #include "dev-cache.h"
-#include "pool.h"
 
 #include <stdio.h>
 #include <limits.h>
@@ -32,26 +31,26 @@ struct config_info {
 	int syslog;
 	int activation;
 	int suffix;
-	uint64_t unit_factor;
-	char unit_type;
-	const char *msg_prefix;
-	int cmd_name;		/* Show command name? */
-
 	int archive;		/* should we archive ? */
 	int backup;		/* should we backup ? */
-
+	const char *msg_prefix;
 	struct format_type *fmt;
-
+	uint64_t unit_factor;
+	int cmd_name;		/* Show command name? */
 	mode_t umask;
+	char unit_type;
+	char _padding[1];
 };
 
 struct config_tree;
+struct archive_params;
+struct backup_params;
 
 /* FIXME Split into tool & library contexts */
 /* command-instance-related variables needed by library */
 struct cmd_context {
-	struct pool *libmem;	/* For permanent config data */
-	struct pool *mem;	/* Transient: Cleared between each command */
+	struct dm_pool *libmem;	/* For permanent config data */
+	struct dm_pool *mem;	/* Transient: Cleared between each command */
 
 	const struct format_type *fmt;	/* Current format to use by default */
 	struct format_type *fmt_backup;	/* Format to use for backups */
@@ -75,6 +74,9 @@ struct cmd_context {
 	struct config_info default_settings;
 	struct config_info current_settings;
 
+	struct archive_params *archive_params;
+	struct backup_params *backup_params;
+
 	/* List of defined tags */
 	struct list tags;
 	int hosttags;

lib/config/config.c

@@ -16,7 +16,6 @@
 #include "lib.h"
 #include "config.h"
 #include "crc.h"
-#include "pool.h"
 #include "device.h"
 #include "str_list.h"
 #include "toolcontext.h"
@@ -50,12 +49,12 @@ struct parser {
 	int fd;			/* descriptor for file being parsed */
 	int line;		/* line number we are on */
 
-	struct pool *mem;
+	struct dm_pool *mem;
 };
 
 struct cs {
 	struct config_tree cft;
-	struct pool *mem;
+	struct dm_pool *mem;
 	time_t timestamp;
 	char *filename;
 	int exists;
@@ -99,16 +98,16 @@ static int _tok_match(const char *str, const char *b, const char *e)
 struct config_tree *create_config_tree(const char *filename)
 {
 	struct cs *c;
-	struct pool *mem = pool_create(10 * 1024);
+	struct dm_pool *mem = dm_pool_create("config", 10 * 1024);
 
 	if (!mem) {
 		stack;
 		return 0;
 	}
 
-	if (!(c = pool_zalloc(mem, sizeof(*c)))) {
+	if (!(c = dm_pool_zalloc(mem, sizeof(*c)))) {
 		stack;
-		pool_destroy(mem);
+		dm_pool_destroy(mem);
 		return 0;
 	}
 
@@ -117,13 +116,13 @@ struct config_tree *create_config_tree(const char *filename)
 	c->timestamp = 0;
 	c->exists = 0;
 	if (filename)
-		c->filename = pool_strdup(c->mem, filename);
+		c->filename = dm_pool_strdup(c->mem, filename);
 	return &c->cft;
 }
 
 void destroy_config_tree(struct config_tree *cft)
 {
-	pool_destroy(((struct cs *) cft)->mem);
+	dm_pool_destroy(((struct cs *) cft)->mem);
 }
 
 int read_config_fd(struct config_tree *cft, struct device *dev,
@@ -136,7 +135,7 @@ int read_config_fd(struct config_tree *cft, struct device *dev,
 	int use_mmap = 1;
 	off_t mmap_offset = 0;
 
-	if (!(p = pool_alloc(c->mem, sizeof(*p)))) {
+	if (!(p = dm_pool_alloc(c->mem, sizeof(*p)))) {
 		stack;
 		return 0;
 	}
@@ -157,7 +156,7 @@ int read_config_fd(struct config_tree *cft, struct device *dev,
 		}
 		p->fb = p->fb + mmap_offset;
 	} else {
-		if (!(p->fb = dbg_malloc(size + size2))) {
+		if (!(p->fb = dm_malloc(size + size2))) {
 			stack;
 			return 0;
 		}
@@ -197,7 +196,7 @@ int read_config_fd(struct config_tree *cft, struct device *dev,
 
       out:
 	if (!use_mmap)
-		dbg_free(p->fb);
+		dm_free(p->fb);
 	else {
 		/* unmap the file */
 		if (munmap((char *) (p->fb - mmap_offset), size + mmap_offset)) {
@@ -235,7 +234,7 @@ int read_config_file(struct config_tree *cft)
 		return 1;
 	}
 
-	if (!(dev = dev_create_file(c->filename, NULL, NULL))) {
+	if (!(dev = dev_create_file(c->filename, NULL, NULL, 1))) {
 		stack;
 		return 0;
 	}
@@ -688,14 +687,14 @@ static void _eat_space(struct parser *p)
  */
 static struct config_value *_create_value(struct parser *p)
 {
-	struct config_value *v = pool_alloc(p->mem, sizeof(*v));
+	struct config_value *v = dm_pool_alloc(p->mem, sizeof(*v));
 	memset(v, 0, sizeof(*v));
 	return v;
 }
 
 static struct config_node *_create_node(struct parser *p)
 {
-	struct config_node *n = pool_alloc(p->mem, sizeof(*n));
+	struct config_node *n = dm_pool_alloc(p->mem, sizeof(*n));
 	memset(n, 0, sizeof(*n));
 	return n;
 }
@@ -703,7 +702,7 @@ static struct config_node *_create_node(struct parser *p)
 static char *_dup_tok(struct parser *p)
 {
 	size_t len = p->te - p->tb;
-	char *str = pool_alloc(p->mem, len + 1);
+	char *str = dm_pool_alloc(p->mem, len + 1);
 	if (!str) {
 		stack;
 		return 0;

lib/config/config.h

@@ -16,6 +16,8 @@
 #ifndef _LVM_CONFIG_H
 #define _LVM_CONFIG_H
 
+#include "lvm-types.h"
+
 struct device;
 struct cmd_context;
 

lib/config/defaults.h

@@ -91,19 +91,22 @@
 #define DEFAULT_REP_HEADINGS 1
 #define DEFAULT_REP_SEPARATOR " "
 
-#define DEFAULT_LVS_COLS "lv_name,vg_name,lv_attr,lv_size,origin,snap_percent,move_pv,copy_percent"
+#define DEFAULT_LVS_COLS "lv_name,vg_name,lv_attr,lv_size,origin,snap_percent,move_pv,mirror_log,copy_percent"
 #define DEFAULT_VGS_COLS "vg_name,pv_count,lv_count,snap_count,vg_attr,vg_size,vg_free"
 #define DEFAULT_PVS_COLS "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free"
 #define DEFAULT_SEGS_COLS "lv_name,vg_name,lv_attr,stripes,segtype,seg_size"
+#define DEFAULT_PVSEGS_COLS "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size"
 
-#define DEFAULT_LVS_COLS_VERB "lv_name,vg_name,seg_count,lv_attr,lv_size,lv_major,lv_minor,lv_kernel_major,lv_kernel_minor,origin,snap_percent,move_pv,copy_percent,lv_uuid"
+#define DEFAULT_LVS_COLS_VERB "lv_name,vg_name,seg_count,lv_attr,lv_size,lv_major,lv_minor,lv_kernel_major,lv_kernel_minor,origin,snap_percent,move_pv,copy_percent,mirror_log,lv_uuid"
 #define DEFAULT_VGS_COLS_VERB "vg_name,vg_attr,vg_extent_size,pv_count,lv_count,snap_count,vg_size,vg_free,vg_uuid"
 #define DEFAULT_PVS_COLS_VERB "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,dev_size,pv_uuid"
 #define DEFAULT_SEGS_COLS_VERB "lv_name,vg_name,lv_attr,seg_start,seg_size,stripes,segtype,stripesize,chunksize"
+#define DEFAULT_PVSEGS_COLS_VERB "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free,pvseg_start,pvseg_size"
 
 #define DEFAULT_LVS_SORT "vg_name,lv_name"
 #define DEFAULT_VGS_SORT "vg_name"
 #define DEFAULT_PVS_SORT "pv_name"
 #define DEFAULT_SEGS_SORT "vg_name,lv_name,seg_start"
+#define DEFAULT_PVSEGS_SORT "pv_name,pvseg_start"
 
 #endif				/* _LVM_DEFAULTS_H */

lib/datastruct/btree.c

@@ -24,13 +24,13 @@ struct node {
 };
 
 struct btree {
-	struct pool *mem;
+	struct dm_pool *mem;
 	struct node *root;
 };
 
-struct btree *btree_create(struct pool *mem)
+struct btree *btree_create(struct dm_pool *mem)
 {
-	struct btree *t = pool_alloc(mem, sizeof(*t));
+	struct btree *t = dm_pool_alloc(mem, sizeof(*t));
 
 	if (t) {
 		t->mem = mem;
@@ -86,7 +86,7 @@ int btree_insert(struct btree *t, uint32_t k, void *data)
 	struct node *p, **c = _lookup(&t->root, key, &p), *n;
 
 	if (!*c) {
-		if (!(n = pool_alloc(t->mem, sizeof(*n)))) {
+		if (!(n = dm_pool_alloc(t->mem, sizeof(*n)))) {
 			stack;
 			return 0;
 		}

lib/datastruct/btree.h

@@ -16,11 +16,9 @@
 #ifndef _LVM_BTREE_H
 #define _LVM_BTREE_H
 
-#include "pool.h"
-
 struct btree;
 
-struct btree *btree_create(struct pool *mem);
+struct btree *btree_create(struct dm_pool *mem);
 
 void *btree_lookup(struct btree *t, uint32_t k);
 int btree_insert(struct btree *t, uint32_t k, void *data);

lib/datastruct/list.h

@@ -18,17 +18,30 @@
 
 #include <assert.h>
 
+/*
+ * A list consists of a list head plus elements.
+ * Each element has 'next' and 'previous' pointers.
+ * The list head's pointers point to the first and the last element.
+ */
+
 struct list {
 	struct 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) }
-
 static inline void list_init(struct list *head)
 {
 	head->n = head->p = head;
 }
 
+/*
+ * Insert an element before 'head'.
+ * If 'head' is the list head, this adds an element to the end of the list.
+ */
 static inline void list_add(struct list *head, struct list *elem)
 {
 	assert(head->n);
@@ -40,6 +53,10 @@ static inline void list_add(struct list *head, struct list *elem)
 	head->p = elem;
 }
 
+/*
+ * Insert an element after 'head'.
+ * If 'head' is the list head, this adds an element to the front of the list.
+ */
 static inline void list_add_h(struct list *head, struct list *elem)
 {
 	assert(head->n);
@@ -51,53 +68,182 @@ static inline void list_add_h(struct list *head, struct list *elem)
 	head->n = 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.
+ */
 static inline void list_del(struct list *elem)
 {
 	elem->n->p = elem->p;
 	elem->p->n = elem->n;
 }
 
+/*
+ * Is the list empty?
+ */
 static inline int list_empty(struct list *head)
 {
 	return head->n == head;
 }
 
+/*
+ * Is this the first element of the list?
+ */
+static inline int list_start(struct list *head, struct list *elem)
+{
+	return elem->p == head;
+}
+
+/*
+ * Is this the last element of the list?
+ */
 static inline int list_end(struct list *head, struct list *elem)
 {
 	return elem->n == head;
 }
 
+/*
+ * Return first element of the list or NULL if empty
+ */
+static inline struct list *list_first(struct list *head)
+{
+	return (list_empty(head) ? NULL : head->n);
+}
+
+/*
+ * Return last element of the list or NULL if empty
+ */
+static inline struct list *list_last(struct list *head)
+{
+	return (list_empty(head) ? NULL : head->p);
+}
+
+/*
+ * Return the previous element of the list, or NULL if we've reached the start.
+ */
+static inline struct list *list_prev(struct list *head, struct list *elem)
+{
+	return (list_start(head, elem) ? NULL : elem->p);
+}
+
+/*
+ * Return the next element of the list, or NULL if we've reached the end.
+ */
 static inline struct list *list_next(struct list *head, struct list *elem)
 {
 	return (list_end(head, elem) ? NULL : elem->n);
 }
 
-#define list_item(v, t) \
-    ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->list))
+/*
+ * Given the address v of an instance of 'struct list' called 'head' 
+ * contained in a structure of type t, return the containing structure.
+ */
+#define list_struct_base(v, t, head) \
+    ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->head))
 
-#define list_struct_base(v, t, h) \
-    ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->h))
+/*
+ * Given the address v of an instance of 'struct list list' contained in
+ * a structure of type t, return the containing structure.
+ */
+#define list_item(v, t) list_struct_base((v), t, list)
 
-/* Given a known element in a known structure, locate another */
+/*
+ * 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) \
     (((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->e))->f)
 
-/* Given a known element in a known structure, locate the list head */
+/*
+ * 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)
 
+/*
+ * Set v to each element of a list in turn.
+ */
 #define list_iterate(v, head) \
 	for (v = (head)->n; v != head; v = v->n)
 
+/*
+ * Set v to each element in a list in turn, starting from the element 
+ * in front of 'start'.
+ * You can use this to 'unwind' a list_iterate and back out actions on
+ * already-processed elements.
+ * If 'start' is 'head' it walks the list backwards.
+ */
 #define list_uniterate(v, head, start) \
 	for (v = (start)->p; v != head; v = v->p)
 
+/*
+ * A safe way to walk a list and delete and free some elements along
+ * the way.
+ * t must be defined as a temporary variable of the same type as v.
+ */
 #define list_iterate_safe(v, t, head) \
 	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)
 
-#define list_iterate_items(v, head) \
-	for (v = list_item((head)->n, typeof(*v)); &v->list != (head); \
-	     v = list_item(v->list.n, typeof(*v)))
+/*
+ * 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'.
+ */
+#define list_iterate_items_gen(v, head, field) \
+	for (v = list_struct_base((head)->n, typeof(*v), field); \
+	     &v->field != (head); \
+	     v = 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.
+ */
+#define list_iterate_items(v, head) 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'.
+ * 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); \
+	     &v->field != (head); \
+	     v = t, t = 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.
+ * 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)
+
+/*
+ * 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'.
+ */
+#define list_iterate_back_items_gen(v, head, field) \
+	for (v = list_struct_base((head)->p, typeof(*v), field); \
+	     &v->field != (head); \
+	     v = 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.
+ */
+#define list_iterate_back_items(v, head) list_iterate_back_items_gen(v, (head), list)
+
+/*
+ * Return the number of elements in a list by walking it.
+ */
 static inline unsigned int list_size(const struct list *head)
 {
 	unsigned int s = 0;

lib/datastruct/lvm-types.h

@@ -22,7 +22,7 @@
 #include <inttypes.h>
 
 /* Define some portable printing types */
-#define PRIsize_t "Zu"
+#define PRIsize_t "zu"
 
 struct str_list {
 	struct list list;

lib/datastruct/str_list.c

@@ -16,11 +16,11 @@
 #include "lib.h"
 #include "str_list.h"
 
-struct list *str_list_create(struct pool *mem)
+struct list *str_list_create(struct dm_pool *mem)
 {
 	struct list *sl;
 
-	if (!(sl = pool_alloc(mem, sizeof(struct list)))) {
+	if (!(sl = dm_pool_alloc(mem, sizeof(struct list)))) {
 		stack;
 		return NULL;
 	}
@@ -30,7 +30,7 @@ struct list *str_list_create(struct pool *mem)
 	return sl;
 }
 
-int str_list_add(struct pool *mem, struct list *sll, const char *str)
+int str_list_add(struct dm_pool *mem, struct list *sll, const char *str)
 {
 	struct str_list *sln;
 
@@ -43,7 +43,7 @@ int str_list_add(struct pool *mem, struct list *sll, const char *str)
 	if (str_list_match_item(sll, str))
 		return 1;
 
-	if (!(sln = pool_alloc(mem, sizeof(*sln)))) {
+	if (!(sln = dm_pool_alloc(mem, sizeof(*sln)))) {
 		stack;
 		return 0;
 	}
@@ -66,7 +66,7 @@ int str_list_del(struct list *sll, const char *str)
 	return 1;
 }
 
-int str_list_dup(struct pool *mem, struct list *sllnew, struct list *sllold)
+int str_list_dup(struct dm_pool *mem, struct list *sllnew, struct list *sllold)
 {
 	struct str_list *sl;
 

lib/datastruct/str_list.h

@@ -16,14 +16,12 @@
 #ifndef _LVM_STR_LIST_H
 #define _LVM_STR_LIST_H
 
-#include "pool.h"
-
-struct list *str_list_create(struct pool *mem);
-int str_list_add(struct pool *mem, struct list *sll, const char *str);
+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(struct list *sll, const char *str);
 int str_list_match_list(struct list *sll, struct list *sll2);
 int str_list_lists_equal(struct list *sll, struct list *sll2);
-int str_list_dup(struct pool *mem, struct list *sllnew, struct list *sllold);
+int str_list_dup(struct dm_pool *mem, struct list *sllnew, struct list *sllold);
 
 #endif

lib/device/dev-cache.c

@@ -15,12 +15,10 @@
 
 #include "lib.h"
 #include "dev-cache.h"
-#include "pool.h"
-#include "hash.h"
-#include "list.h"
 #include "lvm-types.h"
 #include "btree.h"
 #include "filter.h"
+#include "filter-persistent.h"
 
 #include <unistd.h>
 #include <sys/param.h>
@@ -37,51 +35,73 @@ struct dir_list {
 };
 
 static struct {
-	struct pool *mem;
-	struct hash_table *names;
+	struct dm_pool *mem;
+	struct dm_hash_table *names;
 	struct btree *devices;
 
 	int has_scanned;
 	struct list dirs;
+	struct list files;
 
 } _cache;
 
-#define _alloc(x) pool_alloc(_cache.mem, (x))
-#define _free(x) pool_free(_cache.mem, (x))
+#define _alloc(x) dm_pool_zalloc(_cache.mem, (x))
+#define _free(x) dm_pool_free(_cache.mem, (x))
+#define _strdup(x) dm_pool_strdup(_cache.mem, (x))
 
 static int _insert(const char *path, int rec);
 
 struct device *dev_create_file(const char *filename, struct device *dev,
-			       struct str_list *alias)
+			       struct str_list *alias, int use_malloc)
 {
 	int allocate = !dev;
 
-	if (allocate && !(dev = dbg_malloc(sizeof(*dev)))) {
-		log_error("struct device allocation failed");
-		return NULL;
-	}
-	if (allocate && !(alias = dbg_malloc(sizeof(*alias)))) {
-		log_error("struct str_list allocation failed");
-		dbg_free(dev);
-		return NULL;
-	}
-	if (!(alias->str = dbg_strdup(filename))) {
-		log_error("filename strdup failed");
-		if (allocate) {
-			dbg_free(dev);
-			dbg_free(alias);
+	if (allocate) {
+		if (use_malloc) {
+			if (!(dev = dm_malloc(sizeof(*dev)))) {
+				log_error("struct device allocation failed");
+				return NULL;
+			}
+			if (!(alias = dm_malloc(sizeof(*alias)))) {
+				log_error("struct str_list allocation failed");
+				dm_free(dev);
+				return NULL;
+			}
+			if (!(alias->str = dm_strdup(filename))) {
+				log_error("filename strdup failed");
+				dm_free(dev);
+				dm_free(alias);
+				return NULL;
+			}
+			dev->flags = DEV_ALLOCED;
+		} else {
+			if (!(dev = _alloc(sizeof(*dev)))) {
+				log_error("struct device allocation failed");
+				return NULL;
+			}
+			if (!(alias = _alloc(sizeof(*alias)))) {
+				log_error("struct str_list allocation failed");
+				_free(dev);
+				return NULL;
+			}
+			if (!(alias->str = _strdup(filename))) {
+				log_error("filename strdup failed");
+				return NULL;
+			}
 		}
+	} else if (!(alias->str = dm_strdup(filename))) {
+		log_error("filename strdup failed");
 		return NULL;
 	}
-	dev->flags = DEV_REGULAR;
-	if (allocate)
-		dev->flags |= DEV_ALLOCED;
+
+	dev->flags |= DEV_REGULAR;
 	list_init(&dev->aliases);
 	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;
 	memset(dev->pvid, 0, sizeof(dev->pvid));
 	list_init(&dev->open_list);
 
@@ -101,6 +121,7 @@ static struct device *_dev_create(dev_t d)
 	dev->dev = d;
 	dev->fd = -1;
 	dev->open_count = 0;
+	dev->block_size = -1;
 	dev->end = UINT64_C(0);
 	memset(dev->pvid, 0, sizeof(dev->pvid));
 	list_init(&dev->open_list);
@@ -172,7 +193,7 @@ static int _compare_paths(const char *path0, const char *path1)
 static int _add_alias(struct device *dev, const char *path)
 {
 	struct str_list *sl = _alloc(sizeof(*sl));
-	struct list *ah;
+	struct str_list *strl;
 	const char *oldpath;
 	int prefer_old = 1;
 
@@ -182,14 +203,14 @@ static int _add_alias(struct device *dev, const char *path)
 	}
 
 	/* Is name already there? */
-	list_iterate(ah, &dev->aliases) {
-		if (!strcmp(list_item(ah, struct str_list)->str, path)) {
-			stack;
+	list_iterate_items(strl, &dev->aliases) {
+		if (!strcmp(strl->str, path)) {
+			log_debug("%s: Already in device cache", path);
 			return 1;
 		}
 	}
 
-	if (!(sl->str = pool_strdup(_cache.mem, path))) {
+	if (!(sl->str = dm_pool_strdup(_cache.mem, path))) {
 		stack;
 		return 0;
 	}
@@ -218,12 +239,27 @@ static int _add_alias(struct device *dev, const char *path)
 static int _insert_dev(const char *path, dev_t d)
 {
 	struct device *dev;
+	static dev_t loopfile_count = 0;
+	int loopfile = 0;
+
+	/* Generate pretend device numbers for loopfiles */
+	if (!d) {
+		if (dm_hash_lookup(_cache.names, path))
+			return 1;
+		d = ++loopfile_count;
+		loopfile = 1;
+	}
 
 	/* is this device already registered ? */
 	if (!(dev = (struct device *) btree_lookup(_cache.devices,
 						   (uint32_t) d))) {
 		/* create new device */
-		if (!(dev = _dev_create(d))) {
+		if (loopfile) {
+			if (!(dev = dev_create_file(path, NULL, NULL, 0))) {
+				stack;
+				return 0;
+			}
+		} else if (!(dev = _dev_create(d))) {
 			stack;
 			return 0;
 		}
@@ -235,12 +271,12 @@ static int _insert_dev(const char *path, dev_t d)
 		}
 	}
 
-	if (!_add_alias(dev, path)) {
+	if (!loopfile && !_add_alias(dev, path)) {
 		log_err("Couldn't add alias to dev cache.");
 		return 0;
 	}
 
-	if (!hash_insert(_cache.names, path, dev)) {
+	if (!dm_hash_insert(_cache.names, path, dev)) {
 		log_err("Couldn't add name to hash in dev cache.");
 		return 0;
 	}
@@ -251,7 +287,7 @@ static int _insert_dev(const char *path, dev_t d)
 static char *_join(const char *dir, const char *name)
 {
 	size_t len = strlen(dir) + strlen(name) + 2;
-	char *r = dbg_malloc(len);
+	char *r = dm_malloc(len);
 	if (r)
 		snprintf(r, len, "%s/%s", dir, name);
 
@@ -301,7 +337,7 @@ static int _insert_dir(const char *dir)
 
 			_collapse_slashes(path);
 			r &= _insert(path, 1);
-			dbg_free(path);
+			dm_free(path);
 
 			free(dirent[n]);
 		}
@@ -311,6 +347,28 @@ static int _insert_dir(const char *dir)
 	return r;
 }
 
+static int _insert_file(const char *path)
+{
+	struct stat info;
+
+	if (stat(path, &info) < 0) {
+		log_sys_very_verbose("stat", path);
+		return 0;
+	}
+
+	if (!S_ISREG(info.st_mode)) {
+		log_debug("%s: Not a regular file", path);
+		return 0;
+	}
+
+	if (!_insert_dev(path, 0)) {
+		stack;
+		return 0;
+	}
+
+	return 1;
+}
+
 static int _insert(const char *path, int rec)
 {
 	struct stat info;
@@ -353,19 +411,21 @@ static int _insert(const char *path, int rec)
 	return r;
 }
 
-static void _full_scan(void)
+static void _full_scan(int dev_scan)
 {
-	struct list *dh;
+	struct dir_list *dl;
 
-	if (_cache.has_scanned)
+	if (_cache.has_scanned && !dev_scan)
 		return;
 
-	list_iterate(dh, &_cache.dirs) {
-		struct dir_list *dl = list_item(dh, struct dir_list);
+	list_iterate_items(dl, &_cache.dirs)
 		_insert_dir(dl->dir);
-	};
+
+	list_iterate_items(dl, &_cache.files)
+		_insert_file(dl->dir);
 
 	_cache.has_scanned = 1;
+	init_full_scan_done(1);
 }
 
 int dev_cache_has_scanned(void)
@@ -377,24 +437,23 @@ void dev_cache_scan(int do_scan)
 {
 	if (!do_scan)
 		_cache.has_scanned = 1;
-	else {
-		_cache.has_scanned = 0;
-		_full_scan();
-	}
+	else
+		_full_scan(1);
 }
 
 int dev_cache_init(void)
 {
 	_cache.names = NULL;
+	_cache.has_scanned = 0;
 
-	if (!(_cache.mem = pool_create(10 * 1024))) {
+	if (!(_cache.mem = dm_pool_create("dev_cache", 10 * 1024))) {
 		stack;
 		return 0;
 	}
 
-	if (!(_cache.names = hash_create(128))) {
+	if (!(_cache.names = dm_hash_create(128))) {
 		stack;
-		pool_destroy(_cache.mem);
+		dm_pool_destroy(_cache.mem);
 		_cache.mem = 0;
 		return 0;
 	}
@@ -405,6 +464,7 @@ int dev_cache_init(void)
 	}
 
 	list_init(&_cache.dirs);
+	list_init(&_cache.files);
 
 	return 1;
 
@@ -421,7 +481,7 @@ static void _check_closed(struct device *dev)
 
 static inline void _check_for_open_devices(void)
 {
-	hash_iter(_cache.names, (iterate_fn) _check_closed);
+	dm_hash_iter(_cache.names, (dm_hash_iterate_fn) _check_closed);
 }
 
 void dev_cache_exit(void)
@@ -430,18 +490,19 @@ void dev_cache_exit(void)
 		_check_for_open_devices();
 
 	if (_cache.mem) {
-		pool_destroy(_cache.mem);
+		dm_pool_destroy(_cache.mem);
 		_cache.mem = NULL;
 	}
 
 	if (_cache.names) {
-		hash_destroy(_cache.names);
+		dm_hash_destroy(_cache.names);
 		_cache.names = NULL;
 	}
 
 	_cache.devices = NULL;
 	_cache.has_scanned = 0;
 	list_init(&_cache.dirs);
+	list_init(&_cache.files);
 }
 
 int dev_cache_add_dir(const char *path)
@@ -470,6 +531,32 @@ int dev_cache_add_dir(const char *path)
 	return 1;
 }
 
+int dev_cache_add_loopfile(const char *path)
+{
+	struct dir_list *dl;
+	struct stat st;
+
+	if (stat(path, &st)) {
+		log_error("Ignoring %s: %s", path, strerror(errno));
+		/* But don't fail */
+		return 1;
+	}
+
+	if (!S_ISREG(st.st_mode)) {
+		log_error("Ignoring %s: Not a regular file", path);
+		return 1;
+	}
+
+	if (!(dl = _alloc(sizeof(*dl) + strlen(path) + 1))) {
+		log_error("dir_list allocation failed for file");
+		return 0;
+	}
+
+	strcpy(dl->dir, path);
+	list_add(&_cache.files, &dl->list);
+	return 1;
+}
+
 /* Check cached device name is still valid before returning it */
 /* This should be a rare occurrence */
 /* set quiet if the cache is expected to be out-of-date */
@@ -480,6 +567,9 @@ const char *dev_name_confirmed(struct device *dev, int quiet)
 	const char *name;
 	int r;
 
+	if ((dev->flags & DEV_REGULAR))
+		return dev_name(dev);
+
 	while ((r = stat(name = list_item(dev->aliases.n,
 					  struct str_list)->str, &buf)) ||
 	       (buf.st_rdev != dev->dev)) {
@@ -499,7 +589,7 @@ const char *dev_name_confirmed(struct device *dev, int quiet)
 				  (int) MINOR(dev->dev));
 
 		/* Remove the incorrect hash entry */
-		hash_remove(_cache.names, name);
+		dm_hash_remove(_cache.names, name);
 
 		/* Leave list alone if there isn't an alternative name */
 		/* so dev_name will always find something to return. */
@@ -522,32 +612,47 @@ const char *dev_name_confirmed(struct device *dev, int quiet)
 struct device *dev_cache_get(const char *name, struct dev_filter *f)
 {
 	struct stat buf;
-	struct device *d = (struct device *) hash_lookup(_cache.names, name);
+	struct device *d = (struct device *) dm_hash_lookup(_cache.names, name);
+
+	if (d && (d->flags & DEV_REGULAR))
+		return d;
 
 	/* If the entry's wrong, remove it */
 	if (d && (stat(name, &buf) || (buf.st_rdev != d->dev))) {
-		hash_remove(_cache.names, name);
+		dm_hash_remove(_cache.names, name);
 		d = NULL;
 	}
 
 	if (!d) {
 		_insert(name, 0);
-		d = (struct device *) hash_lookup(_cache.names, name);
+		d = (struct device *) dm_hash_lookup(_cache.names, name);
+		if (!d) {
+			_full_scan(0);
+			d = (struct device *) dm_hash_lookup(_cache.names, name);
+		}
 	}
 
-	return (d && (!f || f->passes_filter(f, d))) ? d : NULL;
+	return (d && (!f || (d->flags & DEV_REGULAR) ||
+		      f->passes_filter(f, d))) ? d : NULL;
 }
 
-struct dev_iter *dev_iter_create(struct dev_filter *f)
+struct dev_iter *dev_iter_create(struct dev_filter *f, int dev_scan)
 {
-	struct dev_iter *di = dbg_malloc(sizeof(*di));
+	struct dev_iter *di = dm_malloc(sizeof(*di));
 
 	if (!di) {
 		log_error("dev_iter allocation failed");
 		return NULL;
 	}
 
-	_full_scan();
+
+	if (dev_scan) {
+		/* Flag gets reset between each command */
+		if (!full_scan_done())
+			persistent_filter_wipe(f); /* Calls _full_scan(1) */
+	} else
+		_full_scan(0);
+
 	di->current = btree_first(_cache.devices);
 	di->filter = f;
 
@@ -556,7 +661,7 @@ struct dev_iter *dev_iter_create(struct dev_filter *f)
 
 void dev_iter_destroy(struct dev_iter *iter)
 {
-	dbg_free(iter);
+	dm_free(iter);
 }
 
 static inline struct device *_iter_next(struct dev_iter *iter)
@@ -570,7 +675,7 @@ struct device *dev_iter_get(struct dev_iter *iter)
 {
 	while (iter->current) {
 		struct device *d = _iter_next(iter);
-		if (!iter->filter ||
+		if (!iter->filter || (d->flags & DEV_REGULAR) ||
 		    iter->filter->passes_filter(iter->filter, d))
 			return d;
 	}

lib/device/dev-cache.h

@@ -16,7 +16,6 @@
 #ifndef _LVM_DEV_CACHE_H
 #define _LVM_DEV_CACHE_H
 
-#include "lvm-types.h"
 #include "device.h"
 
 /*
@@ -39,13 +38,14 @@ void dev_cache_scan(int do_scan);
 int dev_cache_has_scanned(void);
 
 int dev_cache_add_dir(const char *path);
+int dev_cache_add_loopfile(const char *path);
 struct device *dev_cache_get(const char *name, struct dev_filter *f);
 
 /*
  * Object for iterating through the cache.
  */
 struct dev_iter;
-struct dev_iter *dev_iter_create(struct dev_filter *f);
+struct dev_iter *dev_iter_create(struct dev_filter *f, int dev_scan);
 void dev_iter_destroy(struct dev_iter *iter);
 struct device *dev_iter_get(struct dev_iter *iter);
 

lib/device/dev-io.c

@@ -81,7 +81,9 @@ static int _io(struct device_area *where, void *buffer, int should_write)
 	}
 
 	if (lseek(fd, (off_t) where->start, SEEK_SET) < 0) {
-		log_sys_error("lseek", dev_name(where->dev));
+		log_error("%s: lseek %" PRIu64 " failed: %s",
+			  dev_name(where->dev), (uint64_t) where->start,
+			  strerror(errno));
 		return 0;
 	}
 
@@ -92,6 +94,14 @@ static int _io(struct device_area *where, void *buffer, int should_write)
 			    read(fd, buffer, (size_t) where->size - total);
 		while ((n < 0) && ((errno == EINTR) || (errno == EAGAIN)));
 
+		if (n < 0)
+			log_error("%s: %s failed after %" PRIu64 " of %" PRIu64
+				  " at %" PRIu64 ": %s", dev_name(where->dev),
+				  should_write ? "write" : "read",
+				  (uint64_t) total,
+				  (uint64_t) where->size,
+				  (uint64_t) where->start, strerror(errno));
+
 		if (n <= 0)
 			break;
 
@@ -114,14 +124,18 @@ static int _io(struct device_area *where, void *buffer, int should_write)
  */
 static int _get_block_size(struct device *dev, unsigned int *size)
 {
-	int s;
+	const char *name = dev_name(dev);
 
-	if (ioctl(dev_fd(dev), BLKBSZGET, &s) < 0) {
-		log_sys_error("ioctl BLKBSZGET", dev_name(dev));
-		return 0;
+	if ((dev->block_size == -1)) {
+		if (ioctl(dev_fd(dev), BLKBSZGET, &dev->block_size) < 0) {
+			log_sys_error("ioctl BLKBSZGET", name);
+			return 0;
+		}
+		log_debug("%s: block size is %u bytes", name, dev->block_size);
 	}
 
-	*size = (unsigned int) s;
+	*size = (unsigned int) dev->block_size;
+
 	return 1;
 }
 
@@ -208,16 +222,29 @@ static int _aligned_io(struct device_area *where, void *buffer,
 	return 1;
 }
 
-/*-----------------------------------------------------------------
- * Public functions
- *---------------------------------------------------------------*/
+static int _dev_get_size_file(const struct device *dev, uint64_t *size)
+{
+	const char *name = dev_name(dev);
+	struct stat info;
 
-int dev_get_size(const struct device *dev, uint64_t *size)
+	if (stat(name, &info)) {
+		log_sys_error("stat", name);
+		return 0;
+	}
+
+	*size = info.st_size;
+	*size >>= SECTOR_SHIFT;	/* Convert to sectors */
+
+	log_very_verbose("%s: size is %" PRIu64 " sectors", name, *size);
+
+	return 1;
+}
+
+static int _dev_get_size_dev(const struct device *dev, uint64_t *size)
 {
 	int fd;
 	const char *name = dev_name(dev);
 
-	log_very_verbose("Getting size of %s", name);
 	if ((fd = open(name, O_RDONLY)) < 0) {
 		log_sys_error("open", name);
 		return 0;
@@ -225,22 +252,39 @@ int dev_get_size(const struct device *dev, uint64_t *size)
 
 	if (ioctl(fd, BLKGETSIZE64, size) < 0) {
 		log_sys_error("ioctl BLKGETSIZE64", name);
-		close(fd);
+		if (close(fd))
+			log_sys_error("close", name);
 		return 0;
 	}
 
 	*size >>= BLKSIZE_SHIFT;	/* Convert to sectors */
-	close(fd);
+	if (close(fd))
+		log_sys_error("close", name);
+
+	log_very_verbose("%s: size is %" PRIu64 " sectors", name, *size);
+
 	return 1;
 }
 
+/*-----------------------------------------------------------------
+ * Public functions
+ *---------------------------------------------------------------*/
+
+int dev_get_size(const struct device *dev, uint64_t *size)
+{
+	if ((dev->flags & DEV_REGULAR))
+		return _dev_get_size_file(dev, size);
+	else
+		return _dev_get_size_dev(dev, size);
+}
+
+/* FIXME Unused
 int dev_get_sectsize(struct device *dev, uint32_t *size)
 {
 	int fd;
 	int s;
 	const char *name = dev_name(dev);
 
-	log_very_verbose("Getting size of %s", name);
 	if ((fd = open(name, O_RDONLY)) < 0) {
 		log_sys_error("open", name);
 		return 0;
@@ -254,8 +298,12 @@ int dev_get_sectsize(struct device *dev, uint32_t *size)
 
 	close(fd);
 	*size = (uint32_t) s;
+
+	log_very_verbose("%s: sector size is %" PRIu32 " bytes", name, *size);
+
 	return 1;
 }
+*/
 
 void dev_flush(struct device *dev)
 {
@@ -272,10 +320,29 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 {
 	struct stat buf;
 	const char *name;
+	int need_excl = 0, need_rw = 0;
+
+	if ((flags & O_ACCMODE) == O_RDWR)
+		need_rw = 1;
+
+	if ((flags & O_EXCL))
+		need_excl = 1;
 
 	if (dev->fd >= 0) {
-		dev->open_count++;
-		return 1;
+		if (((dev->flags & DEV_OPENED_RW) || !need_rw) &&
+		    ((dev->flags & DEV_OPENED_EXCL) || !need_excl)) {
+			dev->open_count++;
+			return 1;
+		}
+
+		if (dev->open_count && !need_excl) {
+			/* FIXME Ensure we never get here */
+			log_debug("WARNING: %s already opened read-only", 
+				  dev_name(dev));
+			dev->open_count++;
+		}
+
+		dev_close_immediate(dev);
 	}
 
 	if (memlock())
@@ -296,8 +363,13 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 	}
 
 #ifdef O_DIRECT_SUPPORT
-	if (direct)
-		flags |= O_DIRECT;
+	if (direct) {
+		if (!(dev->flags & DEV_O_DIRECT_TESTED))
+			dev->flags |= DEV_O_DIRECT;
+
+		if ((dev->flags & DEV_O_DIRECT))
+			flags |= O_DIRECT;
+	}
 #endif
 
 #ifdef O_NOATIME
@@ -307,18 +379,46 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 #endif
 
 	if ((dev->fd = open(name, flags, 0777)) < 0) {
-		log_sys_error("open", name);
+#ifdef O_DIRECT_SUPPORT
+		if (direct && !(dev->flags & DEV_O_DIRECT_TESTED)) {
+			flags &= ~O_DIRECT;
+			if ((dev->fd = open(name, flags, 0777)) >= 0) {
+				dev->flags &= ~DEV_O_DIRECT;
+				log_debug("%s: Not using O_DIRECT", name);
+				goto opened;
+			}
+		}
+#endif
+		if (quiet)
+			log_sys_debug("open", name);
+		else
+			log_sys_error("open", name);
 		return 0;
 	}
 
-	dev->open_count = 1;
+#ifdef O_DIRECT_SUPPORT
+      opened:
+	if (direct)
+		dev->flags |= DEV_O_DIRECT_TESTED;
+#endif
+	dev->open_count++;
 	dev->flags &= ~DEV_ACCESSED_W;
 
+	if (need_rw)
+		dev->flags |= DEV_OPENED_RW;
+	else
+		dev->flags &= ~DEV_OPENED_RW;
+
+	if (need_excl)
+		dev->flags |= DEV_OPENED_EXCL;
+	else
+		dev->flags &= ~DEV_OPENED_EXCL;
+
 	if (!(dev->flags & DEV_REGULAR) &&
 	    ((fstat(dev->fd, &buf) < 0) || (buf.st_rdev != dev->dev))) {
 		log_error("%s: fstat failed: Has device name changed?", name);
-		dev_close(dev);
-		dev->fd = -1;
+		dev_close_immediate(dev);
+		dev->open_count = 0;
 		return 0;
 	}
 
@@ -327,12 +427,15 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 		dev_flush(dev);
 #endif
 
-	if ((flags & O_CREAT) && !(flags & O_TRUNC)) {
+	if ((flags & O_CREAT) && !(flags & O_TRUNC))
 		dev->end = lseek(dev->fd, (off_t) 0, SEEK_END);
-	}
 
 	list_add(&_open_devices, &dev->open_list);
-	log_debug("Opened %s", dev_name(dev));
+
+	log_debug("Opened %s %s%s%s", dev_name(dev),
+		  dev->flags & DEV_OPENED_RW ? "RW" : "RO",
+		  dev->flags & DEV_OPENED_EXCL ? " O_EXCL" : "",
+		  dev->flags & DEV_O_DIRECT ? " O_DIRECT" : "");
 
 	return 1;
 }
@@ -355,25 +458,43 @@ int dev_open(struct device *dev)
 	return dev_open_flags(dev, flags, 1, 0);
 }
 
+int dev_test_excl(struct device *dev)
+{
+	int flags;
+	int r;
+
+	flags = vg_write_lock_held() ? O_RDWR : O_RDONLY;
+	flags |= O_EXCL;
+
+	r = dev_open_flags(dev, flags, 1, 1);
+	if (r)
+		dev_close_immediate(dev);
+
+	return r;
+}
+
 static void _close(struct device *dev)
 {
 	if (close(dev->fd))
 		log_sys_error("close", dev_name(dev));
 	dev->fd = -1;
+	dev->block_size = -1;
 	list_del(&dev->open_list);
 
 	log_debug("Closed %s", dev_name(dev));
 
 	if (dev->flags & DEV_ALLOCED) {
-		dbg_free((void *) list_item(dev->aliases.n, struct str_list)->
+		dm_free((void *) list_item(dev->aliases.n, struct str_list)->
 			 str);
-		dbg_free(dev->aliases.n);
-		dbg_free(dev);
+		dm_free(dev->aliases.n);
+		dm_free(dev);
 	}
 }
 
 static int _dev_close(struct device *dev, int immediate)
 {
+	struct lvmcache_info *info;
+
 	if (dev->fd < 0) {
 		log_error("Attempt to close device '%s' "
 			  "which is not open.", dev_name(dev));
@@ -385,8 +506,21 @@ static int _dev_close(struct device *dev, int immediate)
 		dev_flush(dev);
 #endif
 
-	/* FIXME lookup device in cache to get vgname and see if it's locked? */
-	if (--dev->open_count < 1 && (immediate || !vgs_locked()))
+	if (dev->open_count > 0)
+		dev->open_count--;
+
+	if (immediate && dev->open_count) {
+		log_debug("%s: Immediate close attempt while still referenced",
+			  dev_name(dev));
+		dev->open_count = 0;
+	}
+
+	/* Close unless device is known to belong to a locked VG */
+	if (immediate ||
+	    (dev->open_count < 1 && 
+	     (!(info = info_from_pvid(dev->pvid)) ||
+	      !info->vginfo ||
+	      !vgname_is_locked(info->vginfo->vgname))))
 		_close(dev);
 
 	return 1;
@@ -418,8 +552,10 @@ int dev_read(struct device *dev, uint64_t offset, size_t len, void *buffer)
 {
 	struct device_area where;
 
-	if (!dev->open_count)
+	if (!dev->open_count) {
+		stack;
 		return 0;
+	}
 
 	where.dev = dev;
 	where.start = offset;
@@ -437,8 +573,10 @@ int dev_append(struct device *dev, size_t len, void *buffer)
 {
 	int r;
 
-	if (!dev->open_count)
+	if (!dev->open_count) {
+		stack;
 		return 0;
+	}
 
 	r = dev_write(dev, dev->end, len, buffer);
 	dev->end += (uint64_t) len;
@@ -453,8 +591,10 @@ int dev_write(struct device *dev, uint64_t offset, size_t len, void *buffer)
 {
 	struct device_area where;
 
-	if (!dev->open_count)
+	if (!dev->open_count) {
+		stack;
 		return 0;
+	}
 
 	where.dev = dev;
 	where.start = offset;
@@ -501,6 +641,5 @@ int dev_zero(struct device *dev, uint64_t offset, size_t len)
 	if (!dev_close(dev))
 		stack;
 
-	/* FIXME: Always display error */
 	return (len == 0);
 }

lib/device/dev-md.c

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2004 Luca Berra
+ * Copyright (C) 2004 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"
+
+/* Lifted from <linux/raid/md_p.h> because of difficulty including it */
+
+#define MD_SB_MAGIC 0xa92b4efc
+#define MD_RESERVED_BYTES (64 * 1024)
+#define MD_RESERVED_SECTORS (MD_RESERVED_BYTES / 512)
+#define MD_NEW_SIZE_SECTORS(x) ((x & ~(MD_RESERVED_SECTORS - 1)) \
+				- MD_RESERVED_SECTORS)
+
+/*
+ * Returns -1 on error
+ */
+int dev_is_md(struct device *dev, uint64_t *sb)
+{
+	int ret = 0;
+
+#ifdef linux
+
+	uint64_t size, sb_offset;
+	uint32_t md_magic;
+
+	if (!dev_get_size(dev, &size)) {
+		stack;
+		return -1;
+	}
+
+	if (size < MD_RESERVED_SECTORS * 2)
+		return 0;
+
+	if (!dev_open(dev)) {
+		stack;
+		return -1;
+	}
+
+	sb_offset = MD_NEW_SIZE_SECTORS(size) << SECTOR_SHIFT;
+
+	/* Check if it is an md component device. */
+	if (dev_read(dev, sb_offset, sizeof(uint32_t), &md_magic) &&
+	    (md_magic == xlate32(MD_SB_MAGIC))) {
+		if (sb)
+			*sb = sb_offset;
+		ret = 1;
+	}
+
+	if (!dev_close(dev))
+		stack;
+
+#endif
+	return ret;
+}
+

lib/device/device.c

@@ -13,6 +13,93 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
+#include "lvm-types.h"
+#include "device.h"
+#include "metadata.h"
+#include "filter.h"
+#include "xlate.h"
+
+/* See linux/genhd.h and fs/partitions/msdos */
+
+#define PART_MAGIC 0xAA55
+#define PART_MAGIC_OFFSET UINT64_C(0x1FE)
+#define PART_OFFSET UINT64_C(0x1BE)
+
+struct partition {
+        uint8_t boot_ind;
+        uint8_t head;
+        uint8_t sector;
+        uint8_t cyl;
+        uint8_t sys_ind;	/* partition type */
+        uint8_t end_head;
+        uint8_t end_sector;
+        uint8_t end_cyl;
+        uint32_t start_sect;
+        uint32_t nr_sects;
+} __attribute__((packed));
+
+static int _is_partitionable(struct device *dev)
+{
+	int parts = max_partitions(MAJOR(dev->dev));
+
+	if ((parts <= 1) || (MINOR(dev->dev) % parts))
+		return 0;
+
+	return 1;
+}
+
+static int _has_partition_table(struct device *dev)
+{
+	int ret = 0;
+	unsigned p;
+	uint8_t buf[SECTOR_SIZE];
+	uint16_t *part_magic;
+	struct partition *part;
+
+	if (!dev_open(dev)) {
+		stack;
+		return -1;
+	}
+
+	if (!dev_read(dev, 0, sizeof(buf), &buf)) {
+		stack;
+		goto out;
+	}
+
+	/* FIXME Check for other types of partition table too */
+
+	/* Check for msdos partition table */
+	part_magic = (uint16_t *)(buf + PART_MAGIC_OFFSET);
+	if ((*part_magic == xlate16(PART_MAGIC))) {
+		part = (struct partition *) (buf + PART_OFFSET);
+		for (p = 0; p < 4; p++, part++) {
+			/* Table is invalid if boot indicator not 0 or 0x80 */
+			if ((part->boot_ind & 0x7f)) {
+				ret = 0;
+				break;
+			}
+			/* Must have at least one non-empty partition */
+			if (part->nr_sects)
+				ret = 1;
+		}
+	}
+
+      out:
+	if (!dev_close(dev))
+		stack;
+
+	return ret;
+}
+
+int is_partitioned_dev(struct device *dev)
+{
+	if (!_is_partitionable(dev))
+		return 0;
+
+	return _has_partition_table(dev);
+}
+
 #if 0
 #include <sys/stat.h>
 #include <sys/mman.h>
@@ -27,24 +114,13 @@
 #include <linux/major.h>
 #include <linux/genhd.h>
 
-#include "dbg_malloc.h"
-#include "log.h"
-#include "dev-cache.h"
-#include "metadata.h"
-#include "device.h"
-
 int _get_partition_type(struct dev_filter *filter, struct device *d);
 
-#define MINOR_PART(dm, d) (MINOR((d)->dev) % dev_max_partitions(dm, (d)->dev))
+#define MINOR_PART(dev) (MINOR((dev)->dev) % max_partitions(MINOR((dev)->dev)))
 
-int is_whole_disk(struct dev_filter *filter, struct device *d)
+int is_extended_partition(struct device *d)
 {
-	return (MINOR_PART(dm, d)) ? 0 : 1;
-}
-
-int is_extended_partition(struct dev_mgr *dm, struct device *d)
-{
-	return (MINOR_PART(dm, d) > 4) ? 1 : 0;
+	return (MINOR_PART(d) > 4) ? 1 : 0;
 }
 
 struct device *dev_primary(struct dev_mgr *dm, struct device *d)
@@ -126,7 +202,7 @@ int _get_partition_type(struct dev_mgr *dm, struct device *d)
 		return 0;
 	}
 
-	if (!(buffer = dbg_malloc(SECTOR_SIZE))) {
+	if (!(buffer = dm_malloc(SECTOR_SIZE))) {
 		log_error("Failed to allocate partition table buffer");
 		return 0;
 	}

lib/device/device.h

@@ -17,11 +17,16 @@
 #define _LVM_DEVICE_H
 
 #include "uuid.h"
+
 #include <fcntl.h>
 
 #define DEV_ACCESSED_W		0x00000001	/* Device written to? */
 #define DEV_REGULAR		0x00000002	/* Regular file? */
-#define DEV_ALLOCED		0x00000004	/* dbg_malloc used */
+#define DEV_ALLOCED		0x00000004	/* dm_malloc used */
+#define DEV_OPENED_RW		0x00000008	/* Opened RW */
+#define DEV_OPENED_EXCL		0x00000010	/* Opened EXCL */
+#define DEV_O_DIRECT		0x00000020	/* Use O_DIRECT */
+#define DEV_O_DIRECT_TESTED	0x00000040	/* DEV_O_DIRECT is reliable */
 
 /*
  * All devices in LVM will be represented by one of these.
@@ -34,11 +39,13 @@ struct device {
 	/* private */
 	int fd;
 	int open_count;
+	int block_size;
 	uint32_t flags;
 	uint64_t end;
 	struct list open_list;
 
 	char pvid[ID_LEN + 1];
+	char _padding[7];
 };
 
 struct device_list {
@@ -61,10 +68,11 @@ int dev_get_sectsize(struct device *dev, uint32_t *size);
 /* Use quiet version if device number could change e.g. when opening LV */
 int dev_open(struct device *dev);
 int dev_open_quiet(struct device *dev);
-int dev_open_flags(struct device *dev, int flags, int append, int quiet);
+int dev_open_flags(struct device *dev, int flags, int direct, int quiet);
 int dev_close(struct device *dev);
 int dev_close_immediate(struct device *dev);
 void dev_close_all(void);
+int dev_test_excl(struct device *dev);
 
 static inline int dev_fd(struct device *dev)
 {
@@ -78,7 +86,7 @@ int dev_zero(struct device *dev, uint64_t offset, size_t len);
 void dev_flush(struct device *dev);
 
 struct device *dev_create_file(const char *filename, struct device *dev,
-			       struct str_list *alias);
+			       struct str_list *alias, int use_malloc);
 
 static inline const char *dev_name(const struct device *dev)
 {
@@ -89,15 +97,14 @@ static inline const char *dev_name(const struct device *dev)
 /* Return a valid device name from the alias list; NULL otherwise */
 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);
+
 /* FIXME Check partition type if appropriate */
 
 #define is_lvm_partition(a) 1
+/* int is_lvm_partition(const char *name); */
 
-/*
-static inline int is_lvm_partition(const char *name)
-{
-	return 1;
-}
-*/
+int is_partitioned_dev(struct device *dev);
 
 #endif

lib/display/display.c

@@ -151,7 +151,7 @@ const char *display_size(struct cmd_context *cmd, uint64_t size, size_len_t sl)
 		{"         ", "   ", " "},
 	};
 
-	if (!(size_buf = pool_alloc(cmd->mem, SIZE_BUF))) {
+	if (!(size_buf = dm_pool_alloc(cmd->mem, SIZE_BUF))) {
 		log_error("no memory for size display buffer");
 		return "";
 	}
@@ -258,7 +258,7 @@ void pvdisplay_full(struct cmd_context *cmd, struct physical_volume *pv,
 		log_print("PV Size               %s" " / not usable %s",	/*  [LVM: %s]", */
 			  size,
 			  display_size(cmd, (pv->size -
-					     pv->pe_count * pv->pe_size),
+				       (uint64_t) pv->pe_count * pv->pe_size),
 				       SIZE_SHORT));
 
 	} else
@@ -317,7 +317,7 @@ void lvdisplay_colons(struct logical_volume *lv)
 {
 	int inkernel;
 	struct lvinfo info;
-	inkernel = lv_info(lv, &info) && info.exists;
+	inkernel = lv_info(lv->vg->cmd, lv, &info, 1) && info.exists;
 
 	log_print("%s%s/%s:%s:%d:%d:-1:%d:%" PRIu64 ":%d:-1:%d:%d:%d:%d",
 		  lv->vg->cmd->dev_dir,
@@ -337,10 +337,9 @@ int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
 		   void *handle)
 {
 	struct lvinfo info;
-	int inkernel, snap_active;
+	int inkernel, snap_active = 0;
 	char uuid[64];
-	struct snapshot *snap = NULL;
-	struct list *slh, *snaplist;
+	struct lv_segment *snap_seg = NULL;
 	float snap_percent;	/* fused, fsize; */
 
 	if (!id_write_format(&lv->lvid.id[1], uuid, sizeof(uuid))) {
@@ -348,7 +347,7 @@ int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
 		return 0;
 	}
 
-	inkernel = lv_info(lv, &info) && info.exists;
+	inkernel = lv_info(cmd, lv, &info, 1) && info.exists;
 
 	log_print("--- Logical volume ---");
 
@@ -364,27 +363,30 @@ int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
 	if (lv_is_origin(lv)) {
 		log_print("LV snapshot status     source of");
 
-		snaplist = find_snapshots(lv);
-		list_iterate(slh, snaplist) {
-			snap = list_item(slh, struct snapshot_list)->snapshot;
-			snap_active = lv_snapshot_percent(snap->cow,
-							  &snap_percent);
-			if (!snap_active || snap_percent < 0 ||
-			    snap_percent >= 100) snap_active = 0;
+		list_iterate_items_gen(snap_seg, &lv->snapshot_segs,
+				       origin_list) {
+			if (inkernel &&
+			    (snap_active = lv_snapshot_percent(snap_seg->cow,
+							       &snap_percent)))
+				if (snap_percent < 0 || snap_percent >= 100)
+					snap_active = 0;
 			log_print("                       %s%s/%s [%s]",
 				  lv->vg->cmd->dev_dir, lv->vg->name,
-				  snap->cow->name,
+				  snap_seg->cow->name,
 				  (snap_active > 0) ? "active" : "INACTIVE");
 		}
-		snap = NULL;
-	} else if ((snap = find_cow(lv))) {
-		snap_active = lv_snapshot_percent(lv, &snap_percent);
-		if (!snap_active || snap_percent < 0 || snap_percent >= 100)
-			snap_active = 0;
+		snap_seg = NULL;
+	} else if ((snap_seg = find_cow(lv))) {
+		if (inkernel &&
+		    (snap_active = lv_snapshot_percent(snap_seg->cow,
+						       &snap_percent)))
+			if (snap_percent < 0 || snap_percent >= 100)
+				snap_active = 0;
+
 		log_print("LV snapshot status     %s destination for %s%s/%s",
 			  (snap_active > 0) ? "active" : "INACTIVE",
 			  lv->vg->cmd->dev_dir, lv->vg->name,
-			  snap->origin->name);
+			  snap_seg->origin->name);
 	}
 
 	if (inkernel && info.suspended)
@@ -402,15 +404,24 @@ int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
 
 	log_print("LV Size                %s",
 		  display_size(cmd,
-			       snap ? snap->origin->size : lv->size,
+			       snap_seg ? snap_seg->origin->size : lv->size,
 			       SIZE_SHORT));
 
 	log_print("Current LE             %u",
-		  snap ? snap->origin->le_count : lv->le_count);
+		  snap_seg ? snap_seg->origin->le_count : lv->le_count);
 
-/********** FIXME allocation
-    log_print("Allocated LE           %u", lv->allocated_le);
-**********/
+	if (snap_seg) {
+		log_print("COW-table size         %s",
+			  display_size(cmd, (uint64_t) lv->size, SIZE_SHORT));
+		log_print("COW-table LE           %u", lv->le_count);
+
+		if (snap_active)
+			log_print("Allocated to snapshot  %.2f%% ", snap_percent);	
+
+		log_print("Snapshot chunk size    %s",
+			  display_size(cmd, (uint64_t) snap_seg->chunk_size,
+				       SIZE_SHORT));
+	}
 
 	log_print("Segments               %u", list_size(&lv->segments));
 
@@ -418,31 +429,6 @@ int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
 	log_print("Stripe size (KByte)    %u", lv->stripesize / 2);
 ***********/
 
-	if (snap) {
-		if (snap_percent == -1)
-			snap_percent = 100;
-
-		log_print("Snapshot chunk size    %s",
-			  display_size(cmd, (uint64_t) snap->chunk_size,
-				       SIZE_SHORT));
-
-/*
-	size = display_size(lv->size, SIZE_SHORT);
-	sscanf(size, "%f", &fsize);
-	fused = fsize * snap_percent / 100;
-*/
-		log_print("Allocated to snapshot  %.2f%% ",	/* [%.2f/%s]", */
-			  snap_percent);	/*, fused, size); */
-		/* dbg_free(size); */
-	}
-
-/********** FIXME Snapshot
-	size = ???
-	log_print("Allocated to COW-table %s", size);
-	dbg_free(size);
-    }
-******************/
-
 	log_print("Allocation             %s", get_alloc_string(lv->alloc));
 	log_print("Read ahead sectors     %u", lv->read_ahead);
 
@@ -463,27 +449,31 @@ int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
 
 void display_stripe(const struct lv_segment *seg, uint32_t s, const char *pre)
 {
-	switch (seg->area[s].type) {
+	switch (seg_type(seg, s)) {
 	case AREA_PV:
+		/* FIXME Re-check the conditions for 'Missing' */
 		log_print("%sPhysical volume\t%s", pre,
-			  seg->area[s].u.pv.pv ?
-			  dev_name(seg->area[s].u.pv.pv->dev) : "Missing");
+			  seg_pv(seg, s) ?
+			  dev_name(seg_dev(seg, s)) :
+			    "Missing");
 
-		if (seg->area[s].u.pv.pv)
+		if (seg_pv(seg, s))
 			log_print("%sPhysical extents\t%d to %d", pre,
-				  seg->area[s].u.pv.pe,
-				  seg->area[s].u.pv.pe + seg->area_len - 1);
+				  seg_pe(seg, s),
+				  seg_pe(seg, s) + seg->area_len - 1);
 		break;
 	case AREA_LV:
 		log_print("%sLogical volume\t%s", pre,
-			  seg->area[s].u.lv.lv ?
-			  seg->area[s].u.lv.lv->name : "Missing");
+			  seg_lv(seg, s) ?
+			  seg_lv(seg, s)->name : "Missing");
 
-		if (seg->area[s].u.lv.lv)
+		if (seg_lv(seg, s))
 			log_print("%sLogical extents\t%d to %d", pre,
-				  seg->area[s].u.lv.le,
-				  seg->area[s].u.lv.le + seg->area_len - 1);
-
+				  seg_le(seg, s),
+				  seg_le(seg, s) + seg->area_len - 1);
+		break;
+	case AREA_UNASSIGNED:
+		log_print("%sUnassigned area", pre);
 	}
 }
 
@@ -550,7 +540,7 @@ void vgdisplay_full(struct volume_group *vg)
 			  vg->status & SHARED ? "yes" : "no");
 	}
 	log_print("MAX LV                %u", vg->max_lv);
-	log_print("Cur LV                %u", vg->lv_count);
+	log_print("Cur LV                %u", vg->lv_count + vg->snapshot_count);
 	log_print("Open LV               %u", lvs_in_vg_opened(vg));
 /****** FIXME Max LV Size
       log_print ( "MAX LV Size           %s",

lib/error/errseg.c

@@ -13,8 +13,6 @@
  */
 
 #include "lib.h"
-#include "pool.h"
-#include "list.h"
 #include "toolcontext.h"
 #include "segtype.h"
 #include "display.h"
@@ -40,18 +38,13 @@ static int _merge_segments(struct lv_segment *seg1, struct lv_segment *seg2)
 }
 
 #ifdef DEVMAPPER_SUPPORT
-static int _compose_target_line(struct dev_manager *dm, struct pool *mem,
+static int _add_target_line(struct dev_manager *dm, struct dm_pool *mem,
 				struct config_tree *cft, void **target_state,
-				struct lv_segment *seg, char *params,
-				size_t paramsize, const char **target, int *pos,
+				struct lv_segment *seg,
+				struct dm_tree_node *node, uint64_t len,
 				uint32_t *pvmove_mirror_count)
 {
-	/*   error */
-
-	*target = "error";
-	*params = '\0';
-
-	return 1;
+	return dm_tree_node_add_error_target(node, len);
 }
 
 static int _target_present(void)
@@ -59,8 +52,10 @@ static int _target_present(void)
 	static int checked = 0;
 	static int present = 0;
 
-	if (!checked)
-		present = target_present("error");
+	/* Reported truncated in older kernels */
+	if (!checked &&
+	    (target_present("error", 0) || target_present("erro", 0)))
+		present = 1;
 
 	checked = 1;
 	return present;
@@ -69,14 +64,14 @@ static int _target_present(void)
 
 static void _destroy(const struct segment_type *segtype)
 {
-	dbg_free((void *) segtype);
+	dm_free((void *) segtype);
 }
 
 static struct segtype_handler _error_ops = {
 	name:_name,
 	merge_segments:_merge_segments,
 #ifdef DEVMAPPER_SUPPORT
-	compose_target_line:_compose_target_line,
+	add_target_line:_add_target_line,
 	target_present:_target_present,
 #endif
 	destroy:_destroy,
@@ -84,18 +79,16 @@ static struct segtype_handler _error_ops = {
 
 struct segment_type *init_error_segtype(struct cmd_context *cmd)
 {
-	struct segment_type *segtype = dbg_malloc(sizeof(*segtype));
+	struct segment_type *segtype = dm_malloc(sizeof(*segtype));
 
-	if (!segtype) {
-		stack;
-		return NULL;
-	}
+	if (!segtype)
+		return_NULL;
 
 	segtype->cmd = cmd;
 	segtype->ops = &_error_ops;
 	segtype->name = "error";
 	segtype->private = NULL;
-	segtype->flags = SEG_CAN_SPLIT | SEG_VIRTUAL;
+	segtype->flags = SEG_CAN_SPLIT | SEG_VIRTUAL | SEG_CANNOT_BE_ZEROED;
 
 	log_very_verbose("Initialised segtype: %s", segtype->name);
 

lib/filters/filter-composite.c

@@ -42,8 +42,8 @@ static void _destroy(struct dev_filter *f)
 		filters++;
 	}
 
-	dbg_free(f->private);
-	dbg_free(f);
+	dm_free(f->private);
+	dm_free(f);
 }
 
 struct dev_filter *composite_filter_create(int n, struct dev_filter **filters)
@@ -55,7 +55,7 @@ struct dev_filter *composite_filter_create(int n, struct dev_filter **filters)
 		return NULL;
 	}
 
-	if (!(filters_copy = dbg_malloc(sizeof(*filters) * (n + 1)))) {
+	if (!(filters_copy = dm_malloc(sizeof(*filters) * (n + 1)))) {
 		log_error("composite filters allocation failed");
 		return NULL;
 	}
@@ -63,9 +63,9 @@ struct dev_filter *composite_filter_create(int n, struct dev_filter **filters)
 	memcpy(filters_copy, filters, sizeof(*filters) * n);
 	filters_copy[n] = NULL;
 
-	if (!(cft = dbg_malloc(sizeof(*cft)))) {
+	if (!(cft = dm_malloc(sizeof(*cft)))) {
 		log_error("compsoite filters allocation failed");
-		dbg_free(filters_copy);
+		dm_free(filters_copy);
 		return NULL;
 	}
 

lib/filters/filter-md.c

@@ -28,55 +28,37 @@
 
 static int _ignore_md(struct dev_filter *f, struct device *dev)
 {
-	uint64_t size, sector;
-	uint32_t md_magic;
-
-	if (!dev_get_size(dev, &size)) {
-		stack;
-		return 0;
-	}
-
-	if (size < MD_RESERVED_SECTORS * 2)
-		/*
-		 * We could ignore it since it is obviously too
-		 * small, but that's not our job.
-		 */
+	int ret;
+	
+	if (!md_filtering())
 		return 1;
+	
+	ret = dev_is_md(dev, NULL);
 
-	if (!dev_open(dev)) {
-		stack;
+	if (ret == 1) {
+		log_debug("%s: Skipping md component device", dev_name(dev));
 		return 0;
 	}
 
-	sector = MD_NEW_SIZE_SECTORS(size);
-
-	/* Check if it is an md component device. */
-	if (dev_read(dev, sector << SECTOR_SHIFT, sizeof(uint32_t), &md_magic)) {
-		if (md_magic == MD_SB_MAGIC) {
-			log_debug("%s: Skipping md component device",
-				  dev_name(dev));
-			if (!dev_close(dev))
-				stack;
-			return 0;
-		}
+	if (ret < 0) {
+		log_debug("%s: Skipping: error in md component detection",
+			  dev_name(dev));
+		return 0;
 	}
 
-	if (!dev_close(dev))
-		stack;
-
 	return 1;
 }
 
 static void _destroy(struct dev_filter *f)
 {
-	dbg_free(f);
+	dm_free(f);
 }
 
 struct dev_filter *md_filter_create(void)
 {
 	struct dev_filter *f;
 
-	if (!(f = dbg_malloc(sizeof(*f)))) {
+	if (!(f = dm_malloc(sizeof(*f)))) {
 		log_error("md filter allocation failed");
 		return NULL;
 	}

lib/filters/filter-persistent.c

@@ -16,7 +16,6 @@
 #include "lib.h"
 #include "config.h"
 #include "dev-cache.h"
-#include "hash.h"
 #include "filter-persistent.h"
 
 #include <sys/stat.h>
@@ -25,7 +24,7 @@
 
 struct pfilter {
 	char *file;
-	struct hash_table *devices;
+	struct dm_hash_table *devices;
 	struct dev_filter *real;
 };
 
@@ -39,9 +38,9 @@ struct pfilter {
 static int _init_hash(struct pfilter *pf)
 {
 	if (pf->devices)
-		hash_destroy(pf->devices);
+		dm_hash_destroy(pf->devices);
 
-	if (!(pf->devices = hash_create(128))) {
+	if (!(pf->devices = dm_hash_create(128))) {
 		stack;
 		return 0;
 	}
@@ -53,7 +52,9 @@ int persistent_filter_wipe(struct dev_filter *f)
 {
 	struct pfilter *pf = (struct pfilter *) f->private;
 
-	hash_wipe(pf->devices);
+	log_verbose("Wiping cache of LVM-capable devices");
+	dm_hash_wipe(pf->devices);
+
 	/* Trigger complete device scan */
 	dev_cache_scan(1);
 
@@ -83,7 +84,7 @@ static int _read_array(struct pfilter *pf, struct config_tree *cft,
 			continue;
 		}
 
-		if (!hash_insert(pf->devices, cv->v.str, data))
+		if (!dm_hash_insert(pf->devices, cv->v.str, data))
 			log_verbose("Couldn't add '%s' to filter ... ignoring",
 				    cv->v.str);
 		/* Populate dev_cache ourselves */
@@ -116,7 +117,7 @@ int persistent_filter_load(struct dev_filter *f)
 	   PF_BAD_DEVICE); */
 
 	/* Did we find anything? */
-	if (hash_get_num_entries(pf->devices)) {
+	if (dm_hash_get_num_entries(pf->devices)) {
 		/* We populated dev_cache ourselves */
 		dev_cache_scan(0);
 		r = 1;
@@ -134,11 +135,11 @@ static void _write_array(struct pfilter *pf, FILE *fp, const char *path,
 {
 	void *d;
 	int first = 1;
-	struct hash_node *n;
+	struct dm_hash_node *n;
 
-	for (n = hash_get_first(pf->devices); n;
-	     n = hash_get_next(pf->devices, n)) {
-		d = hash_get_data(pf->devices, n);
+	for (n = dm_hash_get_first(pf->devices); n;
+	     n = dm_hash_get_next(pf->devices, n)) {
+		d = dm_hash_get_data(pf->devices, n);
 
 		if (d != data)
 			continue;
@@ -150,7 +151,7 @@ static void _write_array(struct pfilter *pf, FILE *fp, const char *path,
 			first = 0;
 		}
 
-		fprintf(fp, "\t\t\"%s\"", hash_get_key(pf->devices, n));
+		fprintf(fp, "\t\t\"%s\"", dm_hash_get_key(pf->devices, n));
 	}
 
 	if (!first)
@@ -165,7 +166,7 @@ int persistent_filter_dump(struct dev_filter *f)
 
 	FILE *fp;
 
-	if (!hash_get_num_entries(pf->devices)) {
+	if (!dm_hash_get_num_entries(pf->devices)) {
 		log_very_verbose("Internal persistent device cache empty "
 				 "- not writing to %s", pf->file);
 		return 0;
@@ -200,36 +201,31 @@ int persistent_filter_dump(struct dev_filter *f)
 static int _lookup_p(struct dev_filter *f, struct device *dev)
 {
 	struct pfilter *pf = (struct pfilter *) f->private;
-	void *l = hash_lookup(pf->devices, dev_name(dev));
+	void *l = dm_hash_lookup(pf->devices, dev_name(dev));
 	struct str_list *sl;
-	struct list *ah;
 
 	if (!l) {
 		l = pf->real->passes_filter(pf->real, dev) ?
 		    PF_GOOD_DEVICE : PF_BAD_DEVICE;
 
-		list_iterate(ah, &dev->aliases) {
-			sl = list_item(ah, struct str_list);
-			hash_insert(pf->devices, sl->str, l);
-		}
-	}
+		list_iterate_items(sl, &dev->aliases)
+			dm_hash_insert(pf->devices, sl->str, l);
 
-	if (l == PF_BAD_DEVICE) {
-		log_debug("%s: Skipping (cached)", dev_name(dev));
-		return 0;
-	} else
-		return 1;
+	} else if (l == PF_BAD_DEVICE)
+			log_debug("%s: Skipping (cached)", dev_name(dev));
+
+	return (l == PF_BAD_DEVICE) ? 0 : 1;
 }
 
 static void _destroy(struct dev_filter *f)
 {
 	struct pfilter *pf = (struct pfilter *) f->private;
 
-	hash_destroy(pf->devices);
-	dbg_free(pf->file);
+	dm_hash_destroy(pf->devices);
+	dm_free(pf->file);
 	pf->real->destroy(pf->real);
-	dbg_free(pf);
-	dbg_free(f);
+	dm_free(pf);
+	dm_free(f);
 }
 
 struct dev_filter *persistent_filter_create(struct dev_filter *real,
@@ -238,13 +234,13 @@ struct dev_filter *persistent_filter_create(struct dev_filter *real,
 	struct pfilter *pf;
 	struct dev_filter *f = NULL;
 
-	if (!(pf = dbg_malloc(sizeof(*pf)))) {
+	if (!(pf = dm_malloc(sizeof(*pf)))) {
 		stack;
 		return NULL;
 	}
 	memset(pf, 0, sizeof(*pf));
 
-	if (!(pf->file = dbg_malloc(strlen(file) + 1))) {
+	if (!(pf->file = dm_malloc(strlen(file) + 1))) {
 		stack;
 		goto bad;
 	}
@@ -256,7 +252,7 @@ struct dev_filter *persistent_filter_create(struct dev_filter *real,
 		goto bad;
 	}
 
-	if (!(f = dbg_malloc(sizeof(*f)))) {
+	if (!(f = dm_malloc(sizeof(*f)))) {
 		stack;
 		goto bad;
 	}
@@ -268,10 +264,10 @@ struct dev_filter *persistent_filter_create(struct dev_filter *real,
 	return f;
 
       bad:
-	dbg_free(pf->file);
+	dm_free(pf->file);
 	if (pf->devices)
-		hash_destroy(pf->devices);
-	dbg_free(pf);
-	dbg_free(f);
+		dm_hash_destroy(pf->devices);
+	dm_free(pf);
+	dm_free(f);
 	return NULL;
 }

lib/filters/filter-regex.c

@@ -14,21 +14,18 @@
  */
 
 #include "lib.h"
-#include "pool.h"
 #include "filter-regex.h"
 #include "matcher.h"
 #include "device.h"
-#include "bitset.h"
-#include "list.h"
 
 struct rfilter {
-	struct pool *mem;
-	bitset_t accept;
+	struct dm_pool *mem;
+	dm_bitset_t accept;
 	struct matcher *engine;
 };
 
-static int _extract_pattern(struct pool *mem, const char *pat,
-			    char **regex, bitset_t accept, int ix)
+static int _extract_pattern(struct dm_pool *mem, const char *pat,
+			    char **regex, dm_bitset_t accept, int ix)
 {
 	char sep, *r, *ptr;
 
@@ -37,11 +34,11 @@ static int _extract_pattern(struct pool *mem, const char *pat,
 	 */
 	switch (*pat) {
 	case 'a':
-		bit_set(accept, ix);
+		dm_bit_set(accept, ix);
 		break;
 
 	case 'r':
-		bit_clear(accept, ix);
+		dm_bit_clear(accept, ix);
 		break;
 
 	default:
@@ -74,7 +71,7 @@ static int _extract_pattern(struct pool *mem, const char *pat,
 	/*
 	 * copy the regex
 	 */
-	if (!(r = pool_strdup(mem, pat))) {
+	if (!(r = dm_pool_strdup(mem, pat))) {
 		stack;
 		return 0;
 	}
@@ -95,13 +92,13 @@ static int _extract_pattern(struct pool *mem, const char *pat,
 
 static int _build_matcher(struct rfilter *rf, struct config_value *val)
 {
-	struct pool *scratch;
+	struct dm_pool *scratch;
 	struct config_value *v;
 	char **regex;
 	unsigned count = 0;
 	int i, r = 0;
 
-	if (!(scratch = pool_create(1024))) {
+	if (!(scratch = dm_pool_create("filter matcher", 1024))) {
 		stack;
 		return 0;
 	}
@@ -122,7 +119,7 @@ static int _build_matcher(struct rfilter *rf, struct config_value *val)
 	/*
 	 * allocate space for them
 	 */
-	if (!(regex = pool_alloc(scratch, sizeof(*regex) * count))) {
+	if (!(regex = dm_pool_alloc(scratch, sizeof(*regex) * count))) {
 		stack;
 		goto out;
 	}
@@ -130,7 +127,7 @@ static int _build_matcher(struct rfilter *rf, struct config_value *val)
 	/*
 	 * create the accept/reject bitset
 	 */
-	rf->accept = bitset_create(rf->mem, count);
+	rf->accept = dm_bitset_create(rf->mem, count);
 
 	/*
 	 * fill the array back to front because we
@@ -152,23 +149,21 @@ static int _build_matcher(struct rfilter *rf, struct config_value *val)
 	r = 1;
 
       out:
-	pool_destroy(scratch);
+	dm_pool_destroy(scratch);
 	return r;
 }
 
 static int _accept_p(struct dev_filter *f, struct device *dev)
 {
-	struct list *ah;
 	int m, first = 1, rejected = 0;
 	struct rfilter *rf = (struct rfilter *) f->private;
 	struct str_list *sl;
 
-	list_iterate(ah, &dev->aliases) {
-		sl = list_item(ah, struct str_list);
+	list_iterate_items(sl, &dev->aliases) {
 		m = matcher_run(rf->engine, sl->str);
 
 		if (m >= 0) {
-			if (bit(rf->accept, m)) {
+			if (dm_bit(rf->accept, m)) {
 
 				if (!first) {
 					log_debug("%s: New preferred name",
@@ -186,6 +181,9 @@ static int _accept_p(struct dev_filter *f, struct device *dev)
 		first = 0;
 	}
 
+	if (rejected)
+		log_debug("%s: Skipping (regex)", dev_name(dev));
+
 	/*
 	 * pass everything that doesn't match
 	 * anything.
@@ -196,12 +194,12 @@ static int _accept_p(struct dev_filter *f, struct device *dev)
 static void _destroy(struct dev_filter *f)
 {
 	struct rfilter *rf = (struct rfilter *) f->private;
-	pool_destroy(rf->mem);
+	dm_pool_destroy(rf->mem);
 }
 
 struct dev_filter *regex_filter_create(struct config_value *patterns)
 {
-	struct pool *mem = pool_create(10 * 1024);
+	struct dm_pool *mem = dm_pool_create("filter regex", 10 * 1024);
 	struct rfilter *rf;
 	struct dev_filter *f;
 
@@ -210,7 +208,7 @@ struct dev_filter *regex_filter_create(struct config_value *patterns)
 		return NULL;
 	}
 
-	if (!(rf = pool_alloc(mem, sizeof(*rf)))) {
+	if (!(rf = dm_pool_alloc(mem, sizeof(*rf)))) {
 		stack;
 		goto bad;
 	}
@@ -222,7 +220,7 @@ struct dev_filter *regex_filter_create(struct config_value *patterns)
 		goto bad;
 	}
 
-	if (!(f = pool_zalloc(mem, sizeof(*f)))) {
+	if (!(f = dm_pool_zalloc(mem, sizeof(*f)))) {
 		stack;
 		goto bad;
 	}
@@ -233,6 +231,6 @@ struct dev_filter *regex_filter_create(struct config_value *patterns)
 	return f;
 
       bad:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return NULL;
 }

lib/filters/filter-sysfs.c

@@ -15,7 +15,6 @@
 #include "lib.h"
 #include "filter-sysfs.h"
 #include "lvm-string.h"
-#include "pool.h"
 
 #ifdef linux
 
@@ -69,21 +68,21 @@ struct entry {
 
 #define SET_BUCKETS 64
 struct dev_set {
-	struct pool *mem;
+	struct dm_pool *mem;
 	const char *sys_block;
 	int initialised;
 	struct entry *slots[SET_BUCKETS];
 };
 
-static struct dev_set *_dev_set_create(struct pool *mem, const char *sys_block)
+static struct dev_set *_dev_set_create(struct dm_pool *mem, const char *sys_block)
 {
 	struct dev_set *ds;
 
-	if (!(ds = pool_zalloc(mem, sizeof(*ds))))
+	if (!(ds = dm_pool_zalloc(mem, sizeof(*ds))))
 		return NULL;
 
 	ds->mem = mem;
-	ds->sys_block = pool_strdup(mem, sys_block);
+	ds->sys_block = dm_pool_strdup(mem, sys_block);
 	ds->initialised = 0;
 
 	return ds;
@@ -102,7 +101,7 @@ static int _set_insert(struct dev_set *ds, dev_t dev)
 	struct entry *e;
 	unsigned h = _hash_dev(dev);
 
-	if (!(e = pool_alloc(ds->mem, sizeof(*e))))
+	if (!(e = dm_pool_alloc(ds->mem, sizeof(*e))))
 		return 0;
 
 	e->next = ds->slots[h];
@@ -172,7 +171,7 @@ static int _read_devs(struct dev_set *ds, const char *dir)
 	unsigned char dtype;
 	struct stat info;
 	char path[PATH_MAX];
-	dev_t dev;
+	dev_t dev = { 0 };
 	int r = 1;
 
         if (!(dr = opendir(dir))) {
@@ -194,8 +193,10 @@ static int _read_devs(struct dev_set *ds, const char *dir)
 		dtype = d->d_type;
 
 		if (dtype == DT_UNKNOWN) {
-			if (stat(path, &info) >= 0) {
-				if (S_ISDIR(info.st_mode))
+			if (lstat(path, &info) >= 0) {
+				if (S_ISLNK(info.st_mode))
+					dtype = DT_LNK;
+				else if (S_ISDIR(info.st_mode))
 					dtype = DT_DIR;
 				else if (S_ISREG(info.st_mode))
 					dtype = DT_REG;
@@ -246,26 +247,30 @@ static int _accept_p(struct dev_filter *f, struct device *dev)
 	if (ds->initialised != 1)
 		return 1;
 
-	return _set_lookup(ds, dev->dev);
+	if (!_set_lookup(ds, dev->dev)) {
+		log_debug("%s: Skipping (sysfs)", dev_name(dev));
+		return 0;
+	} else
+		return 1;
 }
 
 static void _destroy(struct dev_filter *f)
 {
 	struct dev_set *ds = (struct dev_set *) f->private;
-	pool_destroy(ds->mem);
+	dm_pool_destroy(ds->mem);
 }
 
 struct dev_filter *sysfs_filter_create(const char *proc)
 {
 	char sys_block[PATH_MAX];
-	struct pool *mem;
+	struct dm_pool *mem;
 	struct dev_set *ds;
 	struct dev_filter *f;
 
 	if (!_locate_sysfs_blocks(proc, sys_block, sizeof(sys_block)))
 		return NULL;
 
-	if (!(mem = pool_create(256))) {
+	if (!(mem = dm_pool_create("sysfs", 256))) {
 		log_error("sysfs pool creation failed");
 		return NULL;
 	}
@@ -275,7 +280,7 @@ struct dev_filter *sysfs_filter_create(const char *proc)
 		goto bad;
 	}
 
-	if (!(f = pool_zalloc(mem, sizeof(*f)))) {
+	if (!(f = dm_pool_zalloc(mem, sizeof(*f)))) {
 		stack;
 		goto bad;
 	}
@@ -286,7 +291,7 @@ struct dev_filter *sysfs_filter_create(const char *proc)
 	return f;
 
  bad:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return NULL;
 }
 

lib/filters/filter.c

@@ -18,6 +18,7 @@
 #include "filter.h"
 #include "lvm-string.h"
 #include "config.h"
+#include "metadata.h"
 
 #include <dirent.h>
 #include <unistd.h>
@@ -27,6 +28,9 @@
 
 #define NUMBER_OF_MAJORS 4096
 
+/* 0 means LVM won't use this major number. */
+static int _max_partitions_by_major[NUMBER_OF_MAJORS];
+
 typedef struct {
 	const char *name;
 	const int max_partitions;
@@ -39,12 +43,19 @@ int md_major(void)
 	return _md_major;
 }
 
-/* This list can be supplemented with devices/types in the config file */
+/*
+ * Devices are only checked for partition tables if their minor number
+ * is a multiple of the number corresponding to their type below
+ * i.e. this gives the granularity of whole-device minor numbers.
+ * Use 1 if the device is not partitionable.
+ *
+ * The list can be supplemented with devices/types in the config file.
+ */
 static const device_info_t device_info[] = {
-	{"ide", 16},		/* IDE disk */
+	{"ide", 64},		/* IDE disk */
 	{"sd", 16},		/* SCSI disk */
-	{"md", 16},		/* Multiple Disk driver (SoftRAID) */
-	{"loop", 16},		/* Loop device */
+	{"md", 1},		/* Multiple Disk driver (SoftRAID) */
+	{"loop", 1},		/* Loop device */
 	{"dasd", 4},		/* DASD disk (IBM S/390, zSeries) */
 	{"dac960", 8},		/* DAC960 */
 	{"nbd", 16},		/* Network Block Device */
@@ -53,38 +64,64 @@ static const device_info_t device_info[] = {
 	{"ubd", 16},		/* User-mode virtual block device */
 	{"ataraid", 16},	/* ATA Raid */
 	{"drbd", 16},		/* Distributed Replicated Block Device */
+	{"emcpower", 16},	/* EMC Powerpath */
 	{"power2", 16},		/* EMC Powerpath */
 	{"i2o_block", 16},	/* i2o Block Disk */
 	{"iseries/vd", 8},	/* iSeries disks */
+	{"gnbd", 1},		/* Network block device */
+	{"ramdisk", 1},		/* RAM disk */
+	{"aoe", 16},		/* ATA over Ethernet */
+	{"device-mapper", 1},	/* Other mapped devices */
+	{"xvd", 16},		/* Xen virtual block device */
 	{NULL, 0}
 };
 
 static int _passes_lvm_type_device_filter(struct dev_filter *f,
 					  struct device *dev)
 {
-	int fd;
 	const char *name = dev_name(dev);
+	int ret = 0;
+	uint64_t size;
 
 	/* Is this a recognised device type? */
-	if (!(((int *) f->private)[MAJOR(dev->dev)])) {
+	if (!_max_partitions_by_major[MAJOR(dev->dev)]) {
 		log_debug("%s: Skipping: Unrecognised LVM device type %"
 			  PRIu64, name, (uint64_t) MAJOR(dev->dev));
 		return 0;
 	}
 
 	/* Check it's accessible */
-	if ((fd = open(name, O_RDONLY)) < 0) {
-		log_debug("%s: Skipping: open failed: %s", name,
-			  strerror(errno));
+	if (!dev_open_flags(dev, O_RDONLY, 0, 1)) {
+		log_debug("%s: Skipping: open failed", name);
 		return 0;
 	}
+	
+	/* Check it's not too small */
+	if (!dev_get_size(dev, &size)) {
+		log_debug("%s: Skipping: dev_get_size failed", name);
+		goto out;
+	}
 
-	close(fd);
+	if (size < PV_MIN_SIZE) {
+		log_debug("%s: Skipping: Too small to hold a PV", name);
+		goto out;
+	}
 
-	return 1;
+	if (is_partitioned_dev(dev)) {
+		log_debug("%s: Skipping: Partition table signature found",
+			  name);
+		goto out;
+	}
+
+	ret = 1;
+
+      out:
+	dev_close(dev);
+
+	return ret;
 }
 
-static int *_scan_proc_dev(const char *proc, const struct config_node *cn)
+static int _scan_proc_dev(const char *proc, const struct config_node *cn)
 {
 	char line[80];
 	char proc_devices[PATH_MAX];
@@ -94,36 +131,31 @@ static int *_scan_proc_dev(const char *proc, const struct config_node *cn)
 	int blocksection = 0;
 	size_t dev_len = 0;
 	struct config_value *cv;
-	int *max_partitions_by_major;
 	char *name;
 
-	/* FIXME Make this sparse */
-	if (!(max_partitions_by_major =
-	      dbg_malloc(sizeof(int) * NUMBER_OF_MAJORS))) {
-		log_error("Filter failed to allocate max_partitions_by_major");
-		return NULL;
-	}
 
 	if (!*proc) {
 		log_verbose("No proc filesystem found: using all block device "
 			    "types");
 		for (i = 0; i < NUMBER_OF_MAJORS; i++)
-			max_partitions_by_major[i] = 1;
-		return max_partitions_by_major;
+			_max_partitions_by_major[i] = 1;
+		return 1;
 	}
 
+	/* All types unrecognised initially */
+	memset(_max_partitions_by_major, 0, sizeof(int) * NUMBER_OF_MAJORS);
+
 	if (lvm_snprintf(proc_devices, sizeof(proc_devices),
 			 "%s/devices", proc) < 0) {
 		log_error("Failed to create /proc/devices string");
-		return NULL;
+		return 0;
 	}
 
 	if (!(pd = fopen(proc_devices, "r"))) {
 		log_sys_error("fopen", proc_devices);
-		return NULL;
+		return 0;
 	}
 
-	memset(max_partitions_by_major, 0, sizeof(int) * NUMBER_OF_MAJORS);
 	while (fgets(line, 80, pd) != NULL) {
 		i = 0;
 		while (line[i] == ' ' && line[i] != '\0')
@@ -158,13 +190,13 @@ static int *_scan_proc_dev(const char *proc, const struct config_node *cn)
 			if (dev_len <= strlen(line + i) &&
 			    !strncmp(device_info[j].name, line + i, dev_len) &&
 			    (line_maj < NUMBER_OF_MAJORS)) {
-				max_partitions_by_major[line_maj] =
+				_max_partitions_by_major[line_maj] =
 				    device_info[j].max_partitions;
 				break;
 			}
 		}
 
-		if (max_partitions_by_major[line_maj] || !cn)
+		if (!cn)
 			continue;
 
 		/* Check devices/types for local variations */
@@ -172,7 +204,7 @@ static int *_scan_proc_dev(const char *proc, const struct config_node *cn)
 			if (cv->type != CFG_STRING) {
 				log_error("Expecting string in devices/types "
 					  "in config file");
-				return NULL;
+				return 0;
 			}
 			dev_len = strlen(cv->v.str);
 			name = cv->v.str;
@@ -181,24 +213,29 @@ static int *_scan_proc_dev(const char *proc, const struct config_node *cn)
 				log_error("Max partition count missing for %s "
 					  "in devices/types in config file",
 					  name);
-				return NULL;
+				return 0;
 			}
 			if (!cv->v.i) {
 				log_error("Zero partition count invalid for "
 					  "%s in devices/types in config file",
 					  name);
-				return NULL;
+				return 0;
 			}
 			if (dev_len <= strlen(line + i) &&
 			    !strncmp(name, line + i, dev_len) &&
 			    (line_maj < NUMBER_OF_MAJORS)) {
-				max_partitions_by_major[line_maj] = cv->v.i;
+				_max_partitions_by_major[line_maj] = cv->v.i;
 				break;
 			}
 		}
 	}
 	fclose(pd);
-	return max_partitions_by_major;
+	return 1;
+}
+
+int max_partitions(int major)
+{
+	return _max_partitions_by_major[major];
 }
 
 struct dev_filter *lvm_type_filter_create(const char *proc,
@@ -206,15 +243,16 @@ struct dev_filter *lvm_type_filter_create(const char *proc,
 {
 	struct dev_filter *f;
 
-	if (!(f = dbg_malloc(sizeof(struct dev_filter)))) {
+	if (!(f = dm_malloc(sizeof(struct dev_filter)))) {
 		log_error("LVM type filter allocation failed");
 		return NULL;
 	}
 
 	f->passes_filter = _passes_lvm_type_device_filter;
 	f->destroy = lvm_type_filter_destroy;
+	f->private = NULL;
 
-	if (!(f->private = _scan_proc_dev(proc, cn))) {
+	if (!_scan_proc_dev(proc, cn)) {
 		stack;
 		return NULL;
 	}
@@ -224,7 +262,6 @@ struct dev_filter *lvm_type_filter_create(const char *proc,
 
 void lvm_type_filter_destroy(struct dev_filter *f)
 {
-	dbg_free(f->private);
-	dbg_free(f);
+	dm_free(f);
 	return;
 }

lib/filters/filter.h

@@ -36,5 +36,6 @@ struct dev_filter *lvm_type_filter_create(const char *proc,
 void lvm_type_filter_destroy(struct dev_filter *f);
 
 int md_major(void);
+int max_partitions(int major);
 
 #endif

lib/format1/disk-rep.c

@@ -15,7 +15,6 @@
 
 #include "lib.h"
 #include "disk-rep.h"
-#include "pool.h"
 #include "xlate.h"
 #include "filter.h"
 #include "lvmcache.h"
@@ -255,7 +254,7 @@ static int _read_uuids(struct disk_list *data)
 		if (!dev_read(data->dev, pos, sizeof(buffer), buffer))
 			fail;
 
-		if (!(ul = pool_alloc(data->mem, sizeof(*ul))))
+		if (!(ul = dm_pool_alloc(data->mem, sizeof(*ul))))
 			fail;
 
 		memcpy(ul->uuid, buffer, NAME_LEN);
@@ -284,7 +283,7 @@ static int _read_lvs(struct disk_list *data)
 
 	for (i = 0; (i < vgd->lv_max) && (read < vgd->lv_cur); i++) {
 		pos = data->pvd.lv_on_disk.base + (i * sizeof(struct lv_disk));
-		ll = pool_alloc(data->mem, sizeof(*ll));
+		ll = dm_pool_alloc(data->mem, sizeof(*ll));
 
 		if (!ll)
 			fail;
@@ -305,7 +304,7 @@ static int _read_lvs(struct disk_list *data)
 static int _read_extents(struct disk_list *data)
 {
 	size_t len = sizeof(struct pe_disk) * data->pvd.pe_total;
-	struct pe_disk *extents = pool_alloc(data->mem, len);
+	struct pe_disk *extents = dm_pool_alloc(data->mem, len);
 	uint64_t pos = data->pvd.pe_on_disk.base;
 
 	if (!extents)
@@ -321,10 +320,10 @@ static int _read_extents(struct disk_list *data)
 }
 
 static struct disk_list *__read_disk(const struct format_type *fmt,
-				     struct device *dev, struct pool *mem,
+				     struct device *dev, struct dm_pool *mem,
 				     const char *vg_name)
 {
-	struct disk_list *dl = pool_alloc(mem, sizeof(*dl));
+	struct disk_list *dl = dm_pool_alloc(mem, sizeof(*dl));
 	const char *name = dev_name(dev);
 	struct lvmcache_info *info;
 
@@ -400,12 +399,12 @@ static struct disk_list *__read_disk(const struct format_type *fmt,
 	return dl;
 
       bad:
-	pool_free(dl->mem, dl);
+	dm_pool_free(dl->mem, dl);
 	return NULL;
 }
 
 struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
-			    struct pool *mem, const char *vg_name)
+			    struct dm_pool *mem, const char *vg_name)
 {
 	struct disk_list *r;
 
@@ -424,11 +423,11 @@ struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
 
 static void _add_pv_to_list(struct list *head, struct disk_list *data)
 {
-	struct list *pvdh;
 	struct pv_disk *pvd;
+	struct disk_list *diskl;
 
-	list_iterate(pvdh, head) {
-		pvd = &list_item(pvdh, struct disk_list)->pvd;
+	list_iterate_items(diskl, head) {
+		pvd = &diskl->pvd;
 		if (!strncmp(data->pvd.pv_uuid, pvd->pv_uuid,
 			     sizeof(pvd->pv_uuid))) {
 			if (MAJOR(data->dev->dev) != md_major()) {
@@ -439,7 +438,7 @@ 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(pvdh);
+			list_del(&diskl->list);
 			break;
 		}
 	}
@@ -452,20 +451,20 @@ static void _add_pv_to_list(struct list *head, struct disk_list *data)
  * so we can free off all the memory if something goes wrong.
  */
 int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
-		   struct dev_filter *filter, struct pool *mem,
+		   struct dev_filter *filter, struct dm_pool *mem,
 		   struct list *head)
 {
 	struct dev_iter *iter;
 	struct device *dev;
 	struct disk_list *data = NULL;
-	struct list *vgih;
 	struct lvmcache_vginfo *vginfo;
+	struct lvmcache_info *info;
 
 	/* Fast path if we already saw this VG and cached the list of PVs */
 	if (vg_name && (vginfo = vginfo_from_vgname(vg_name)) &&
 	    vginfo->infos.n) {
-		list_iterate(vgih, &vginfo->infos) {
-			dev = list_item(vgih, struct lvmcache_info)->dev;
+		list_iterate_items(info, &vginfo->infos) {
+			dev = info->dev;
 			if (dev && !(data = read_disk(fmt, dev, mem, vg_name)))
 				break;
 			_add_pv_to_list(head, data);
@@ -482,7 +481,7 @@ int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		/* vgcache_del(vg_name); */
 	}
 
-	if (!(iter = dev_iter_create(filter))) {
+	if (!(iter = dev_iter_create(filter, 1))) {
 		log_error("read_pvs_in_vg: dev_iter_create failed");
 		return 0;
 	}
@@ -506,6 +505,9 @@ static int _write_vgd(struct disk_list *data)
 	struct vg_disk *vgd = &data->vgd;
 	uint64_t pos = data->pvd.vg_on_disk.base;
 
+	log_debug("Writing %s VG metadata to %s at %" PRIu64 " len %" PRIsize_t,
+		  data->pvd.vg_name, dev_name(data->dev), pos, sizeof(*vgd));
+
 	_xlate_vgd(vgd);
 	if (!dev_write(data->dev, pos, sizeof(*vgd), vgd))
 		fail;
@@ -518,18 +520,20 @@ static int _write_vgd(struct disk_list *data)
 static int _write_uuids(struct disk_list *data)
 {
 	struct uuid_list *ul;
-	struct list *uh;
 	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;
 	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;
 
-	list_iterate(uh, &data->uuids) {
+	list_iterate_items(ul, &data->uuids) {
 		if (pos >= end) {
 			log_error("Too many uuids to fit on %s",
 				  dev_name(data->dev));
 			return 0;
 		}
 
-		ul = list_item(uh, struct uuid_list);
+		log_debug("Writing %s uuidlist to %s at %" PRIu64 " len %d",
+			  data->pvd.vg_name, dev_name(data->dev),
+			  pos, NAME_LEN);
+
 		if (!dev_write(data->dev, pos, NAME_LEN, ul->uuid))
 			fail;
 
@@ -541,6 +545,10 @@ static int _write_uuids(struct disk_list *data)
 
 static int _write_lvd(struct device *dev, uint64_t pos, struct lv_disk *disk)
 {
+	log_debug("Writing %s LV %s metadata to %s at %" PRIu64 " len %"
+		  PRIsize_t, disk->vg_name, disk->lv_name, dev_name(dev),
+		  pos, sizeof(*disk));
+
 	_xlate_lvd(disk);
 	if (!dev_write(dev, pos, sizeof(*disk), disk))
 		fail;
@@ -552,7 +560,7 @@ static int _write_lvd(struct device *dev, uint64_t pos, struct lv_disk *disk)
 
 static int _write_lvs(struct disk_list *data)
 {
-	struct list *lvh;
+	struct lvd_list *ll;
 	uint64_t pos, offset;
 
 	pos = data->pvd.lv_on_disk.base;
@@ -563,9 +571,7 @@ static int _write_lvs(struct disk_list *data)
 		return 0;
 	}
 
-	list_iterate(lvh, &data->lvds) {
-		struct lvd_list *ll = list_item(lvh, struct lvd_list);
-
+	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);
@@ -585,6 +591,10 @@ static int _write_extents(struct disk_list *data)
 	struct pe_disk *extents = data->extents;
 	uint64_t pos = data->pvd.pe_on_disk.base;
 
+	log_debug("Writing %s extents metadata to %s at %" PRIu64 " len %"
+		  PRIsize_t, data->pvd.vg_name, dev_name(data->dev),
+		  pos, len);
+
 	_xlate_extents(extents, data->pvd.pe_total);
 	if (!dev_write(data->dev, pos, len, extents))
 		fail;
@@ -608,7 +618,7 @@ static int _write_pvd(struct disk_list *data)
 	/* Make sure that the gap between the PV structure and
 	   the next one is zeroed in order to make non LVM tools
 	   happy (idea from AED) */
-	buf = dbg_malloc(size);
+	buf = dm_malloc(size);
 	if (!buf) {
 		log_err("Couldn't allocate temporary PV buffer.");
 		return 0;
@@ -617,13 +627,17 @@ static int _write_pvd(struct disk_list *data)
 	memset(buf, 0, size);
 	memcpy(buf, &data->pvd, sizeof(struct pv_disk));
 
+	log_debug("Writing %s PV metadata to %s at %" PRIu64 " len %"
+		  PRIsize_t, data->pvd.vg_name, dev_name(data->dev),
+		  pos, size);
+
 	_xlate_pvd((struct pv_disk *) buf);
 	if (!dev_write(data->dev, pos, size, buf)) {
-		dbg_free(buf);
+		dm_free(buf);
 		fail;
 	}
 
-	dbg_free(buf);
+	dm_free(buf);
 	return 1;
 }
 
@@ -704,11 +718,9 @@ static int _write_all_pvd(const struct format_type *fmt, struct disk_list *data)
  */
 int write_disks(const struct format_type *fmt, struct list *pvs)
 {
-	struct list *pvh;
 	struct disk_list *dl;
 
-	list_iterate(pvh, pvs) {
-		dl = list_item(pvh, struct disk_list);
+	list_iterate_items(dl, pvs) {
 		if (!(_write_all_pvd(fmt, dl)))
 			fail;
 

lib/format1/disk-rep.h

@@ -18,7 +18,6 @@
 
 #include "lvm-types.h"
 #include "metadata.h"
-#include "pool.h"
 #include "toolcontext.h"
 
 #define MAX_PV 256
@@ -159,7 +158,7 @@ struct lvd_list {
 
 struct disk_list {
 	struct list list;
-	struct pool *mem;
+	struct dm_pool *mem;
 	struct device *dev;
 
 	struct pv_disk pvd;
@@ -191,11 +190,11 @@ int calculate_extent_count(struct physical_volume *pv, uint32_t extent_size,
  */
 
 struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
-			    struct pool *mem, const char *vg_name);
+			    struct dm_pool *mem, const char *vg_name);
 
 int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		   struct dev_filter *filter,
-		   struct pool *mem, struct list *results);
+		   struct dm_pool *mem, struct list *results);
 
 int write_disks(const struct format_type *fmt, struct list *pvds);
 
@@ -203,33 +202,33 @@ int write_disks(const struct format_type *fmt, struct list *pvds);
  * Functions to translate to between disk and in
  * core structures.
  */
-int import_pv(struct pool *mem, struct device *dev,
+int import_pv(struct dm_pool *mem, struct device *dev,
 	      struct volume_group *vg,
 	      struct physical_volume *pv, struct pv_disk *pvd);
-int export_pv(struct cmd_context *cmd, struct pool *mem,
+int export_pv(struct cmd_context *cmd, struct dm_pool *mem,
 	      struct volume_group *vg,
 	      struct pv_disk *pvd, struct physical_volume *pv);
 
-int import_vg(struct pool *mem,
+int import_vg(struct dm_pool *mem,
 	      struct volume_group *vg, struct disk_list *dl, int partial);
 int export_vg(struct vg_disk *vgd, struct volume_group *vg);
 
-int import_lv(struct pool *mem, struct logical_volume *lv, struct lv_disk *lvd);
+int import_lv(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);
 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 pool *mem,
+int import_pvs(const struct format_type *fmt, struct dm_pool *mem,
 	       struct volume_group *vg,
 	       struct list *pvds, struct list *results, int *count);
 
-int import_lvs(struct pool *mem, struct volume_group *vg, struct list *pvds);
+int import_lvs(struct dm_pool *mem, struct volume_group *vg, struct 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 pool *mem, struct volume_group *vg,
+int import_snapshots(struct dm_pool *mem, struct volume_group *vg,
 		     struct list *pvds);
 
 int export_uuids(struct disk_list *dl, struct volume_group *vg);

lib/format1/format1.c

@@ -15,10 +15,7 @@
 
 #include "lib.h"
 #include "disk-rep.h"
-#include "pool.h"
-#include "hash.h"
 #include "limits.h"
-#include "list.h"
 #include "display.h"
 #include "toolcontext.h"
 #include "lvmcache.h"
@@ -46,9 +43,7 @@ static int _check_vgs(struct list *pvs, int *partial)
 	 * This means an active VG won't be affected if disks are inserted
 	 * bearing an exported VG with the same name.
 	 */
-	list_iterate(pvh, pvs) {
-		dl = list_item(pvh, struct disk_list);
-
+	list_iterate_items(dl, pvs) {
 		if (first_time) {
 			exported = dl->pvd.pv_status & VG_EXPORTED;
 			first_time = 0;
@@ -130,8 +125,8 @@ static int _check_vgs(struct list *pvs, int *partial)
 static struct volume_group *_build_vg(struct format_instance *fid,
 				      struct list *pvs)
 {
-	struct pool *mem = fid->fmt->cmd->mem;
-	struct volume_group *vg = pool_alloc(mem, sizeof(*vg));
+	struct dm_pool *mem = fid->fmt->cmd->mem;
+	struct volume_group *vg = dm_pool_alloc(mem, sizeof(*vg));
 	struct disk_list *dl;
 	int partial;
 
@@ -148,7 +143,6 @@ static struct volume_group *_build_vg(struct format_instance *fid,
 	vg->seqno = 0;
 	list_init(&vg->pvs);
 	list_init(&vg->lvs);
-	list_init(&vg->snapshots);
 	list_init(&vg->tags);
 
 	if (!_check_vgs(pvs, &partial))
@@ -175,7 +169,7 @@ static struct volume_group *_build_vg(struct format_instance *fid,
 
       bad:
 	stack;
-	pool_free(mem, vg);
+	dm_pool_free(mem, vg);
 	return NULL;
 }
 
@@ -183,7 +177,7 @@ static struct volume_group *_vg_read(struct format_instance *fid,
 				     const char *vg_name,
 				     struct metadata_area *mda)
 {
-	struct pool *mem = pool_create(1024 * 10);
+	struct dm_pool *mem = dm_pool_create("lvm1 vg_read", 1024 * 10);
 	struct list pvs;
 	struct volume_group *vg = NULL;
 	list_init(&pvs);
@@ -208,16 +202,16 @@ static struct volume_group *_vg_read(struct format_instance *fid,
 	}
 
       bad:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return vg;
 }
 
 static struct disk_list *_flatten_pv(struct format_instance *fid,
-				     struct pool *mem, struct volume_group *vg,
+				     struct dm_pool *mem, struct volume_group *vg,
 				     struct physical_volume *pv,
 				     const char *dev_dir)
 {
-	struct disk_list *dl = pool_alloc(mem, sizeof(*dl));
+	struct disk_list *dl = dm_pool_alloc(mem, sizeof(*dl));
 
 	if (!dl) {
 		stack;
@@ -235,25 +229,22 @@ static struct disk_list *_flatten_pv(struct format_instance *fid,
 	    !export_uuids(dl, vg) ||
 	    !export_lvs(dl, vg, pv, dev_dir) || !calculate_layout(dl)) {
 		stack;
-		pool_free(mem, dl);
+		dm_pool_free(mem, dl);
 		return NULL;
 	}
 
 	return dl;
 }
 
-static int _flatten_vg(struct format_instance *fid, struct pool *mem,
+static int _flatten_vg(struct format_instance *fid, struct dm_pool *mem,
 		       struct volume_group *vg,
 		       struct list *pvds, const char *dev_dir,
 		       struct dev_filter *filter)
 {
-	struct list *pvh;
 	struct pv_list *pvl;
 	struct disk_list *data;
 
-	list_iterate(pvh, &vg->pvs) {
-		pvl = list_item(pvh, struct pv_list);
-
+	list_iterate_items(pvl, &vg->pvs) {
 		if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir))) {
 			stack;
 			return 0;
@@ -276,7 +267,7 @@ static int _flatten_vg(struct format_instance *fid, struct pool *mem,
 static int _vg_write(struct format_instance *fid, struct volume_group *vg,
 		     struct metadata_area *mda)
 {
-	struct pool *mem = pool_create(1024 * 10);
+	struct dm_pool *mem = dm_pool_create("lvm1 vg_write", 1024 * 10);
 	struct list pvds;
 	int r = 0;
 
@@ -292,14 +283,14 @@ static int _vg_write(struct format_instance *fid, struct volume_group *vg,
 	     write_disks(fid->fmt, &pvds));
 
 	lvmcache_update_vg(vg);
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return r;
 }
 
 static int _pv_read(const struct format_type *fmt, const char *pv_name,
 		    struct physical_volume *pv, struct list *mdas)
 {
-	struct pool *mem = pool_create(1024);
+	struct dm_pool *mem = dm_pool_create("lvm1 pv_read", 1024);
 	struct disk_list *dl;
 	struct device *dev;
 	int r = 0;
@@ -331,7 +322,7 @@ static int _pv_read(const struct format_type *fmt, const char *pv_name,
 	r = 1;
 
       out:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return r;
 }
 
@@ -398,7 +389,7 @@ static int _lv_setup(struct format_instance *fid, struct logical_volume *lv)
 static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 		     struct list *mdas, int64_t sector)
 {
-	struct pool *mem;
+	struct dm_pool *mem;
 	struct disk_list *dl;
 	struct list pvs;
 	struct label *label;
@@ -421,12 +412,12 @@ static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 	pv->pe_size = pv->pe_count = 0;
 	pv->pe_start = PE_ALIGN;
 
-	if (!(mem = pool_create(1024))) {
+	if (!(mem = dm_pool_create("lvm1 pv_write", 1024))) {
 		stack;
 		return 0;
 	}
 
-	if (!(dl = pool_alloc(mem, sizeof(*dl)))) {
+	if (!(dl = dm_pool_alloc(mem, sizeof(*dl)))) {
 		stack;
 		goto bad;
 	}
@@ -450,11 +441,11 @@ static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 		goto bad;
 	}
 
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return 1;
 
       bad:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return 0;
 }
 
@@ -516,7 +507,7 @@ static struct format_instance *_create_instance(const struct format_type *fmt,
 	struct format_instance *fid;
 	struct metadata_area *mda;
 
-	if (!(fid = pool_alloc(fmt->cmd->mem, sizeof(*fid)))) {
+	if (!(fid = dm_pool_alloc(fmt->cmd->mem, sizeof(*fid)))) {
 		stack;
 		return NULL;
 	}
@@ -525,9 +516,9 @@ static struct format_instance *_create_instance(const struct format_type *fmt,
 	list_init(&fid->metadata_areas);
 
 	/* Define a NULL metadata area */
-	if (!(mda = pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
+	if (!(mda = dm_pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
 		stack;
-		pool_free(fmt->cmd->mem, fid);
+		dm_pool_free(fmt->cmd->mem, fid);
 		return NULL;
 	}
 
@@ -545,7 +536,7 @@ static void _destroy_instance(struct format_instance *fid)
 
 static void _destroy(const struct format_type *fmt)
 {
-	dbg_free((void *) fmt);
+	dm_free((void *) fmt);
 }
 
 static struct format_handler _format1_ops = {
@@ -567,7 +558,7 @@ struct format_type *init_format(struct cmd_context *cmd);
 struct format_type *init_format(struct cmd_context *cmd)
 #endif
 {
-	struct format_type *fmt = dbg_malloc(sizeof(*fmt));
+	struct format_type *fmt = dm_malloc(sizeof(*fmt));
 
 	if (!fmt) {
 		stack;

lib/format1/import-export.c

@@ -19,13 +19,11 @@
 
 #include "lib.h"
 #include "disk-rep.h"
-#include "pool.h"
-#include "hash.h"
-#include "list.h"
 #include "lvm-string.h"
 #include "filter.h"
 #include "toolcontext.h"
 #include "segtype.h"
+#include "pv_alloc.h"
 
 #include <time.h>
 
@@ -37,7 +35,7 @@ static int _check_vg_name(const char *name)
 /*
  * Extracts the last part of a path.
  */
-static char *_create_lv_name(struct pool *mem, const char *full_name)
+static char *_create_lv_name(struct dm_pool *mem, const char *full_name)
 {
 	const char *ptr = strrchr(full_name, '/');
 
@@ -46,10 +44,10 @@ static char *_create_lv_name(struct pool *mem, const char *full_name)
 	else
 		ptr++;
 
-	return pool_strdup(mem, ptr);
+	return dm_pool_strdup(mem, ptr);
 }
 
-int import_pv(struct pool *mem, struct device *dev,
+int import_pv(struct dm_pool *mem, struct device *dev,
 	      struct volume_group *vg,
 	      struct physical_volume *pv, struct pv_disk *pvd)
 {
@@ -57,7 +55,7 @@ int import_pv(struct pool *mem, struct device *dev,
 	memcpy(&pv->id, pvd->pv_uuid, ID_LEN);
 
 	pv->dev = dev;
-	if (!(pv->vg_name = pool_strdup(mem, pvd->vg_name))) {
+	if (!(pv->vg_name = dm_pool_strdup(mem, pvd->vg_name))) {
 		stack;
 		return 0;
 	}
@@ -86,9 +84,15 @@ int import_pv(struct pool *mem, struct device *dev,
 	pv->pe_size = pvd->pe_size;
 	pv->pe_start = pvd->pe_start;
 	pv->pe_count = pvd->pe_total;
-	pv->pe_alloc_count = pvd->pe_allocated;
+	pv->pe_alloc_count = 0;
 
 	list_init(&pv->tags);
+	list_init(&pv->segments);
+
+	if (!alloc_pv_segment_whole_pv(mem, pv)) {
+		stack;
+		return 0;
+	}
 
 	return 1;
 }
@@ -105,7 +109,7 @@ static int _system_id(struct cmd_context *cmd, char *s, const char *prefix)
 	return 1;
 }
 
-int export_pv(struct cmd_context *cmd, struct pool *mem,
+int export_pv(struct cmd_context *cmd, struct dm_pool *mem,
 	      struct volume_group *vg,
 	      struct pv_disk *pvd, struct physical_volume *pv)
 {
@@ -191,7 +195,7 @@ int export_pv(struct cmd_context *cmd, struct pool *mem,
 	return 1;
 }
 
-int import_vg(struct pool *mem,
+int import_vg(struct dm_pool *mem,
 	      struct volume_group *vg, struct disk_list *dl, int partial)
 {
 	struct vg_disk *vgd = &dl->vgd;
@@ -202,12 +206,12 @@ int import_vg(struct pool *mem,
 		return 0;
 	}
 
-	if (!(vg->name = pool_strdup(mem, dl->pvd.vg_name))) {
+	if (!(vg->name = dm_pool_strdup(mem, dl->pvd.vg_name))) {
 		stack;
 		return 0;
 	}
 
-	if (!(vg->system_id = pool_alloc(mem, NAME_LEN))) {
+	if (!(vg->system_id = dm_pool_alloc(mem, NAME_LEN))) {
 		stack;
 		return 0;
 	}
@@ -234,7 +238,7 @@ int import_vg(struct pool *mem,
 
 	vg->extent_size = vgd->pe_size;
 	vg->extent_count = vgd->pe_total;
-	vg->free_count = vgd->pe_total - vgd->pe_allocated;
+	vg->free_count = vgd->pe_total;
 	vg->max_lv = vgd->lv_max;
 	vg->max_pv = vgd->pv_max;
 	vg->alloc = ALLOC_NORMAL;
@@ -281,7 +285,7 @@ int export_vg(struct vg_disk *vgd, struct volume_group *vg)
 	return 1;
 }
 
-int import_lv(struct pool *mem, struct logical_volume *lv, struct lv_disk *lvd)
+int import_lv(struct dm_pool *mem, struct logical_volume *lv, struct lv_disk *lvd)
 {
 	lvid_from_lvnum(&lv->lvid, &lv->vg->id, lvd->lv_number);
 
@@ -323,6 +327,8 @@ int import_lv(struct pool *mem, struct logical_volume *lv, struct lv_disk *lvd)
 	lv->size = lvd->lv_size;
 	lv->le_count = lvd->lv_allocated_le;
 
+	lv->snapshot = NULL;
+	list_init(&lv->snapshot_segs);
 	list_init(&lv->segments);
 	list_init(&lv->tags);
 
@@ -373,14 +379,11 @@ static void _export_lv(struct lv_disk *lvd, struct volume_group *vg,
 int export_extents(struct disk_list *dl, uint32_t lv_num,
 		   struct logical_volume *lv, struct physical_volume *pv)
 {
-	struct list *segh;
 	struct pe_disk *ped;
 	struct lv_segment *seg;
 	uint32_t pe, s;
 
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
-
+	list_iterate_items(seg, &lv->segments) {
 		for (s = 0; s < seg->area_count; s++) {
 			if (!(seg->segtype->flags & SEG_FORMAT1_SUPPORT)) {
 				log_error("Segment type %s in LV %s: "
@@ -388,16 +391,16 @@ int export_extents(struct disk_list *dl, uint32_t lv_num,
 					  seg->segtype->name, lv->name);
 				return 0;
 			}
-			if (seg->area[s].type != AREA_PV) {
-				log_error("LV stripe found in LV %s: "
+			if (seg_type(seg, s) != AREA_PV) {
+				log_error("Non-PV stripe found in LV %s: "
 					  "unsupported by format1", lv->name);
 				return 0;
 			}
-			if (seg->area[s].u.pv.pv != pv)
+			if (seg_pv(seg, s) != pv)
 				continue;	/* not our pv */
 
 			for (pe = 0; pe < (seg->len / seg->area_count); pe++) {
-				ped = &dl->extents[pe + seg->area[s].u.pv.pe];
+				ped = &dl->extents[pe + seg_pe(seg, s)];
 				ped->lv_num = lv_num;
 				ped->le_num = (seg->le / seg->area_count) + pe +
 				    s * (lv->le_count / seg->area_count);
@@ -408,21 +411,17 @@ int export_extents(struct disk_list *dl, uint32_t lv_num,
 	return 1;
 }
 
-int import_pvs(const struct format_type *fmt, struct pool *mem,
+int import_pvs(const struct format_type *fmt, struct dm_pool *mem,
 	       struct volume_group *vg,
 	       struct list *pvds, struct list *results, int *count)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	struct pv_list *pvl;
 
 	*count = 0;
-	list_iterate(pvdh, pvds) {
-
-		dl = list_item(pvdh, struct disk_list);
-
-		if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) ||
-		    !(pvl->pv = pool_alloc(mem, sizeof(*pvl->pv)))) {
+	list_iterate_items(dl, pvds) {
+		if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl))) ||
+		    !(pvl->pv = dm_pool_alloc(mem, sizeof(*pvl->pv)))) {
 			stack;
 			return 0;
 		}
@@ -440,15 +439,15 @@ int import_pvs(const struct format_type *fmt, struct pool *mem,
 	return 1;
 }
 
-static struct logical_volume *_add_lv(struct pool *mem,
+static struct logical_volume *_add_lv(struct dm_pool *mem,
 				      struct volume_group *vg,
 				      struct lv_disk *lvd)
 {
 	struct lv_list *ll;
 	struct logical_volume *lv;
 
-	if (!(ll = pool_zalloc(mem, sizeof(*ll))) ||
-	    !(ll->lv = pool_zalloc(mem, sizeof(*ll->lv)))) {
+	if (!(ll = dm_pool_zalloc(mem, sizeof(*ll))) ||
+	    !(ll->lv = dm_pool_zalloc(mem, sizeof(*ll->lv)))) {
 		stack;
 		return NULL;
 	}
@@ -466,17 +465,14 @@ static struct logical_volume *_add_lv(struct pool *mem,
 	return lv;
 }
 
-int import_lvs(struct pool *mem, struct volume_group *vg, struct list *pvds)
+int import_lvs(struct dm_pool *mem, struct volume_group *vg, struct list *pvds)
 {
 	struct disk_list *dl;
 	struct lvd_list *ll;
 	struct lv_disk *lvd;
-	struct list *pvdh, *lvdh;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
-		list_iterate(lvdh, &dl->lvds) {
-			ll = list_item(lvdh, struct lvd_list);
+	list_iterate_items(dl, pvds) {
+		list_iterate_items(ll, &dl->lvds) {
 			lvd = &ll->lvd;
 
 			if (!find_lv(vg, lvd->lv_name) &&
@@ -495,19 +491,18 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 	       struct physical_volume *pv, const char *dev_dir)
 {
 	int r = 0;
-	struct list *lvh, *sh;
 	struct lv_list *ll;
 	struct lvd_list *lvdl;
 	size_t len;
 	uint32_t lv_num;
-	struct hash_table *lvd_hash;
+	struct dm_hash_table *lvd_hash;
 
 	if (!_check_vg_name(vg->name)) {
 		stack;
 		return 0;
 	}
 
-	if (!(lvd_hash = hash_create(32))) {
+	if (!(lvd_hash = dm_hash_create(32))) {
 		stack;
 		return 0;
 	}
@@ -516,15 +511,17 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 	 * setup the pv's extents array
 	 */
 	len = sizeof(struct pe_disk) * dl->pvd.pe_total;
-	if (!(dl->extents = pool_alloc(dl->mem, len))) {
+	if (!(dl->extents = dm_pool_alloc(dl->mem, len))) {
 		stack;
 		goto out;
 	}
 	memset(dl->extents, 0, len);
 
-	list_iterate(lvh, &vg->lvs) {
-		ll = list_item(lvh, struct lv_list);
-		if (!(lvdl = pool_alloc(dl->mem, sizeof(*lvdl)))) {
+	list_iterate_items(ll, &vg->lvs) {
+		if (ll->lv->status & SNAPSHOT)
+			continue;
+
+		if (!(lvdl = dm_pool_alloc(dl->mem, sizeof(*lvdl)))) {
 			stack;
 			goto out;
 		}
@@ -532,10 +529,9 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 		_export_lv(&lvdl->lvd, vg, ll->lv, dev_dir);
 
 		lv_num = lvnum_from_lvid(&ll->lv->lvid);
-
 		lvdl->lvd.lv_number = lv_num;
 
-		if (!hash_insert(lvd_hash, ll->lv->name, &lvdl->lvd)) {
+		if (!dm_hash_insert(lvd_hash, ll->lv->name, &lvdl->lvd)) {
 			stack;
 			goto out;
 		}
@@ -545,64 +541,45 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 			goto out;
 		}
 
+		if (lv_is_origin(ll->lv))
+			lvdl->lvd.lv_access |= LV_SNAPSHOT_ORG;
+
+		if (lv_is_cow(ll->lv)) {
+			lvdl->lvd.lv_access |= LV_SNAPSHOT;
+			lvdl->lvd.lv_chunk_size = ll->lv->snapshot->chunk_size;
+			lvdl->lvd.lv_snapshot_minor =
+			    lvnum_from_lvid(&ll->lv->snapshot->origin->lvid);
+		}
+
 		list_add(&dl->lvds, &lvdl->list);
 		dl->pvd.lv_cur++;
 	}
 
-	/*
-	 * Now we need to run through the snapshots, exporting
-	 * the SNAPSHOT_ORG flags etc.
-	 */
-	list_iterate(sh, &vg->snapshots) {
-		struct lv_disk *org, *cow;
-		struct snapshot *s = list_item(sh,
-					       struct snapshot_list)->snapshot;
-
-		if (!(org = hash_lookup(lvd_hash, s->origin->name))) {
-			log_err("Couldn't find snapshot origin '%s'.",
-				s->origin->name);
-			goto out;
-		}
-
-		if (!(cow = hash_lookup(lvd_hash, s->cow->name))) {
-			log_err("Couldn't find snapshot cow store '%s'.",
-				s->cow->name);
-			goto out;
-		}
-
-		org->lv_access |= LV_SNAPSHOT_ORG;
-		cow->lv_access |= LV_SNAPSHOT;
-		cow->lv_snapshot_minor = org->lv_number;
-		cow->lv_chunk_size = s->chunk_size;
-	}
-
 	r = 1;
 
       out:
-	hash_destroy(lvd_hash);
+	dm_hash_destroy(lvd_hash);
 	return r;
 }
 
 /*
  * FIXME: More inefficient code.
  */
-int import_snapshots(struct pool *mem, struct volume_group *vg,
+int import_snapshots(struct dm_pool *mem, struct volume_group *vg,
 		     struct list *pvds)
 {
 	struct logical_volume *lvs[MAX_LV];
-	struct list *pvdh, *lvdh;
 	struct disk_list *dl;
+	struct lvd_list *ll;
 	struct lv_disk *lvd;
 	int lvnum;
 	struct logical_volume *org, *cow;
 
 	/* build an index of lv numbers */
 	memset(lvs, 0, sizeof(lvs));
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
-
-		list_iterate(lvdh, &dl->lvds) {
-			lvd = &(list_item(lvdh, struct lvd_list)->lvd);
+	list_iterate_items(dl, pvds) {
+		list_iterate_items(ll, &dl->lvds) {
+			lvd = &ll->lvd;
 
 			lvnum = lvd->lv_number;
 
@@ -624,11 +601,9 @@ int import_snapshots(struct pool *mem, struct volume_group *vg,
 	/*
 	 * Now iterate through yet again adding the snapshots.
 	 */
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
-
-		list_iterate(lvdh, &dl->lvds) {
-			lvd = &(list_item(lvdh, struct lvd_list)->lvd);
+	list_iterate_items(dl, pvds) {
+		list_iterate_items(ll, &dl->lvds) {
+			lvd = &ll->lvd;
 
 			if (!(lvd->lv_access & LV_SNAPSHOT))
 				continue;
@@ -646,7 +621,8 @@ int import_snapshots(struct pool *mem, struct volume_group *vg,
 				continue;
 
 			/* insert the snapshot */
-			if (!vg_add_snapshot(org, cow, 1, NULL,
+			if (!vg_add_snapshot(vg->fid, NULL, org, cow, NULL,
+					     org->le_count, 
 					     lvd->lv_chunk_size)) {
 				log_err("Couldn't add snapshot.");
 				return 0;
@@ -661,11 +637,9 @@ int export_uuids(struct disk_list *dl, struct volume_group *vg)
 {
 	struct uuid_list *ul;
 	struct pv_list *pvl;
-	struct list *pvh;
 
-	list_iterate(pvh, &vg->pvs) {
-		pvl = list_item(pvh, struct pv_list);
-		if (!(ul = pool_alloc(dl->mem, sizeof(*ul)))) {
+	list_iterate_items(pvl, &vg->pvs) {
+		if (!(ul = dm_pool_alloc(dl->mem, sizeof(*ul)))) {
 			stack;
 			return 0;
 		}
@@ -684,14 +658,11 @@ int export_uuids(struct disk_list *dl, struct volume_group *vg)
  */
 void export_numbers(struct list *pvds, struct volume_group *vg)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	int pv_num = 1;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		dl->pvd.pv_number = pv_num++;
-	}
 }
 
 /*
@@ -699,26 +670,20 @@ void export_numbers(struct list *pvds, struct volume_group *vg)
  */
 void export_pv_act(struct list *pvds)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	int act = 0;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		if (dl->pvd.pv_status & PV_ACTIVE)
 			act++;
-	}
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		dl->vgd.pv_act = act;
-	}
 }
 
 int export_vg_number(struct format_instance *fid, struct list *pvds,
 		     const char *vg_name, struct dev_filter *filter)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	int vg_num;
 
@@ -727,10 +692,8 @@ int export_vg_number(struct format_instance *fid, struct list *pvds,
 		return 0;
 	}
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		dl->vgd.vg_number = vg_num;
-	}
 
 	return 1;
 }

lib/format1/import-extents.c

@@ -15,8 +15,6 @@
 
 #include "lib.h"
 #include "metadata.h"
-#include "hash.h"
-#include "pool.h"
 #include "disk-rep.h"
 #include "lv_alloc.h"
 #include "display.h"
@@ -44,11 +42,10 @@ struct lv_map {
 	struct pe_specifier *map;
 };
 
-static struct hash_table *_create_lv_maps(struct pool *mem,
+static struct dm_hash_table *_create_lv_maps(struct dm_pool *mem,
 					  struct volume_group *vg)
 {
-	struct hash_table *maps = hash_create(32);
-	struct list *llh;
+	struct dm_hash_table *maps = dm_hash_create(32);
 	struct lv_list *ll;
 	struct lv_map *lvm;
 
@@ -58,22 +55,23 @@ static struct hash_table *_create_lv_maps(struct pool *mem,
 		return NULL;
 	}
 
-	list_iterate(llh, &vg->lvs) {
-		ll = list_item(llh, struct lv_list);
+	list_iterate_items(ll, &vg->lvs) {
+		if (ll->lv->status & SNAPSHOT)
+			continue;
 
-		if (!(lvm = pool_alloc(mem, sizeof(*lvm)))) {
+		if (!(lvm = dm_pool_alloc(mem, sizeof(*lvm)))) {
 			stack;
 			goto bad;
 		}
 
 		lvm->lv = ll->lv;
-		if (!(lvm->map = pool_zalloc(mem, sizeof(*lvm->map)
+		if (!(lvm->map = dm_pool_zalloc(mem, sizeof(*lvm->map)
 					     * ll->lv->le_count))) {
 			stack;
 			goto bad;
 		}
 
-		if (!hash_insert(maps, ll->lv->name, lvm)) {
+		if (!dm_hash_insert(maps, ll->lv->name, lvm)) {
 			stack;
 			goto bad;
 		}
@@ -82,21 +80,20 @@ static struct hash_table *_create_lv_maps(struct pool *mem,
 	return maps;
 
       bad:
-	hash_destroy(maps);
+	dm_hash_destroy(maps);
 	return NULL;
 }
 
 static int _fill_lv_array(struct lv_map **lvs,
-			  struct hash_table *maps, struct disk_list *dl)
+			  struct dm_hash_table *maps, struct disk_list *dl)
 {
-	struct list *lvh;
+	struct lvd_list *ll;
 	struct lv_map *lvm;
 
 	memset(lvs, 0, sizeof(*lvs) * MAX_LV);
-	list_iterate(lvh, &dl->lvds) {
-		struct lvd_list *ll = list_item(lvh, struct lvd_list);
 
-		if (!(lvm = hash_lookup(maps, strrchr(ll->lvd.lv_name, '/')
+	list_iterate_items(ll, &dl->lvds) {
+		if (!(lvm = dm_hash_lookup(maps, strrchr(ll->lvd.lv_name, '/')
 					+ 1))) {
 			log_err("Physical volume (%s) contains an "
 				"unknown logical volume (%s).",
@@ -113,18 +110,16 @@ static int _fill_lv_array(struct lv_map **lvs,
 	return 1;
 }
 
-static int _fill_maps(struct hash_table *maps, struct volume_group *vg,
+static int _fill_maps(struct dm_hash_table *maps, struct volume_group *vg,
 		      struct list *pvds)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	struct physical_volume *pv;
 	struct lv_map *lvms[MAX_LV], *lvm;
 	struct pe_disk *e;
 	uint32_t i, lv_num, le;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds) {
 		pv = find_pv(vg, dl->dev);
 		e = dl->extents;
 
@@ -187,13 +182,13 @@ static int _check_single_map(struct lv_map *lvm)
 	return 1;
 }
 
-static int _check_maps_are_complete(struct hash_table *maps)
+static int _check_maps_are_complete(struct dm_hash_table *maps)
 {
-	struct hash_node *n;
+	struct dm_hash_node *n;
 	struct lv_map *lvm;
 
-	for (n = hash_get_first(maps); n; n = hash_get_next(maps, n)) {
-		lvm = (struct lv_map *) hash_get_data(maps, n);
+	for (n = dm_hash_get_first(maps); n; n = dm_hash_get_next(maps, n)) {
+		lvm = (struct lv_map *) dm_hash_get_data(maps, n);
 
 		if (!_check_single_map(lvm)) {
 			stack;
@@ -205,58 +200,59 @@ static int _check_maps_are_complete(struct hash_table *maps)
 
 static int _read_linear(struct cmd_context *cmd, struct lv_map *lvm)
 {
-	uint32_t le = 0;
+	uint32_t le = 0, len;
 	struct lv_segment *seg;
+	struct segment_type *segtype;
+
+	if (!(segtype = get_segtype_from_string(cmd, "striped"))) {
+		stack;
+		return 0;
+	}
 
 	while (le < lvm->lv->le_count) {
-		seg = alloc_lv_segment(cmd->mem, 1);
+		len = 0;
 
-		seg->lv = lvm->lv;
-		if (!(seg->segtype = get_segtype_from_string(cmd, "striped"))) {
+		do
+			len++;
+		while ((lvm->map[le + len].pv == lvm->map[le].pv) &&
+			 (lvm->map[le].pv &&
+			  lvm->map[le + len].pe == lvm->map[le].pe + len));
+
+		if (!(seg = alloc_lv_segment(cmd->mem, segtype, lvm->lv, le,
+					     len, 0, 0, NULL, 1, len, 0, 0, 0))) {
+			log_error("Failed to allocate linear segment.");
+			return 0;
+		}
+
+		if (!set_lv_segment_area_pv(seg, 0, lvm->map[le].pv,
+					    lvm->map[le].pe)) {
 			stack;
 			return 0;
 		}
 
-		seg->le = le;
-		seg->len = 0;
-		seg->area_len = 0;
-		seg->stripe_size = 0;
-
-		seg->area[0].type = AREA_PV;
-		seg->area[0].u.pv.pv = lvm->map[le].pv;
-		seg->area[0].u.pv.pe = lvm->map[le].pe;
-
-		do {
-			seg->len++;
-			seg->area_len++;
-		} while ((lvm->map[le + seg->len].pv == seg->area[0].u.pv.pv) &&
-			 (seg->area[0].u.pv.pv &&
-			  lvm->map[le + seg->len].pe == seg->area[0].u.pv.pe +
-			  seg->len));
+		list_add(&lvm->lv->segments, &seg->list);
 
 		le += seg->len;
-
-		list_add(&lvm->lv->segments, &seg->list);
 	}
 
 	return 1;
 }
 
-static int _check_stripe(struct lv_map *lvm, struct lv_segment *seg,
-			 uint32_t base_le, uint32_t len)
+static int _check_stripe(struct lv_map *lvm, uint32_t area_count,
+			 uint32_t seg_len, uint32_t base_le, uint32_t len)
 {
-	uint32_t le, st;
-
-	le = base_le + seg->len;
+	uint32_t st;
 
 	/*
 	 * Is the next physical extent in every stripe adjacent to the last?
 	 */
-	for (st = 0; st < seg->area_count; st++)
-		if ((lvm->map[le + st * len].pv != seg->area[st].u.pv.pv) ||
-		    (seg->area[st].u.pv.pv &&
-		     lvm->map[le + st * len].pe !=
-		     seg->area[st].u.pv.pe + seg->len)) return 0;
+	for (st = 0; st < area_count; st++)
+		if ((lvm->map[base_le + st * len + seg_len].pv !=
+		     lvm->map[base_le + st * len].pv) ||
+		    (lvm->map[base_le + st * len].pv &&
+		     lvm->map[base_le + st * len + seg_len].pe !=
+		     lvm->map[base_le + st * len].pe + seg_len))
+			return 0;
 
 	return 1;
 }
@@ -264,7 +260,9 @@ static int _check_stripe(struct lv_map *lvm, struct lv_segment *seg,
 static int _read_stripes(struct cmd_context *cmd, struct lv_map *lvm)
 {
 	uint32_t st, le = 0, len;
+	uint32_t area_len;
 	struct lv_segment *seg;
+	struct segment_type *segtype;
 
 	/*
 	 * Work out overall striped length
@@ -276,43 +274,46 @@ static int _read_stripes(struct cmd_context *cmd, struct lv_map *lvm)
 	}
 	len = lvm->lv->le_count / lvm->stripes;
 
+	if (!(segtype = get_segtype_from_string(cmd, "striped"))) {
+		stack;
+		return 0;
+	}
+
 	while (le < len) {
-		if (!(seg = alloc_lv_segment(cmd->mem, lvm->stripes))) {
-			stack;
-			return 0;
-		}
-
-		seg->lv = lvm->lv;
-		if (!(seg->segtype = get_segtype_from_string(cmd, "striped"))) {
-			stack;
-			return 0;
-		}
-		seg->stripe_size = lvm->stripe_size;
-		seg->le = seg->area_count * le;
-		seg->len = 1;
-		seg->area_len = 1;
-
-		/*
-		 * Set up start positions of each stripe in this segment
-		 */
-		for (st = 0; st < seg->area_count; st++) {
-			seg->area[st].u.pv.pv = lvm->map[le + st * len].pv;
-			seg->area[st].u.pv.pe = lvm->map[le + st * len].pe;
-		}
+		area_len = 1;
 
 		/* 
 		 * Find how many blocks are contiguous in all stripes
 		 * and so can form part of this segment
 		 */
-		while (_check_stripe(lvm, seg, le, len)) {
-			seg->len++;
-			seg->area_len++;
+		while (_check_stripe(lvm, lvm->stripes,
+				     area_len * lvm->stripes, le, len))
+			area_len++;
+
+		if (!(seg = alloc_lv_segment(cmd->mem, segtype, lvm->lv,
+					     lvm->stripes * le,
+					     lvm->stripes * area_len,
+					     0, lvm->stripe_size, NULL,
+					     lvm->stripes,
+					     area_len, 0, 0, 0))) {
+			log_error("Failed to allocate striped segment.");
+			return 0;
 		}
 
-		le += seg->len;
-		seg->len *= seg->area_count;
+		/*
+		 * Set up start positions of each stripe in this segment
+		 */
+		for (st = 0; st < seg->area_count; st++)
+			if (!set_lv_segment_area_pv(seg, st,
+						    lvm->map[le + st * len].pv,
+						    lvm->map[le + st * len].pe)) {
+				stack;
+				return 0;
+			}
 
 		list_add(&lvm->lv->segments, &seg->list);
+
+		le += seg->len;
 	}
 
 	return 1;
@@ -324,13 +325,13 @@ static int _build_segments(struct cmd_context *cmd, struct lv_map *lvm)
 		_read_linear(cmd, lvm));
 }
 
-static int _build_all_segments(struct cmd_context *cmd, struct hash_table *maps)
+static int _build_all_segments(struct cmd_context *cmd, struct dm_hash_table *maps)
 {
-	struct hash_node *n;
+	struct dm_hash_node *n;
 	struct lv_map *lvm;
 
-	for (n = hash_get_first(maps); n; n = hash_get_next(maps, n)) {
-		lvm = (struct lv_map *) hash_get_data(maps, n);
+	for (n = dm_hash_get_first(maps); n; n = dm_hash_get_next(maps, n)) {
+		lvm = (struct lv_map *) dm_hash_get_data(maps, n);
 		if (!_build_segments(cmd, lvm)) {
 			stack;
 			return 0;
@@ -344,8 +345,8 @@ int import_extents(struct cmd_context *cmd, struct volume_group *vg,
 		   struct list *pvds)
 {
 	int r = 0;
-	struct pool *scratch = pool_create(10 * 1024);
-	struct hash_table *maps;
+	struct dm_pool *scratch = dm_pool_create("lvm1 import_extents", 10 * 1024);
+	struct dm_hash_table *maps;
 
 	if (!scratch) {
 		stack;
@@ -375,7 +376,7 @@ int import_extents(struct cmd_context *cmd, struct volume_group *vg,
 
       out:
 	if (maps)
-		hash_destroy(maps);
-	pool_destroy(scratch);
+		dm_hash_destroy(maps);
+	dm_pool_destroy(scratch);
 	return r;
 }

lib/format1/layout.c

@@ -117,7 +117,7 @@ int calculate_layout(struct disk_list *dl)
 int calculate_extent_count(struct physical_volume *pv, uint32_t extent_size,
 			   uint32_t max_extent_count, uint64_t pe_start)
 {
-	struct pv_disk *pvd = dbg_malloc(sizeof(*pvd));
+	struct pv_disk *pvd = dm_malloc(sizeof(*pvd));
 	uint32_t end;
 
 	if (!pvd) {
@@ -138,7 +138,7 @@ int calculate_extent_count(struct physical_volume *pv, uint32_t extent_size,
 	if (pvd->pe_total < PE_SIZE_PV_SIZE_REL) {
 		log_error("Too few extents on %s.  Try smaller extent size.",
 			  dev_name(pv->dev));
-		dbg_free(pvd);
+		dm_free(pvd);
 		return 0;
 	}
 
@@ -160,13 +160,13 @@ int calculate_extent_count(struct physical_volume *pv, uint32_t extent_size,
 		log_error("Metadata extent limit (%u) exceeded for %s - "
 			  "%u required", MAX_PE_TOTAL, dev_name(pv->dev),
 			  pvd->pe_total);
-		dbg_free(pvd);
+		dm_free(pvd);
 		return 0;
 	}
 
 	pv->pe_count = pvd->pe_total;
 	pv->pe_start = pvd->pe_start;
 	/* We can't set pe_size here without breaking LVM1 compatibility */
-	dbg_free(pvd);
+	dm_free(pvd);
 	return 1;
 }

lib/format1/lvm1-label.c

@@ -90,7 +90,7 @@ static void _destroy_label(struct labeller *l, struct label *label)
 
 static void _destroy(struct labeller *l)
 {
-	dbg_free(l);
+	dm_free(l);
 }
 
 struct label_ops _lvm1_ops = {
@@ -107,7 +107,7 @@ struct labeller *lvm1_labeller_create(struct format_type *fmt)
 {
 	struct labeller *l;
 
-	if (!(l = dbg_malloc(sizeof(*l)))) {
+	if (!(l = dm_malloc(sizeof(*l)))) {
 		log_err("Couldn't allocate labeller object.");
 		return NULL;
 	}

lib/format1/vg_number.c

@@ -14,7 +14,6 @@
  */
 
 #include "lib.h"
-#include "pool.h"
 #include "disk-rep.h"
 
 /*
@@ -27,10 +26,9 @@
 int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 		       const char *candidate_vg, int *result)
 {
-	struct list *pvh;
 	struct list all_pvs;
 	struct disk_list *dl;
-	struct pool *mem = pool_create(10 * 1024);
+	struct dm_pool *mem = dm_pool_create("lvm1 vg_number", 10 * 1024);
 	int numbers[MAX_VG], i, r = 0;
 
 	list_init(&all_pvs);
@@ -47,8 +45,7 @@ int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 
 	memset(numbers, 0, sizeof(numbers));
 
-	list_iterate(pvh, &all_pvs) {
-		dl = list_item(pvh, struct disk_list);
+	list_iterate_items(dl, &all_pvs) {
 		if (!*dl->pvd.vg_name || !strcmp(dl->pvd.vg_name, candidate_vg))
 			continue;
 
@@ -64,6 +61,6 @@ int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 	}
 
       out:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return r;
 }

lib/format_pool/disk_rep.c

@@ -14,12 +14,10 @@
  */
 
 #include "lib.h"
-#include "pool.h"
 #include "label.h"
 #include "metadata.h"
 #include "lvmcache.h"
 #include "filter.h"
-#include "list.h"
 #include "xlate.h"
 
 #include "disk_rep.h"
@@ -35,7 +33,7 @@
 #define CPOUT_64(x, y) {(y) = xlate64_be((x));}
 
 static int __read_pool_disk(const struct format_type *fmt, struct device *dev,
-			    struct pool *mem, struct pool_list *pl,
+			    struct dm_pool *mem, struct pool_list *pl,
 			    const char *vg_name)
 {
 	char buf[512];
@@ -57,12 +55,9 @@ static int __read_pool_disk(const struct format_type *fmt, struct device *dev,
 
 static void _add_pl_to_list(struct list *head, struct pool_list *data)
 {
-	struct list *pvdh;
 	struct pool_list *pl;
 
-	list_iterate(pvdh, head) {
-		pl = list_item(pvdh, struct pool_list);
-
+	list_iterate_items(pl, head) {
 		if (id_equal(&data->pv_uuid, &pl->pv_uuid)) {
 			char uuid[ID_LEN + 7];
 
@@ -76,7 +71,7 @@ static void _add_pl_to_list(struct list *head, struct pool_list *data)
 			}
 			log_very_verbose("Duplicate PV %s - using md %s",
 					 uuid, dev_name(data->dev));
-			list_del(pvdh);
+			list_del(&pl->list);
 			break;
 		}
 	}
@@ -243,15 +238,13 @@ void get_pool_uuid(char *uuid, uint64_t poolid, uint32_t spid, uint32_t devid)
 
 }
 
-static int _read_vg_pds(const struct format_type *fmt, struct pool *mem,
+static int _read_vg_pds(const struct format_type *fmt, struct dm_pool *mem,
 			struct lvmcache_vginfo *vginfo, struct list *head,
 			uint32_t *devcount)
 {
-
-	struct list *vgih = NULL;
-	struct device *dev;
+	struct lvmcache_info *info;
 	struct pool_list *pl = NULL;
-	struct pool *tmpmem = NULL;
+	struct dm_pool *tmpmem;
 
 	uint32_t sp_count = 0;
 	uint32_t *sp_devs = NULL;
@@ -259,28 +252,28 @@ static int _read_vg_pds(const struct format_type *fmt, struct pool *mem,
 
 	/* FIXME: maybe should return a different error in memory
 	 * allocation failure */
-	if (!(tmpmem = pool_create(512))) {
+	if (!(tmpmem = dm_pool_create("pool read_vg", 512))) {
 		stack;
 		return 0;
 	}
 
-	list_iterate(vgih, &vginfo->infos) {
-		dev = list_item(vgih, struct lvmcache_info)->dev;
-		if (dev &&
-		    !(pl = read_pool_disk(fmt, dev, mem, vginfo->vgname)))
+	list_iterate_items(info, &vginfo->infos) {
+		if (info->dev &&
+		    !(pl = read_pool_disk(fmt, info->dev, mem, vginfo->vgname)))
 			    break;
 		/*
 		 * We need to keep track of the total expected number
 		 * of devices per subpool
 		 */
 		if (!sp_count) {
+			/* FIXME pl left uninitialised if !info->dev */
 			sp_count = pl->pd.pl_subpools;
 			if (!(sp_devs =
-			      pool_zalloc(tmpmem,
+			      dm_pool_zalloc(tmpmem,
 					  sizeof(uint32_t) * sp_count))) {
 				log_error("Unable to allocate %d 32-bit uints",
 					  sp_count);
-				pool_destroy(tmpmem);
+				dm_pool_destroy(tmpmem);
 				return 0;
 			}
 		}
@@ -298,11 +291,10 @@ static int _read_vg_pds(const struct format_type *fmt, struct pool *mem,
 	}
 
 	*devcount = 0;
-	for (i = 0; i < sp_count; i++) {
+	for (i = 0; i < sp_count; i++)
 		*devcount += sp_devs[i];
-	}
 
-	pool_destroy(tmpmem);
+	dm_pool_destroy(tmpmem);
 
 	if (pl && *pl->pd.pl_pool_name)
 		return 1;
@@ -312,7 +304,7 @@ static int _read_vg_pds(const struct format_type *fmt, struct pool *mem,
 }
 
 int read_pool_pds(const struct format_type *fmt, const char *vg_name,
-		  struct pool *mem, struct list *pdhead)
+		  struct dm_pool *mem, struct list *pdhead)
 {
 	struct lvmcache_vginfo *vginfo;
 	uint32_t totaldevs;
@@ -357,7 +349,7 @@ int read_pool_pds(const struct format_type *fmt, const char *vg_name,
 }
 
 struct pool_list *read_pool_disk(const struct format_type *fmt,
-				 struct device *dev, struct pool *mem,
+				 struct device *dev, struct dm_pool *mem,
 				 const char *vg_name)
 {
 	struct pool_list *pl;
@@ -367,7 +359,7 @@ struct pool_list *read_pool_disk(const struct format_type *fmt,
 		return NULL;
 	}
 
-	if (!(pl = pool_zalloc(mem, sizeof(*pl)))) {
+	if (!(pl = dm_pool_zalloc(mem, sizeof(*pl)))) {
 		log_error("Unable to allocate pool list structure");
 		return 0;
 	}

lib/format_pool/disk_rep.h

@@ -18,7 +18,8 @@
 
 #include "label.h"
 #include "metadata.h"
-#include "pool.h"
+
+#define MINOR_OFFSET 65536
 
 /* From NSP.cf */
 #define NSPMajorVersion	4
@@ -66,29 +67,6 @@ struct pool_list;
 struct user_subpool;
 struct user_device;
 
-/* This must be kept up to date with sistina/pool/module/pool_sptypes.h */
-
-/*  Generic Labels  */
-#define SPTYPE_DATA                (0x00000000)
-
-/*  GFS specific labels  */
-#define SPTYPE_GFS_DATA            (0x68011670)
-#define SPTYPE_GFS_JOURNAL         (0x69011670)
-
-struct sptype_name {
-	const char *name;
-	uint32_t label;
-};
-
-static const struct sptype_name sptype_names[] = {
-	{"data",	SPTYPE_DATA},
-
-	{"gfs_data",	SPTYPE_GFS_DATA},
-	{"gfs_journal",	SPTYPE_GFS_JOURNAL},
-
-	{"", 0x0}		/*  This must be the last flag.  */
-};
-
 struct pool_disk {
 	uint64_t pl_magic;	/* Pool magic number */
 	uint64_t pl_pool_id;	/* Unique pool identifier */
@@ -159,20 +137,20 @@ int read_pool_label(struct pool_list *pl, struct labeller *l,
 void pool_label_out(struct pool_disk *pl, char *buf);
 void pool_label_in(struct pool_disk *pl, char *buf);
 void get_pool_uuid(char *uuid, uint64_t poolid, uint32_t spid, uint32_t devid);
-int import_pool_vg(struct volume_group *vg, struct pool *mem, struct list *pls);
-int import_pool_lvs(struct volume_group *vg, struct pool *mem,
+int import_pool_vg(struct volume_group *vg, struct dm_pool *mem, struct list *pls);
+int import_pool_lvs(struct volume_group *vg, struct dm_pool *mem,
 		    struct list *pls);
 int import_pool_pvs(const struct format_type *fmt, struct volume_group *vg,
-		    struct list *pvs, struct pool *mem, struct list *pls);
-int import_pool_pv(const struct format_type *fmt, struct pool *mem,
+		    struct list *pvs, struct dm_pool *mem, struct list *pls);
+int import_pool_pv(const struct format_type *fmt, struct dm_pool *mem,
 		   struct volume_group *vg, struct physical_volume *pv,
 		   struct pool_list *pl);
-int import_pool_segments(struct list *lvs, struct pool *mem,
+int import_pool_segments(struct list *lvs, struct dm_pool *mem,
 			 struct user_subpool *usp, int sp_count);
 int read_pool_pds(const struct format_type *fmt, const char *vgname,
-		  struct pool *mem, struct list *head);
+		  struct dm_pool *mem, struct list *head);
 struct pool_list *read_pool_disk(const struct format_type *fmt,
-				 struct device *dev, struct pool *mem,
+				 struct device *dev, struct dm_pool *mem,
 				 const char *vg_name);
 
 #endif				/* DISK_REP_POOL_FORMAT_H */

lib/format_pool/format_pool.c

@@ -14,12 +14,9 @@
  */
 
 #include "lib.h"
-#include "pool.h"
 #include "label.h"
 #include "metadata.h"
-#include "hash.h"
 #include "limits.h"
-#include "list.h"
 #include "display.h"
 #include "toolcontext.h"
 #include "lvmcache.h"
@@ -30,11 +27,9 @@
 #define FMT_POOL_NAME "pool"
 
 /* Must be called after pvs are imported */
-static struct user_subpool *_build_usp(struct list *pls, struct pool *mem,
+static struct user_subpool *_build_usp(struct list *pls, struct dm_pool *mem,
 				       int *sps)
 {
-
-	struct list *plhs;
 	struct pool_list *pl;
 	struct user_subpool *usp = NULL, *cur_sp = NULL;
 	struct user_device *cur_dev = NULL;
@@ -43,11 +38,9 @@ static struct user_subpool *_build_usp(struct list *pls, struct pool *mem,
 	 * FIXME: Need to do some checks here - I'm tempted to add a
 	 * user_pool structure and build the entire thing to check against.
 	 */
-	list_iterate(plhs, pls) {
-		pl = list_item(plhs, struct pool_list);
-
+	list_iterate_items(pl, pls) {
 		*sps = pl->pd.pl_subpools;
-		if (!usp && (!(usp = pool_zalloc(mem, sizeof(*usp) * (*sps))))) {
+		if (!usp && (!(usp = dm_pool_zalloc(mem, sizeof(*usp) * (*sps))))) {
 			log_error("Unable to allocate %d subpool structures",
 				  *sps);
 			return 0;
@@ -65,20 +58,20 @@ static struct user_subpool *_build_usp(struct list *pls, struct pool *mem,
 
 		if (!cur_sp->devs &&
 		    (!(cur_sp->devs =
-		       pool_zalloc(mem,
+		       dm_pool_zalloc(mem,
 				   sizeof(*usp->devs) * pl->pd.pl_sp_devs)))) {
 
 			log_error("Unable to allocate %d pool_device "
 				  "structures", pl->pd.pl_sp_devs);
 			return 0;
 		}
+
 		cur_dev = &cur_sp->devs[pl->pd.pl_sp_devid];
 		cur_dev->sp_id = cur_sp->id;
 		cur_dev->devid = pl->pd.pl_sp_id;
 		cur_dev->blocks = pl->pd.pl_blocks;
 		cur_dev->pv = pl->pv;
 		cur_dev->initialized = 1;
-
 	}
 
 	return usp;
@@ -107,15 +100,15 @@ static int _check_usp(char *vgname, struct user_subpool *usp, int sp_count)
 }
 
 static struct volume_group *_build_vg_from_pds(struct format_instance
-					       *fid, struct pool *mem,
+					       *fid, struct dm_pool *mem,
 					       struct list *pds)
 {
-	struct pool *smem = fid->fmt->cmd->mem;
+	struct dm_pool *smem = fid->fmt->cmd->mem;
 	struct volume_group *vg = NULL;
 	struct user_subpool *usp = NULL;
 	int sp_count;
 
-	if (!(vg = pool_zalloc(smem, sizeof(*vg)))) {
+	if (!(vg = dm_pool_zalloc(smem, sizeof(*vg)))) {
 		log_error("Unable to allocate volume group structure");
 		return NULL;
 	}
@@ -132,7 +125,6 @@ static struct volume_group *_build_vg_from_pds(struct format_instance
 	vg->system_id = NULL;
 	list_init(&vg->pvs);
 	list_init(&vg->lvs);
-	list_init(&vg->snapshots);
 	list_init(&vg->tags);
 
 	if (!import_pool_vg(vg, smem, pds)) {
@@ -181,7 +173,7 @@ static struct volume_group *_vg_read(struct format_instance *fid,
 				     const char *vg_name,
 				     struct metadata_area *mda)
 {
-	struct pool *mem = pool_create(1024);
+	struct dm_pool *mem = dm_pool_create("pool vg_read", 1024);
 	struct list pds;
 	struct volume_group *vg = NULL;
 
@@ -210,7 +202,7 @@ static struct volume_group *_vg_read(struct format_instance *fid,
 	}
 
       out:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return vg;
 }
 
@@ -227,7 +219,7 @@ static int _pv_setup(const struct format_type *fmt,
 static int _pv_read(const struct format_type *fmt, const char *pv_name,
 		    struct physical_volume *pv, struct list *mdas)
 {
-	struct pool *mem = pool_create(1024);
+	struct dm_pool *mem = dm_pool_create("pool pv_read", 1024);
 	struct pool_list *pl;
 	struct device *dev;
 	int r = 0;
@@ -264,7 +256,7 @@ static int _pv_read(const struct format_type *fmt, const char *pv_name,
 	r = 1;
 
       out:
-	pool_destroy(mem);
+	dm_pool_destroy(mem);
 	return r;
 }
 
@@ -281,7 +273,7 @@ static struct format_instance *_create_instance(const struct format_type *fmt,
 	struct format_instance *fid;
 	struct metadata_area *mda;
 
-	if (!(fid = pool_zalloc(fmt->cmd->mem, sizeof(*fid)))) {
+	if (!(fid = dm_pool_zalloc(fmt->cmd->mem, sizeof(*fid)))) {
 		log_error("Unable to allocate format instance structure for "
 			  "pool format");
 		return NULL;
@@ -291,10 +283,10 @@ static struct format_instance *_create_instance(const struct format_type *fmt,
 	list_init(&fid->metadata_areas);
 
 	/* Define a NULL metadata area */
-	if (!(mda = pool_zalloc(fmt->cmd->mem, sizeof(*mda)))) {
+	if (!(mda = dm_pool_zalloc(fmt->cmd->mem, sizeof(*mda)))) {
 		log_error("Unable to allocate metadata area structure "
 			  "for pool format");
-		pool_free(fmt->cmd->mem, fid);
+		dm_pool_free(fmt->cmd->mem, fid);
 		return NULL;
 	}
 
@@ -312,7 +304,7 @@ static void _destroy_instance(struct format_instance *fid)
 
 static void _destroy(const struct format_type *fmt)
 {
-	dbg_free((void *) fmt);
+	dm_free((void *) fmt);
 }
 
 /* *INDENT-OFF* */
@@ -332,7 +324,7 @@ struct format_type *init_format(struct cmd_context *cmd);
 struct format_type *init_format(struct cmd_context *cmd)
 #endif
 {
-	struct format_type *fmt = dbg_malloc(sizeof(*fmt));
+	struct format_type *fmt = dm_malloc(sizeof(*fmt));
 
 	if (!fmt) {
 		log_error("Unable to allocate format type structure for pool "

lib/format_pool/import_export.c

@@ -14,26 +14,24 @@
  */
 
 #include "lib.h"
-#include "pool.h"
 #include "label.h"
 #include "metadata.h"
 #include "lvmcache.h"
 #include "disk_rep.h"
+#include "sptype_names.h"
 #include "lv_alloc.h"
+#include "pv_alloc.h"
 #include "str_list.h"
 #include "display.h"
 #include "segtype.h"
 
 /* This file contains only imports at the moment... */
 
-int import_pool_vg(struct volume_group *vg, struct pool *mem, struct list *pls)
+int import_pool_vg(struct volume_group *vg, struct dm_pool *mem, struct list *pls)
 {
-	struct list *plhs;
 	struct pool_list *pl;
 
-	list_iterate(plhs, pls) {
-		pl = list_item(plhs, struct pool_list);
-
+	list_iterate_items(pl, pls) {
 		vg->extent_count +=
 		    ((pl->pd.pl_blocks) / POOL_PE_SIZE);
 
@@ -42,11 +40,11 @@ int import_pool_vg(struct volume_group *vg, struct pool *mem, struct list *pls)
 		if (vg->name)
 			continue;
 
-		vg->name = pool_strdup(mem, pl->pd.pl_pool_name);
+		vg->name = dm_pool_strdup(mem, pl->pd.pl_pool_name);
 		get_pool_vg_uuid(&vg->id, &pl->pd);
 		vg->extent_size = POOL_PE_SIZE;
 		vg->status |= LVM_READ | LVM_WRITE | CLUSTERED | SHARED;
-		vg->free_count = 0;
+		vg->free_count = vg->extent_count;
 		vg->max_lv = 1;
 		vg->max_pv = POOL_MAX_DEVICES;
 		vg->alloc = ALLOC_NORMAL;
@@ -56,11 +54,10 @@ int import_pool_vg(struct volume_group *vg, struct pool *mem, struct list *pls)
 	return 1;
 }
 
-int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
+int import_pool_lvs(struct volume_group *vg, struct dm_pool *mem, struct list *pls)
 {
 	struct pool_list *pl;
-	struct list *plhs;
-	struct lv_list *lvl = pool_zalloc(mem, sizeof(*lvl));
+	struct lv_list *lvl = dm_pool_zalloc(mem, sizeof(*lvl));
 	struct logical_volume *lv;
 
 	if (!lvl) {
@@ -68,7 +65,7 @@ int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
 		return 0;
 	}
 
-	if (!(lvl->lv = pool_zalloc(mem, sizeof(*lvl->lv)))) {
+	if (!(lvl->lv = dm_pool_zalloc(mem, sizeof(*lvl->lv)))) {
 		log_error("Unable to allocate logical volume structure");
 		return 0;
 	}
@@ -81,18 +78,18 @@ int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
 	lv->name = NULL;
 	lv->le_count = 0;
 	lv->read_ahead = 0;
+	lv->snapshot = NULL;
+	list_init(&lv->snapshot_segs);
 	list_init(&lv->segments);
 	list_init(&lv->tags);
 
-	list_iterate(plhs, pls) {
-		pl = list_item(plhs, struct pool_list);
-
+	list_iterate_items(pl, pls) {
 		lv->size += pl->pd.pl_blocks;
 
 		if (lv->name)
 			continue;
 
-		if (!(lv->name = pool_strdup(mem, pl->pd.pl_pool_name))) {
+		if (!(lv->name = dm_pool_strdup(mem, pl->pd.pl_pool_name))) {
 			stack;
 			return 0;
 		}
@@ -107,10 +104,12 @@ int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
 		/* for pool a minor of 0 is dynamic */
 		if (pl->pd.pl_minor) {
 			lv->status |= FIXED_MINOR;
-			lv->minor = pl->pd.pl_minor;
+			lv->minor = pl->pd.pl_minor + MINOR_OFFSET;
 		} else {
 			lv->minor = -1;
 		}
+		lv->snapshot = NULL;
+		list_init(&lv->snapshot_segs);
 		list_init(&lv->segments);
 		list_init(&lv->tags);
 	}
@@ -124,20 +123,17 @@ int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
 }
 
 int import_pool_pvs(const struct format_type *fmt, struct volume_group *vg,
-		    struct list *pvs, struct pool *mem, struct list *pls)
+		    struct list *pvs, struct dm_pool *mem, struct list *pls)
 {
 	struct pv_list *pvl;
 	struct pool_list *pl;
-	struct list *plhs;
 
-	list_iterate(plhs, pls) {
-		pl = list_item(plhs, struct pool_list);
-
-		if (!(pvl = pool_zalloc(mem, sizeof(*pvl)))) {
+	list_iterate_items(pl, pls) {
+		if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl)))) {
 			log_error("Unable to allocate pv list structure");
 			return 0;
 		}
-		if (!(pvl->pv = pool_zalloc(mem, sizeof(*pvl->pv)))) {
+		if (!(pvl->pv = dm_pool_zalloc(mem, sizeof(*pvl->pv)))) {
 			log_error("Unable to allocate pv structure");
 			return 0;
 		}
@@ -153,7 +149,7 @@ int import_pool_pvs(const struct format_type *fmt, struct volume_group *vg,
 	return 1;
 }
 
-int import_pool_pv(const struct format_type *fmt, struct pool *mem,
+int import_pool_pv(const struct format_type *fmt, struct dm_pool *mem,
 		   struct volume_group *vg, struct physical_volume *pv,
 		   struct pool_list *pl)
 {
@@ -165,7 +161,7 @@ int import_pool_pv(const struct format_type *fmt, struct pool *mem,
 	pv->fmt = fmt;
 
 	pv->dev = pl->dev;
-	if (!(pv->vg_name = pool_strdup(mem, pd->pl_pool_name))) {
+	if (!(pv->vg_name = dm_pool_strdup(mem, pd->pl_pool_name))) {
 		log_error("Unable to duplicate vg_name string");
 		return 0;
 	}
@@ -174,9 +170,15 @@ int import_pool_pv(const struct format_type *fmt, struct pool *mem,
 	pv->pe_size = POOL_PE_SIZE;
 	pv->pe_start = POOL_PE_START;
 	pv->pe_count = pv->size / POOL_PE_SIZE;
-	pv->pe_alloc_count = pv->pe_count;
+	pv->pe_alloc_count = 0;
 
 	list_init(&pv->tags);
+	list_init(&pv->segments);
+
+	if (!alloc_pv_segment_whole_pv(mem, pv)) {
+		stack;
+		return 0;
+	}
 
 	return 1;
 }
@@ -194,101 +196,107 @@ static const char *_cvt_sptype(uint32_t sptype)
 	return sptype_names[i].name;
 }
 
-static int _add_stripe_seg(struct pool *mem,
+static int _add_stripe_seg(struct dm_pool *mem,
 			   struct user_subpool *usp, struct logical_volume *lv,
 			   uint32_t *le_cur)
 {
 	struct lv_segment *seg;
+	struct segment_type *segtype;
 	int j;
+	uint32_t area_len;
 
-	if (!(seg = alloc_lv_segment(mem, usp->num_devs))) {
-		log_error("Unable to allocate striped lv_segment structure");
-		return 0;
-	}
-	if(usp->striping & (usp->striping - 1)) {
+	if (usp->striping & (usp->striping - 1)) {
 		log_error("Stripe size must be a power of 2");
 		return 0;
 	}
-	seg->stripe_size = usp->striping;
-	seg->status |= 0;
-	seg->le += *le_cur;
+
+	area_len = (usp->devs[0].blocks) / POOL_PE_SIZE;
+
+	if (!(segtype = get_segtype_from_string(lv->vg->cmd,
+						     "striped"))) {
+		stack;
+		return 0;
+	}
+
+	if (!(seg = alloc_lv_segment(mem, segtype, lv, *le_cur, 
+				     area_len * usp->num_devs, 0,
+				     usp->striping, NULL, usp->num_devs,
+				     area_len, 0, 0, 0))) {
+		log_error("Unable to allocate striped lv_segment structure");
+		return 0;
+	}
+
+	for (j = 0; j < usp->num_devs; j++)
+		if (!set_lv_segment_area_pv(seg, j, usp->devs[j].pv, 0)) {
+			stack;
+			return 0;
+		}
 
 	/* add the subpool type to the segment tag list */
 	str_list_add(mem, &seg->tags, _cvt_sptype(usp->type));
 
-	for (j = 0; j < usp->num_devs; j++) {
-		if (!(seg->segtype = get_segtype_from_string(lv->vg->cmd,
-							     "striped"))) {
-			stack;
-			return 0;
-		}
-
-		seg->area_len = (usp->devs[j].blocks) / POOL_PE_SIZE;
-		seg->len += seg->area_len;
-		*le_cur += seg->area_len;
-		seg->lv = lv;
-
-		seg->area[j].type = AREA_PV;
-		seg->area[j].u.pv.pv = usp->devs[j].pv;
-		seg->area[j].u.pv.pe = 0;
-	}
 	list_add(&lv->segments, &seg->list);
+
+	*le_cur += seg->len;
+
 	return 1;
 }
 
-static int _add_linear_seg(struct pool *mem,
+static int _add_linear_seg(struct dm_pool *mem,
 			   struct user_subpool *usp, struct logical_volume *lv,
 			   uint32_t *le_cur)
 {
 	struct lv_segment *seg;
+	struct segment_type *segtype;
 	int j;
+	uint32_t area_len;
+
+	if (!(segtype = get_segtype_from_string(lv->vg->cmd, "striped"))) {
+		stack;
+		return 0;
+	}
 
 	for (j = 0; j < usp->num_devs; j++) {
-		/* linear segments only have 1 data area */
-		if (!(seg = alloc_lv_segment(mem, 1))) {
+		area_len = (usp->devs[j].blocks) / POOL_PE_SIZE;
+
+		if (!(seg = alloc_lv_segment(mem, segtype, lv, *le_cur,
+					     area_len, 0, usp->striping,
+					     NULL, 1, area_len,
+					     POOL_PE_SIZE, 0, 0))) {
 			log_error("Unable to allocate linear lv_segment "
 				  "structure");
 			return 0;
 		}
-		seg->stripe_size = usp->striping;
-		seg->le += *le_cur;
-		seg->chunk_size = POOL_PE_SIZE;
-		seg->status |= 0;
-		if (!(seg->segtype = get_segtype_from_string(lv->vg->cmd,
-							     "striped"))) {
-			stack;
-			return 0;
-		}
+
 		/* add the subpool type to the segment tag list */
 		str_list_add(mem, &seg->tags, _cvt_sptype(usp->type));
 
-		seg->lv = lv;
-
-		seg->area_len = (usp->devs[j].blocks) / POOL_PE_SIZE;
-		seg->len = seg->area_len;
-		*le_cur += seg->len;
-		seg->area[0].type = AREA_PV;
-		seg->area[0].u.pv.pv = usp->devs[j].pv;
-		seg->area[0].u.pv.pe = 0;
+		if (!set_lv_segment_area_pv(seg, 0, usp->devs[j].pv, 0)) {
+			stack;
+			return 0;
+		}
 		list_add(&lv->segments, &seg->list);
+
+		*le_cur += seg->len;
 	}
+
 	return 1;
 }
 
-int import_pool_segments(struct list *lvs, struct pool *mem,
+int import_pool_segments(struct list *lvs, struct dm_pool *mem,
 			 struct user_subpool *usp, int subpools)
 {
-
-	struct list *lvhs;
 	struct lv_list *lvl;
 	struct logical_volume *lv;
 	uint32_t le_cur = 0;
 	int i;
 
-	list_iterate(lvhs, lvs) {
-		lvl = list_item(lvhs, struct lv_list);
-
+	list_iterate_items(lvl, lvs) {
 		lv = lvl->lv;
+
+		if (lv->status & SNAPSHOT)
+			continue;
+
 		for (i = 0; i < subpools; i++) {
 			if (usp[i].striping) {
 				if (!_add_stripe_seg(mem, &usp[i], lv, &le_cur)) {
@@ -305,5 +313,4 @@ int import_pool_segments(struct list *lvs, struct pool *mem,
 	}
 
 	return 1;
-
 }

lib/format_pool/pool_label.c

@@ -14,7 +14,6 @@
  */
 
 #include "lib.h"
-#include "pool.h"
 #include "label.h"
 #include "metadata.h"
 #include "xlate.h"
@@ -79,7 +78,7 @@ static void _destroy_label(struct labeller *l, struct label *label)
 
 static void _destroy(struct labeller *l)
 {
-	dbg_free(l);
+	dm_free(l);
 }
 
 struct label_ops _pool_ops = {
@@ -96,7 +95,7 @@ struct labeller *pool_labeller_create(struct format_type *fmt)
 {
 	struct labeller *l;
 
-	if (!(l = dbg_malloc(sizeof(*l)))) {
+	if (!(l = dm_malloc(sizeof(*l)))) {
 		log_error("Couldn't allocate labeller object.");
 		return NULL;
 	}

lib/format_pool/sptype_names.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-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 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
+ */
+
+#ifndef SPTYPE_NAMES_H
+#define SPTYPE_NAMES_H
+
+/* This must be kept up to date with sistina/pool/module/pool_sptypes.h */
+
+/*  Generic Labels  */
+#define SPTYPE_DATA                (0x00000000)
+
+/*  GFS specific labels  */
+#define SPTYPE_GFS_DATA            (0x68011670)
+#define SPTYPE_GFS_JOURNAL         (0x69011670)
+
+struct sptype_name {
+	const char *name;
+	uint32_t label;
+};
+
+static const struct sptype_name sptype_names[] = {
+	{"data",	SPTYPE_DATA},
+
+	{"gfs_data",	SPTYPE_GFS_DATA},
+	{"gfs_journal",	SPTYPE_GFS_JOURNAL},
+
+	{"", 0x0}		/*  This must be the last flag.  */
+};
+
+#endif

lib/format_text/archive.c

@@ -16,9 +16,7 @@
 #include "lib.h"
 #include "format-text.h"
 
-#include "pool.h"
 #include "config.h"
-#include "hash.h"
 #include "import-export.h"
 #include "lvm-string.h"
 #include "lvm-file.h"
@@ -53,7 +51,7 @@ struct archive_file {
 	struct list list;
 
 	char *path;
-	int index;
+	uint32_t index;
 };
 
 /*
@@ -91,7 +89,6 @@ static int _split_vg(const char *filename, char *vgname, size_t vg_size,
 
 static void _insert_file(struct list *head, struct archive_file *b)
 {
-	struct list *bh;
 	struct archive_file *bf = NULL;
 
 	if (list_empty(head)) {
@@ -99,11 +96,9 @@ static void _insert_file(struct list *head, struct archive_file *b)
 		return;
 	}
 
-	/* index increases through list */
-	list_iterate(bh, head) {
-		bf = list_item(bh, struct archive_file);
-
-		if (bf->index > b->index) {
+	/* index reduces through list */
+	list_iterate_items(bf, head) {
+		if (b->index > bf->index) {
 			list_add(&bf->list, &b->list);
 			return;
 		}
@@ -112,33 +107,34 @@ static void _insert_file(struct list *head, struct archive_file *b)
 	list_add_h(&bf->list, &b->list);
 }
 
-static char *_join(struct pool *mem, const char *dir, const char *name)
+static char *_join(struct dm_pool *mem, const char *dir, const char *name)
 {
-	if (!pool_begin_object(mem, 32) ||
-	    !pool_grow_object(mem, dir, strlen(dir)) ||
-	    !pool_grow_object(mem, "/", 1) ||
-	    !pool_grow_object(mem, name, strlen(name)) ||
-	    !pool_grow_object(mem, "\0", 1)) {
+	if (!dm_pool_begin_object(mem, 32) ||
+	    !dm_pool_grow_object(mem, dir, strlen(dir)) ||
+	    !dm_pool_grow_object(mem, "/", 1) ||
+	    !dm_pool_grow_object(mem, name, strlen(name)) ||
+	    !dm_pool_grow_object(mem, "\0", 1)) {
 		stack;
 		return NULL;
 	}
 
-	return pool_end_object(mem);
+	return dm_pool_end_object(mem);
 }
 
 /*
  * Returns a list of archive_files.
  */
-static struct list *_scan_archive(struct pool *mem,
+static struct list *_scan_archive(struct dm_pool *mem,
 				  const char *vgname, const char *dir)
 {
-	int i, count, ix;
+	int i, count;
+	uint32_t ix;
 	char vgname_found[64], *path;
 	struct dirent **dirent;
 	struct archive_file *af;
 	struct list *results;
 
-	if (!(results = pool_alloc(mem, sizeof(*results)))) {
+	if (!(results = dm_pool_alloc(mem, sizeof(*results)))) {
 		stack;
 		return NULL;
 	}
@@ -147,13 +143,13 @@ static struct list *_scan_archive(struct pool *mem,
 
 	/* Sort fails beyond 5-digit indexes */
 	if ((count = scandir(dir, &dirent, NULL, alphasort)) < 0) {
-		log_err("Couldn't scan archive directory.");
+		log_err("Couldn't scan the archive directory (%s).", dir);
 		return 0;
 	}
 
 	for (i = 0; i < count; i++) {
-		/* ignore dot files */
-		if (dirent[i]->d_name[0] == '.')
+		if (!strcmp(dirent[i]->d_name, ".") ||
+		    !strcmp(dirent[i]->d_name, ".."))
 			continue;
 
 		/* check the name is the correct format */
@@ -173,7 +169,7 @@ static struct list *_scan_archive(struct pool *mem,
 		/*
 		 * Create a new archive_file.
 		 */
-		if (!(af = pool_alloc(mem, sizeof(*af)))) {
+		if (!(af = dm_pool_alloc(mem, sizeof(*af)))) {
 			log_err("Couldn't create new archive file.");
 			results = NULL;
 			goto out;
@@ -199,7 +195,6 @@ static struct list *_scan_archive(struct pool *mem,
 static void _remove_expired(struct list *archives, uint32_t archives_size,
 			    uint32_t retain_days, uint32_t min_archive)
 {
-	struct list *bh;
 	struct archive_file *bf;
 	struct stat sb;
 	time_t retain_time;
@@ -213,9 +208,7 @@ static void _remove_expired(struct list *archives, uint32_t archives_size,
 	retain_time = time(NULL) - (time_t) retain_days *SECS_PER_DAY;
 
 	/* Assume list is ordered oldest first (by index) */
-	list_iterate(bh, archives) {
-		bf = list_item(bh, struct archive_file);
-
+	list_iterate_items(bf, archives) {
 		/* Get the mtime of the file and unlink if too old */
 		if (stat(bf->path, &sb)) {
 			log_sys_error("stat", bf->path);
@@ -240,7 +233,7 @@ int archive_vg(struct volume_group *vg,
 	       uint32_t retain_days, uint32_t min_archive)
 {
 	int i, fd, renamed = 0;
-	unsigned int ix = 0;
+	uint32_t ix = 0;
 	struct archive_file *last;
 	FILE *fp = NULL;
 	char temp_file[PATH_MAX], archive_name[PATH_MAX];
@@ -272,20 +265,20 @@ int archive_vg(struct volume_group *vg,
 	 * Now we want to rename this file to <vg>_index.vg.
 	 */
 	if (!(archives = _scan_archive(vg->cmd->mem, vg->name, dir))) {
-		log_err("Couldn't scan the archive directory (%s).", dir);
+		stack;
 		return 0;
 	}
 
 	if (list_empty(archives))
 		ix = 0;
 	else {
-		last = list_item(archives->p, struct archive_file);
+		last = list_item(list_first(archives), struct archive_file);
 		ix = last->index + 1;
 	}
 
 	for (i = 0; i < 10; i++) {
 		if (lvm_snprintf(archive_name, sizeof(archive_name),
-				 "%s/%s_%05d.vg", dir, vg->name, ix) < 0) {
+				 "%s/%s_%05u.vg", dir, vg->name, ix) < 0) {
 			log_error("Archive file name too long.");
 			return 0;
 		}
@@ -338,30 +331,27 @@ static void _display_archive(struct cmd_context *cmd, struct archive_file *af)
 	log_print("Description:\t%s", desc ? desc : "<No description>");
 	log_print("Backup Time:\t%s", ctime(&when));
 
-	pool_free(cmd->mem, vg);
+	dm_pool_free(cmd->mem, vg);
 	tf->fmt->ops->destroy_instance(tf);
 }
 
 int archive_list(struct cmd_context *cmd, const char *dir, const char *vgname)
 {
-	struct list *archives, *ah;
+	struct list *archives;
 	struct archive_file *af;
 
 	if (!(archives = _scan_archive(cmd->mem, vgname, dir))) {
-		log_err("Couldn't scan the archive directory (%s).", dir);
+		stack;
 		return 0;
 	}
 
 	if (list_empty(archives))
 		log_print("No archives found in %s.", dir);
 
-	list_iterate(ah, archives) {
-		af = list_item(ah, struct archive_file);
-
+	list_iterate_back_items(af, archives)
 		_display_archive(cmd, af);
-	}
 
-	pool_free(cmd->mem, archives);
+	dm_pool_free(cmd->mem, archives);
 
 	return 1;
 }

lib/format_text/archiver.c

@@ -13,61 +13,72 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "tools.h"
+#include "lib.h"
+#include "archiver.h"
+#include "format-text.h"
+#include "lvm-file.h"
+#include "lvm-string.h"
+#include "lvmcache.h"
+#include "toolcontext.h"
 
-static struct {
+#include <unistd.h>
+
+struct archive_params {
 	int enabled;
 	char *dir;
 	unsigned int keep_days;
 	unsigned int keep_number;
+};
 
-} _archive_params;
-
-static struct {
+struct backup_params {
 	int enabled;
 	char *dir;
+};
 
-} _backup_params;
-
-int archive_init(const char *dir, unsigned int keep_days, unsigned int keep_min)
+int archive_init(struct cmd_context *cmd, const char *dir,
+		 unsigned int keep_days, unsigned int keep_min)
 {
-	_archive_params.dir = NULL;
+	if (!(cmd->archive_params = dm_pool_zalloc(cmd->libmem,
+						sizeof(*cmd->archive_params)))) {
+		log_error("archive_params alloc failed");
+		return 0;
+	}
+
+	cmd->archive_params->dir = NULL;
 
 	if (!*dir)
 		return 1;
 
-	if (!create_dir(dir))
-		return 0;
-
-	if (!(_archive_params.dir = dbg_strdup(dir))) {
+	if (!(cmd->archive_params->dir = dm_strdup(dir))) {
 		log_error("Couldn't copy archive directory name.");
 		return 0;
 	}
 
-	_archive_params.keep_days = keep_days;
-	_archive_params.keep_number = keep_min;
-	_archive_params.enabled = 1;
+	cmd->archive_params->keep_days = keep_days;
+	cmd->archive_params->keep_number = keep_min;
+	cmd->archive_params->enabled = 1;
+
 	return 1;
 }
 
-void archive_exit(void)
+void archive_exit(struct cmd_context *cmd)
 {
-	if (_archive_params.dir)
-		dbg_free(_archive_params.dir);
-	memset(&_archive_params, 0, sizeof(_archive_params));
+	if (cmd->archive_params->dir)
+		dm_free(cmd->archive_params->dir);
+	memset(cmd->archive_params, 0, sizeof(*cmd->archive_params));
 }
 
-void archive_enable(int flag)
+void archive_enable(struct cmd_context *cmd, int flag)
 {
-	_archive_params.enabled = flag;
+	cmd->archive_params->enabled = flag;
 }
 
-static char *_build_desc(struct pool *mem, const char *line, int before)
+static char *_build_desc(struct dm_pool *mem, const char *line, int before)
 {
 	size_t len = strlen(line) + 32;
 	char *buffer;
 
-	if (!(buffer = pool_zalloc(mem, strlen(line) + 32))) {
+	if (!(buffer = dm_pool_zalloc(mem, strlen(line) + 32))) {
 		stack;
 		return NULL;
 	}
@@ -91,14 +102,14 @@ static int __archive(struct volume_group *vg)
 		return 0;
 	}
 
-	return archive_vg(vg, _archive_params.dir, desc,
-			  _archive_params.keep_days,
-			  _archive_params.keep_number);
+	return archive_vg(vg, vg->cmd->archive_params->dir, desc,
+			  vg->cmd->archive_params->keep_days,
+			  vg->cmd->archive_params->keep_number);
 }
 
 int archive(struct volume_group *vg)
 {
-	if (!_archive_params.enabled || !_archive_params.dir)
+	if (!vg->cmd->archive_params->enabled || !vg->cmd->archive_params->dir)
 		return 1;
 
 	if (test_mode()) {
@@ -106,7 +117,16 @@ int archive(struct volume_group *vg)
 		return 1;
 	}
 
-	log_verbose("Archiving volume group \"%s\" metadata.", vg->name);
+	if (!create_dir(vg->cmd->archive_params->dir))
+		return 0;
+
+	/* Trap a read-only file system */
+        if ((access(vg->cmd->archive_params->dir, R_OK | W_OK | X_OK) == -1) &&
+	     (errno == EROFS))
+                return 0;
+
+	log_verbose("Archiving volume group \"%s\" metadata (seqno %u).", vg->name,
+		    vg->seqno);
 	if (!__archive(vg)) {
 		log_error("Volume group \"%s\" metadata archive failed.",
 			  vg->name);
@@ -121,23 +141,26 @@ int archive_display(struct cmd_context *cmd, const char *vg_name)
 	int r1, r2;
 
 	init_partial(1);
-	r1 = archive_list(cmd, _archive_params.dir, vg_name);
-	r2 = backup_list(cmd, _backup_params.dir, vg_name);
+	r1 = archive_list(cmd, cmd->archive_params->dir, vg_name);
+	r2 = backup_list(cmd, cmd->backup_params->dir, vg_name);
 	init_partial(0);
 
 	return r1 && r2;
 }
 
-int backup_init(const char *dir)
+int backup_init(struct cmd_context *cmd, const char *dir)
 {
-	_backup_params.dir = NULL;
+	if (!(cmd->backup_params = dm_pool_zalloc(cmd->libmem,
+					       sizeof(*cmd->archive_params)))) {
+		log_error("archive_params alloc failed");
+		return 0;
+	}
+
+	cmd->backup_params->dir = NULL;
 	if (!*dir)
 		return 1;
 
-	if (!create_dir(dir))
-		return 0;
-
-	if (!(_backup_params.dir = dbg_strdup(dir))) {
+	if (!(cmd->backup_params->dir = dm_strdup(dir))) {
 		log_error("Couldn't copy backup directory name.");
 		return 0;
 	}
@@ -145,16 +168,16 @@ int backup_init(const char *dir)
 	return 1;
 }
 
-void backup_exit(void)
+void backup_exit(struct cmd_context *cmd)
 {
-	if (_backup_params.dir)
-		dbg_free(_backup_params.dir);
-	memset(&_backup_params, 0, sizeof(_backup_params));
+	if (cmd->backup_params->dir)
+		dm_free(cmd->backup_params->dir);
+	memset(cmd->backup_params, 0, sizeof(*cmd->backup_params));
 }
 
-void backup_enable(int flag)
+void backup_enable(struct cmd_context *cmd, int flag)
 {
-	_backup_params.enabled = flag;
+	cmd->backup_params->enabled = flag;
 }
 
 static int __backup(struct volume_group *vg)
@@ -168,7 +191,7 @@ static int __backup(struct volume_group *vg)
 	}
 
 	if (lvm_snprintf(name, sizeof(name), "%s/%s",
-			 _backup_params.dir, vg->name) < 0) {
+			 vg->cmd->backup_params->dir, vg->name) < 0) {
 		log_error("Failed to generate volume group metadata backup "
 			  "filename.");
 		return 0;
@@ -179,7 +202,7 @@ static int __backup(struct volume_group *vg)
 
 int backup(struct volume_group *vg)
 {
-	if (!_backup_params.enabled || !_backup_params.dir) {
+	if (!vg->cmd->backup_params->enabled || !vg->cmd->backup_params->dir) {
 		log_print("WARNING: This metadata update is NOT backed up");
 		return 1;
 	}
@@ -189,6 +212,14 @@ int backup(struct volume_group *vg)
 		return 1;
 	}
 
+	if (!create_dir(vg->cmd->backup_params->dir))
+		return 0;
+
+	/* Trap a read-only file system */
+        if ((access(vg->cmd->backup_params->dir, R_OK | W_OK | X_OK) == -1) &&
+	    (errno == EROFS))
+                return 0;
+
 	if (!__backup(vg)) {
 		log_error("Backup of volume group %s metadata failed.",
 			  vg->name);
@@ -198,12 +229,12 @@ int backup(struct volume_group *vg)
 	return 1;
 }
 
-int backup_remove(const char *vg_name)
+int backup_remove(struct cmd_context *cmd, const char *vg_name)
 {
 	char path[PATH_MAX];
 
 	if (lvm_snprintf(path, sizeof(path), "%s/%s",
-			 _backup_params.dir, vg_name) < 0) {
+			 cmd->backup_params->dir, vg_name) < 0) {
 		log_err("Failed to generate backup filename (for removal).");
 		return 0;
 	}
@@ -269,7 +300,7 @@ int backup_restore_vg(struct cmd_context *cmd, struct volume_group *vg)
 			return 0;
 		}
 		if (cmd->fmt != info->fmt) {
-			log_error("PV %s is a different format (%s)",
+			log_error("PV %s is a different format (seqno %s)",
 				  dev_name(pv->dev), info->fmt->name);
 			return 0;
 		}
@@ -312,7 +343,7 @@ int backup_restore(struct cmd_context *cmd, const char *vg_name)
 	char path[PATH_MAX];
 
 	if (lvm_snprintf(path, sizeof(path), "%s/%s",
-			 _backup_params.dir, vg_name) < 0) {
+			 cmd->backup_params->dir, vg_name) < 0) {
 		log_err("Failed to generate backup filename (for restore).");
 		return 0;
 	}
@@ -330,7 +361,7 @@ int backup_to_file(const char *file, const char *desc, struct volume_group *vg)
 
 	cmd = vg->cmd;
 
-	log_verbose("Creating volume group backup \"%s\"", file);
+	log_verbose("Creating volume group backup \"%s\" (seqno %u).", file, vg->seqno);
 
 	if (!(context = create_text_context(cmd, file, desc)) ||
 	    !(tf = cmd->fmt_backup->ops->create_instance(cmd->fmt_backup, NULL,
@@ -354,3 +385,34 @@ int backup_to_file(const char *file, const char *desc, struct volume_group *vg)
 	tf->fmt->ops->destroy_instance(tf);
 	return r;
 }
+
+/*
+ * Update backup (and archive) if they're out-of-date or don't exist.
+ */
+void check_current_backup(struct volume_group *vg)
+{
+	char path[PATH_MAX];
+	struct volume_group *vg_backup;
+
+	if ((vg->status & PARTIAL_VG) || (vg->status & EXPORTED_VG))
+		return;
+
+	if (lvm_snprintf(path, sizeof(path), "%s/%s",
+			 vg->cmd->backup_params->dir, vg->name) < 0) {
+		log_debug("Failed to generate backup filename.");
+		return;
+	}
+
+	log_suppress(1);
+	/* Up-to-date backup exists? */
+	if ((vg_backup = backup_read_vg(vg->cmd, vg->name, path)) &&
+	    (vg->seqno == vg_backup->seqno) &&
+	    (id_equal(&vg->id, &vg_backup->id)))
+		return;
+	log_suppress(0);
+
+	if (vg_backup)
+		archive(vg_backup);
+	archive(vg);
+	backup(vg);
+}

lib/format_text/archiver.h

@@ -18,11 +18,6 @@
 
 #include "metadata.h"
 
-/*
- * FIXME: This file is going to merge with the archiving code in
- * lib/format_text at some point.
- */
-
 /*
  * There are two operations that come under the general area of
  * backups.  'Archiving' occurs just before a volume group
@@ -36,20 +31,20 @@
  * Typically backups will be stored in /etc/lvm/backups.
  */
 
-int archive_init(const char *dir,
+int archive_init(struct cmd_context *cmd, const char *dir,
 		 unsigned int keep_days, unsigned int keep_min);
-void archive_exit(void);
+void archive_exit(struct cmd_context *cmd);
 
-void archive_enable(int flag);
+void archive_enable(struct cmd_context *cmd, int flag);
 int archive(struct volume_group *vg);
 int archive_display(struct cmd_context *cmd, const char *vg_name);
 
-int backup_init(const char *dir);
-void backup_exit(void);
+int backup_init(struct cmd_context *cmd, const char *dir);
+void backup_exit(struct cmd_context *cmd);
 
-void backup_enable(int flag);
+void backup_enable(struct cmd_context *cmd, int flag);
 int backup(struct volume_group *vg);
-int backup_remove(const char *vg_name);
+int backup_remove(struct cmd_context *cmd, const char *vg_name);
 
 struct volume_group *backup_read_vg(struct cmd_context *cmd,
 				    const char *vg_name, const char *file);
@@ -60,4 +55,6 @@ int backup_restore(struct cmd_context *cmd, const char *vg_name);
 
 int backup_to_file(const char *file, const char *desc, struct volume_group *vg);
 
+void check_current_backup(struct volume_group *vg);
+
 #endif

lib/format_text/export.c

@@ -16,8 +16,6 @@
 #include "lib.h"
 #include "import-export.h"
 #include "metadata.h"
-#include "hash.h"
-#include "pool.h"
 #include "display.h"
 #include "lvm-string.h"
 #include "segtype.h"
@@ -30,19 +28,32 @@
 struct formatter;
 typedef int (*out_with_comment_fn) (struct formatter * f, const char *comment,
 				    const char *fmt, va_list ap);
-typedef void (*nl_fn) (struct formatter * f);
+typedef int (*nl_fn) (struct formatter * f);
+
+/*
+ * Macro for formatted output.
+ * out_with_comment_fn returns -1 if data didn't fit and buffer was expanded.
+ * Then argument list is reset and out_with_comment_fn is called again.
+ */
+#define _out_with_comment(f, buffer, fmt, ap) \
+        do { \
+		va_start(ap, fmt); \
+		r = f->out_with_comment(f, buffer, fmt, ap); \
+		va_end(ap); \
+	} while (r == -1)
+
 /*
  * The first half of this file deals with
  * exporting the vg, ie. writing it to a file.
  */
 struct formatter {
-	struct pool *mem;	/* pv names allocated from here */
-	struct hash_table *pv_names;	/* dev_name -> pv_name (eg, pv1) */
+	struct dm_pool *mem;	/* pv names allocated from here */
+	struct dm_hash_table *pv_names;	/* dev_name -> pv_name (eg, pv1) */
 
 	union {
 		FILE *fp;	/* where we're writing to */
 		struct {
-			char *buf;
+			char *start;
 			uint32_t size;
 			uint32_t used;
 		} buf;
@@ -95,22 +106,45 @@ static void _dec_indent(struct formatter *f)
 /*
  * Newline function for prettier layout.
  */
-static void _nl_file(struct formatter *f)
+static int _nl_file(struct formatter *f)
 {
 	fprintf(f->data.fp, "\n");
+
+	return 1;
 }
 
-static void _nl_raw(struct formatter *f)
+static int _extend_buffer(struct formatter *f)
 {
-	if (f->data.buf.used >= f->data.buf.size - 1)
-		return;
+	char *newbuf;
 
-	*f->data.buf.buf = '\n';
-	f->data.buf.buf += 1;
+	log_debug("Doubling metadata output buffer to %" PRIu32,
+		  f->data.buf.size * 2);
+	if (!(newbuf = dm_realloc(f->data.buf.start,
+				   f->data.buf.size * 2))) {
+		log_error("Buffer reallocation failed.");
+		return 0;
+	}
+	f->data.buf.start = newbuf;
+	f->data.buf.size *= 2;
+
+	return 1;
+}
+
+static int _nl_raw(struct formatter *f)
+{
+	/* If metadata doesn't fit, extend buffer */
+	if ((f->data.buf.used + 2 > f->data.buf.size) &&
+	    (!_extend_buffer(f))) {
+		stack;
+		return 0;
+	}
+
+	*(f->data.buf.start + f->data.buf.used) = '\n';
 	f->data.buf.used += 1;
-	*f->data.buf.buf = '\0';
 
-	return;
+	*(f->data.buf.start + f->data.buf.used) = '\0';
+
+	return 1;
 }
 
 #define COMMENT_TAB 6
@@ -154,16 +188,21 @@ static int _out_with_comment_raw(struct formatter *f, const char *comment,
 {
 	int n;
 
-	n = vsnprintf(f->data.buf.buf, f->data.buf.size - f->data.buf.used,
-		      fmt, ap);
+	n = vsnprintf(f->data.buf.start + f->data.buf.used,
+		      f->data.buf.size - f->data.buf.used, fmt, ap);
 
-	if (n < 0 || (n > f->data.buf.size - f->data.buf.used - 1))
-		return 0;
+	/* If metadata doesn't fit, extend buffer */
+	if (n < 0 || (n + f->data.buf.used + 2 > f->data.buf.size)) {
+		if (!_extend_buffer(f)) {
+			stack;
+			return 0;
+		}
+		return -1; /* Retry */
+	}
 
-	f->data.buf.buf += n;
 	f->data.buf.used += n;
 
-	f->nl(f);
+	outnl(f);
 
 	return 1;
 }
@@ -209,9 +248,7 @@ int out_size(struct formatter *f, uint64_t size, const char *fmt, ...)
 	if (!_sectors_to_units(size, buffer, sizeof(buffer)))
 		return 0;
 
-	va_start(ap, fmt);
-	r = f->out_with_comment(f, buffer, fmt, ap);
-	va_end(ap);
+	_out_with_comment(f, buffer, fmt, ap);
 
 	return r;
 }
@@ -225,9 +262,7 @@ int out_hint(struct formatter *f, const char *fmt, ...)
 	va_list ap;
 	int r;
 
-	va_start(ap, fmt);
-	r = f->out_with_comment(f, "# Hint only", fmt, ap);
-	va_end(ap);
+	_out_with_comment(f, "# Hint only", fmt, ap);
 
 	return r;
 }
@@ -240,9 +275,7 @@ int out_text(struct formatter *f, const char *fmt, ...)
 	va_list ap;
 	int r;
 
-	va_start(ap, fmt);
-	r = f->out_with_comment(f, NULL, fmt, ap);
-	va_end(ap);
+	_out_with_comment(f, NULL, fmt, ap);
 
 	return r;
 }
@@ -257,10 +290,10 @@ static int _print_header(struct formatter *f,
 	outf(f, "# Generated by LVM2: %s", ctime(&t));
 	outf(f, CONTENTS_FIELD " = \"" CONTENTS_VALUE "\"");
 	outf(f, FORMAT_VERSION_FIELD " = %d", FORMAT_VERSION_VALUE);
-	f->nl(f);
+	outnl(f);
 
 	outf(f, "description = \"%s\"", desc);
-	f->nl(f);
+	outnl(f);
 	outf(f, "creation_host = \"%s\"\t# %s %s %s %s %s", _utsname.nodename,
 	     _utsname.sysname, _utsname.nodename, _utsname.release,
 	     _utsname.version, _utsname.machine);
@@ -309,7 +342,7 @@ static int _print_vg(struct formatter *f, struct volume_group *vg)
 
 	/* Default policy is NORMAL; INHERIT is meaningless */
 	if (vg->alloc != ALLOC_NORMAL && vg->alloc != ALLOC_INHERIT) {
-		f->nl(f);
+		outnl(f);
 		outf(f, "allocation_policy = \"%s\"",
 		     get_alloc_string(vg->alloc));
 	}
@@ -325,12 +358,12 @@ static inline const char *_get_pv_name(struct formatter *f,
 				       struct physical_volume *pv)
 {
 	return (pv) ? (const char *)
-	    hash_lookup(f->pv_names, dev_name(pv->dev)) : "Missing";
+	    dm_hash_lookup(f->pv_names, dev_name(pv->dev)) : "Missing";
 }
 
 static int _print_pvs(struct formatter *f, struct volume_group *vg)
 {
-	struct list *pvh;
+	struct pv_list *pvl;
 	struct physical_volume *pv;
 	char buffer[4096];
 	const char *name;
@@ -338,15 +371,15 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 	outf(f, "physical_volumes {");
 	_inc_indent(f);
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
+	list_iterate_items(pvl, &vg->pvs) {
+		pv = pvl->pv;
 
 		if (!(name = _get_pv_name(f, pv))) {
 			stack;
 			return 0;
 		}
 
-		f->nl(f);
+		outnl(f);
 		outf(f, "%s {", name);
 		_inc_indent(f);
 
@@ -360,7 +393,7 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 			stack;
 			return 0;
 		}
-		f->nl(f);
+		outnl(f);
 
 		if (!print_flags(pv->status, PV_FLAGS, buffer, sizeof(buffer))) {
 			stack;
@@ -407,7 +440,7 @@ static int _print_segment(struct formatter *f, struct volume_group *vg,
 		return 0;
 	}
 
-	f->nl(f);
+	outnl(f);
 	outf(f, "type = \"%s\"", seg->segtype->name);
 
 	if (!list_empty(&seg->tags)) {
@@ -436,28 +469,31 @@ int out_areas(struct formatter *f, const struct lv_segment *seg,
 	const char *name;
 	unsigned int s;
 
-	f->nl(f);
+	outnl(f);
 
 	outf(f, "%ss = [", type);
 	_inc_indent(f);
 
 	for (s = 0; s < seg->area_count; s++) {
-		switch (seg->area[s].type) {
+		switch (seg_type(seg, s)) {
 		case AREA_PV:
-			if (!(name = _get_pv_name(f, seg->area[s].u.pv.pv))) {
+			if (!(name = _get_pv_name(f, seg_pv(seg, s)))) {
 				stack;
 				return 0;
 			}
 
 			outf(f, "\"%s\", %u%s", name,
-			     seg->area[s].u.pv.pe,
+			     seg_pe(seg, s),
 			     (s == seg->area_count - 1) ? "" : ",");
 			break;
 		case AREA_LV:
 			outf(f, "\"%s\", %u%s",
-			     seg->area[s].u.lv.lv->name,
-			     seg->area[s].u.lv.le,
+			     seg_lv(seg, s)->name,
+			     seg_le(seg, s),
 			     (s == seg->area_count - 1) ? "" : ",");
+			break;
+		case AREA_UNASSIGNED:
+			return 0;
 		}
 	}
 
@@ -466,72 +502,57 @@ int out_areas(struct formatter *f, const struct lv_segment *seg,
 	return 1;
 }
 
-static int _count_segments(struct logical_volume *lv)
+static int _print_lv(struct formatter *f, struct logical_volume *lv)
 {
-	int r = 0;
-	struct list *segh;
+	struct lv_segment *seg;
+	char buffer[4096];
+	int seg_count;
 
-	list_iterate(segh, &lv->segments)
-	    r++;
-
-	return r;
-}
-
-static int _print_snapshot(struct formatter *f, struct snapshot *snap,
-			   unsigned int count)
-{
-	char buffer[256];
-	struct lv_segment seg;
-
-	f->nl(f);
-
-	outf(f, "snapshot%u {", count);
+	outnl(f);
+	outf(f, "%s {", lv->name);
 	_inc_indent(f);
 
-	if (!id_write_format(&snap->id, buffer, sizeof(buffer))) {
+	/* FIXME: Write full lvid */
+	if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {
 		stack;
 		return 0;
 	}
 
 	outf(f, "id = \"%s\"", buffer);
 
-	seg.status = LVM_READ | LVM_WRITE | VISIBLE_LV;
-	if (!print_flags(seg.status, LV_FLAGS, buffer, sizeof(buffer))) {
+	if (!print_flags(lv->status, LV_FLAGS, buffer, sizeof(buffer))) {
 		stack;
 		return 0;
 	}
-
 	outf(f, "status = %s", buffer);
-	outf(f, "segment_count = 1");
 
-	f->nl(f);
-
-	if (!(seg.segtype = get_segtype_from_string(snap->origin->vg->cmd,
-						    "snapshot"))) {
-		stack;
-		return 0;
+	if (!list_empty(&lv->tags)) {
+		if (!print_tags(&lv->tags, buffer, sizeof(buffer))) {
+			stack;
+			return 0;
+		}
+		outf(f, "tags = %s", buffer);
 	}
 
-	seg.le = 0;
-	seg.len = snap->origin->le_count;
-	seg.origin = snap->origin;
-	seg.cow = snap->cow;
-	seg.chunk_size = snap->chunk_size;
+	if (lv->alloc != ALLOC_INHERIT)
+		outf(f, "allocation_policy = \"%s\"",
+		     get_alloc_string(lv->alloc));
 
-	/* FIXME Dummy values */
-	list_init(&seg.list);
-	seg.lv = snap->cow;
-	seg.stripe_size = 0;
-	seg.area_count = 0;
-	seg.area_len = 0;
-	seg.extents_copied = 0;
+	if (lv->read_ahead)
+		outf(f, "read_ahead = %u", lv->read_ahead);
+	if (lv->major >= 0)
+		outf(f, "major = %d", lv->major);
+	if (lv->minor >= 0)
+		outf(f, "minor = %d", lv->minor);
+	outf(f, "segment_count = %u", list_size(&lv->segments));
+	outnl(f);
 
-	/* Can't tag a snapshot independently of its origin */
-	list_init(&seg.tags);
-
-	if (!_print_segment(f, snap->origin->vg, 1, &seg)) {
-		stack;
-		return 0;
+	seg_count = 1;
+	list_iterate_items(seg, &lv->segments) {
+		if (!_print_segment(f, lv->vg, seg_count++, seg)) {
+			stack;
+			return 0;
+		}
 	}
 
 	_dec_indent(f);
@@ -540,31 +561,9 @@ static int _print_snapshot(struct formatter *f, struct snapshot *snap,
 	return 1;
 }
 
-static int _print_snapshots(struct formatter *f, struct volume_group *vg)
-{
-	struct list *sh;
-	struct snapshot *s;
-	unsigned int count = 0;
-
-	list_iterate(sh, &vg->snapshots) {
-		s = list_item(sh, struct snapshot_list)->snapshot;
-
-		if (!_print_snapshot(f, s, count++)) {
-			stack;
-			return 0;
-		}
-	}
-
-	return 1;
-}
-
 static int _print_lvs(struct formatter *f, struct volume_group *vg)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
-	struct lv_segment *seg;
-	char buffer[4096];
-	int seg_count;
+	struct lv_list *lvl;
 
 	/*
 	 * Don't bother with an lv section if there are no lvs.
@@ -575,63 +574,25 @@ static int _print_lvs(struct formatter *f, struct volume_group *vg)
 	outf(f, "logical_volumes {");
 	_inc_indent(f);
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-
-		f->nl(f);
-		outf(f, "%s {", lv->name);
-		_inc_indent(f);
-
-		/* FIXME: Write full lvid */
-		if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {
+	/*
+	 * Write visible LVs first
+	 */
+	list_iterate_items(lvl, &vg->lvs) {
+		if (!(lvl->lv->status & VISIBLE_LV))
+			continue;
+		if (!_print_lv(f, lvl->lv)) {
 			stack;
 			return 0;
 		}
-
-		outf(f, "id = \"%s\"", buffer);
-
-		if (!print_flags(lv->status, LV_FLAGS, buffer, sizeof(buffer))) {
-			stack;
-			return 0;
-		}
-		outf(f, "status = %s", buffer);
-
-		if (!list_empty(&lv->tags)) {
-			if (!print_tags(&lv->tags, buffer, sizeof(buffer))) {
-				stack;
-				return 0;
-			}
-			outf(f, "tags = %s", buffer);
-		}
-
-		if (lv->alloc != ALLOC_INHERIT)
-			outf(f, "allocation_policy = \"%s\"",
-			     get_alloc_string(lv->alloc));
-
-		if (lv->read_ahead)
-			outf(f, "read_ahead = %u", lv->read_ahead);
-		if (lv->major >= 0)
-			outf(f, "major = %d", lv->major);
-		if (lv->minor >= 0)
-			outf(f, "minor = %d", lv->minor);
-		outf(f, "segment_count = %u", _count_segments(lv));
-		f->nl(f);
-
-		seg_count = 1;
-		list_iterate_items(seg, &lv->segments) {
-			if (!_print_segment(f, vg, seg_count++, seg)) {
-				stack;
-				return 0;
-			}
-		}
-
-		_dec_indent(f);
-		outf(f, "}");
 	}
 
-	if (!_print_snapshots(f, vg)) {
-		stack;
-		return 0;
+	list_iterate_items(lvl, &vg->lvs) {
+		if ((lvl->lv->status & VISIBLE_LV))
+			continue;
+		if (!_print_lv(f, lvl->lv)) {
+			stack;
+			return 0;
+		}
 	}
 
 	_dec_indent(f);
@@ -648,22 +609,22 @@ static int _print_lvs(struct formatter *f, struct volume_group *vg)
 static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 {
 	int count = 0;
-	struct list *pvh;
+	struct pv_list *pvl;
 	struct physical_volume *pv;
 	char buffer[32], *name;
 
-	if (!(f->mem = pool_create(512))) {
+	if (!(f->mem = dm_pool_create("text pv_names", 512))) {
 		stack;
 		goto bad;
 	}
 
-	if (!(f->pv_names = hash_create(128))) {
+	if (!(f->pv_names = dm_hash_create(128))) {
 		stack;
 		goto bad;
 	}
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
+	list_iterate_items(pvl, &vg->pvs) {
+		pv = pvl->pv;
 
 		/* FIXME But skip if there's already an LV called pv%d ! */
 		if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0) {
@@ -671,12 +632,12 @@ static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 			goto bad;
 		}
 
-		if (!(name = pool_strdup(f->mem, buffer))) {
+		if (!(name = dm_pool_strdup(f->mem, buffer))) {
 			stack;
 			goto bad;
 		}
 
-		if (!hash_insert(f->pv_names, dev_name(pv->dev), name)) {
+		if (!dm_hash_insert(f->pv_names, dev_name(pv->dev), name)) {
 			stack;
 			goto bad;
 		}
@@ -686,10 +647,10 @@ static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 
       bad:
 	if (f->mem)
-		pool_destroy(f->mem);
+		dm_pool_destroy(f->mem);
 
 	if (f->pv_names)
-		hash_destroy(f->pv_names);
+		dm_hash_destroy(f->pv_names);
 
 	return 0;
 }
@@ -716,11 +677,11 @@ static int _text_vg_export(struct formatter *f,
 	if (!_print_vg(f, vg))
 		fail;
 
-	f->nl(f);
+	outnl(f);
 	if (!_print_pvs(f, vg))
 		fail;
 
-	f->nl(f);
+	outnl(f);
 	if (!_print_lvs(f, vg))
 		fail;
 
@@ -736,10 +697,10 @@ static int _text_vg_export(struct formatter *f,
 
       out:
 	if (f->mem)
-		pool_destroy(f->mem);
+		dm_pool_destroy(f->mem);
 
 	if (f->pv_names)
-		hash_destroy(f->pv_names);
+		dm_hash_destroy(f->pv_names);
 
 	return r;
 }
@@ -751,7 +712,7 @@ int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp)
 
 	_init();
 
-	if (!(f = dbg_malloc(sizeof(*f)))) {
+	if (!(f = dm_malloc(sizeof(*f)))) {
 		stack;
 		return 0;
 	}
@@ -766,27 +727,31 @@ int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp)
 	r = _text_vg_export(f, vg, desc);
 	if (r)
 		r = !ferror(f->data.fp);
-	dbg_free(f);
+	dm_free(f);
 	return r;
 }
 
 /* Returns amount of buffer used incl. terminating NUL */
-int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
-		       uint32_t size)
+int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf)
 {
 	struct formatter *f;
-	int r;
+	int r = 0;
 
 	_init();
 
-	if (!(f = dbg_malloc(sizeof(*f)))) {
+	if (!(f = dm_malloc(sizeof(*f)))) {
 		stack;
 		return 0;
 	}
 
 	memset(f, 0, sizeof(*f));
-	f->data.buf.buf = buf;
-	f->data.buf.size = size;
+
+	f->data.buf.size = 65536;	/* Initial metadata limit */
+	if (!(f->data.buf.start = dm_malloc(f->data.buf.size))) {
+		log_error("text_export buffer allocation failed");
+		goto out;
+	}
+
 	f->indent = 0;
 	f->header = 0;
 	f->out_with_comment = &_out_with_comment_raw;
@@ -794,15 +759,17 @@ int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
 
 	if (!_text_vg_export(f, vg, desc)) {
 		stack;
-		r = 0;
+		dm_free(f->data.buf.start);
 		goto out;
 	}
 
 	r = f->data.buf.used + 1;
+	*buf = f->data.buf.start;
 
       out:
-	dbg_free(f);
+	dm_free(f);
 	return r;
 }
 
 #undef outf
+#undef outnl

lib/format_text/flags.c

@@ -36,6 +36,7 @@ static struct flag _vg_flags[] = {
 	{LVM_WRITE, "WRITE"},
 	{CLUSTERED, "CLUSTERED"},
 	{SHARED, "SHARED"},
+	{PRECOMMITTED, NULL},
 	{0, NULL}
 };
 
@@ -52,8 +53,12 @@ static struct flag _lv_flags[] = {
 	{VISIBLE_LV, "VISIBLE"},
 	{PVMOVE, "PVMOVE"},
 	{LOCKED, "LOCKED"},
+	{MIRROR_IMAGE, NULL},
+	{MIRROR_LOG, NULL},
 	{MIRRORED, NULL},
 	{VIRTUAL, NULL},
+	{SNAPSHOT, NULL},
+	{ACTIVATE_EXCL, NULL},
 	{0, NULL}
 };
 

lib/format_text/format-text.h

@@ -18,7 +18,6 @@
 
 #include "lvm-types.h"
 #include "metadata.h"
-#include "pool.h"
 
 /*
  * Archives a vg config.  'retain_days' is the minimum number of
@@ -47,11 +46,11 @@ struct labeller *text_labeller_create(const struct format_type *fmt);
 
 int pvhdr_read(struct device *dev, char *buf);
 
-int add_da(const struct format_type *fmt, struct pool *mem, struct list *das,
+int add_da(const struct format_type *fmt, struct dm_pool *mem, struct list *das,
 	   uint64_t start, uint64_t size);
 void del_das(struct list *das);
 
-int add_mda(const struct format_type *fmt, struct pool *mem, struct list *mdas,
+int add_mda(const struct format_type *fmt, struct dm_pool *mem, struct list *mdas,
 	    struct device *dev, uint64_t start, uint64_t size);
 void del_mdas(struct list *mdas);
 

lib/format_text/import-export.h

@@ -19,7 +19,6 @@
 #include "config.h"
 #include "lvm-types.h"
 #include "metadata.h"
-#include "pool.h"
 
 #include <stdio.h>
 
@@ -46,7 +45,7 @@ struct text_vg_version_ops {
 	int (*check_version) (struct config_tree * cf);
 	struct volume_group *(*read_vg) (struct format_instance * fid,
 					 struct config_tree * cf);
-	void (*read_desc) (struct pool * mem, struct config_tree * cf,
+	void (*read_desc) (struct dm_pool * mem, struct config_tree * cf,
 			   time_t *when, char **desc);
 };
 
@@ -56,11 +55,10 @@ int print_flags(uint32_t status, int type, char *buffer, size_t size);
 int read_flags(uint32_t *status, int type, struct config_value *cv);
 
 int print_tags(struct list *tags, char *buffer, size_t size);
-int read_tags(struct pool *mem, struct list *tags, struct config_value *cv);
+int read_tags(struct dm_pool *mem, struct list *tags, struct config_value *cv);
 
 int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp);
-int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
-		       uint32_t size);
+int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf);
 struct volume_group *text_vg_import_file(struct format_instance *fid,
 					 const char *file,
 					 time_t *when, char **desc);

lib/format_text/import.c

@@ -16,9 +16,7 @@
 #include "lib.h"
 #include "metadata.h"
 #include "import-export.h"
-#include "pool.h"
 #include "display.h"
-#include "hash.h"
 #include "toolcontext.h"
 #include "lvmcache.h"
 

lib/format_text/import_vsn1.c

@@ -16,22 +16,21 @@
 #include "lib.h"
 #include "metadata.h"
 #include "import-export.h"
-#include "pool.h"
 #include "display.h"
-#include "hash.h"
 #include "toolcontext.h"
 #include "lvmcache.h"
 #include "lv_alloc.h"
+#include "pv_alloc.h"
 #include "segtype.h"
 #include "text_import.h"
 
-typedef int (*section_fn) (struct format_instance * fid, struct pool * mem,
+typedef int (*section_fn) (struct format_instance * fid, struct dm_pool * mem,
 			   struct volume_group * vg, struct config_node * pvn,
 			   struct config_node * vgn,
-			   struct hash_table * pv_hash);
+			   struct dm_hash_table * pv_hash);
 
 #define _read_int32(root, path, result) \
-	get_config_uint32(root, path, result)
+	get_config_uint32(root, path, (uint32_t *) result)
 
 #define _read_uint32(root, path, result) \
 	get_config_uint32(root, path, result)
@@ -110,16 +109,16 @@ static int _read_id(struct id *id, struct config_node *cn, const char *path)
 	return 1;
 }
 
-static int _read_pv(struct format_instance *fid, struct pool *mem,
+static int _read_pv(struct format_instance *fid, struct dm_pool *mem,
 		    struct volume_group *vg, struct config_node *pvn,
-		    struct config_node *vgn, struct hash_table *pv_hash)
+		    struct config_node *vgn, struct dm_hash_table *pv_hash)
 {
 	struct physical_volume *pv;
 	struct pv_list *pvl;
 	struct config_node *cn;
 
-	if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) ||
-	    !(pvl->pv = pool_zalloc(mem, sizeof(*pvl->pv)))) {
+	if (!(pvl = dm_pool_zalloc(mem, sizeof(*pvl))) ||
+	    !(pvl->pv = dm_pool_zalloc(mem, sizeof(*pvl->pv)))) {
 		stack;
 		return 0;
 	}
@@ -130,7 +129,7 @@ static int _read_pv(struct format_instance *fid, struct pool *mem,
 	 * Add the pv to the pv hash for quick lookup when we read
 	 * the lv segments.
 	 */
-	if (!hash_insert(pv_hash, pvn->key, pv)) {
+	if (!dm_hash_insert(pv_hash, pvn->key, pv)) {
 		stack;
 		return 0;
 	}
@@ -163,7 +162,7 @@ static int _read_pv(struct format_instance *fid, struct pool *mem,
 			return 0;
 	}
 
-	if (!(pv->vg_name = pool_strdup(mem, vg->name))) {
+	if (!(pv->vg_name = dm_pool_strdup(mem, vg->name))) {
 		stack;
 		return 0;
 	}
@@ -190,6 +189,7 @@ static int _read_pv(struct format_instance *fid, struct pool *mem,
 	}
 
 	list_init(&pv->tags);
+	list_init(&pv->segments);
 
 	/* Optional tags */
 	if ((cn = find_config_node(pvn, "tags")) &&
@@ -208,6 +208,11 @@ static int _read_pv(struct format_instance *fid, struct pool *mem,
 	pv->pe_alloc_count = 0;
 	pv->fmt = fid->fmt;
 
+	if (!alloc_pv_segment_whole_pv(mem, pv)) {
+		stack;
+		return 0;
+	}
+
 	vg->pv_count++;
 	list_add(&vg->pvs, &pvl->list);
 
@@ -216,12 +221,9 @@ static int _read_pv(struct format_instance *fid, struct pool *mem,
 
 static void _insert_segment(struct logical_volume *lv, struct lv_segment *seg)
 {
-	struct list *segh;
 	struct lv_segment *comp;
 
-	list_iterate(segh, &lv->segments) {
-		comp = list_item(segh, struct lv_segment);
-
+	list_iterate_items(comp, &lv->segments) {
 		if (comp->le > seg->le) {
 			list_add(&comp->list, &seg->list);
 			return;
@@ -232,9 +234,9 @@ static void _insert_segment(struct logical_volume *lv, struct lv_segment *seg)
 	list_add(&lv->segments, &seg->list);
 }
 
-static int _read_segment(struct pool *mem, struct volume_group *vg,
+static int _read_segment(struct dm_pool *mem, struct volume_group *vg,
 			 struct logical_volume *lv, struct config_node *sn,
-			 struct hash_table *pv_hash)
+			 struct dm_hash_table *pv_hash)
 {
 	uint32_t area_count = 0u;
 	struct lv_segment *seg;
@@ -283,19 +285,13 @@ static int _read_segment(struct pool *mem, struct volume_group *vg,
 		return 0;
 	}
 
-	if (!(seg = alloc_lv_segment(mem, area_count))) {
+	if (!(seg = alloc_lv_segment(mem, segtype, lv, start_extent,
+				     extent_count, 0, 0, NULL, area_count,
+				     extent_count, 0, 0, 0))) {
 		log_error("Segment allocation failed");
 		return 0;
 	}
 
-	seg->lv = lv;
-	seg->le = start_extent;
-	seg->len = extent_count;
-	seg->area_len = extent_count;
-	seg->status = 0u;
-	seg->segtype = segtype;
-	seg->extents_copied = 0u;
-
 	if (seg->segtype->ops->text_import &&
 	    !seg->segtype->ops->text_import(seg, sn, pv_hash)) {
 		stack;
@@ -315,17 +311,18 @@ static int _read_segment(struct pool *mem, struct volume_group *vg,
 	 */
 	_insert_segment(lv, seg);
 
-	if (seg->segtype->flags & SEG_AREAS_MIRRORED)
+	if (seg_is_mirrored(seg))
 		lv->status |= MIRRORED;
 
-	if (seg->segtype->flags & SEG_VIRTUAL)
+	if (seg_is_virtual(seg))
 		lv->status |= VIRTUAL;
 
 	return 1;
 }
 
 int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
-		      const struct config_node *cn, struct hash_table *pv_hash)
+		      const struct config_node *cn, struct dm_hash_table *pv_hash,
+		      uint32_t flags)
 {
 	unsigned int s;
 	struct config_value *cv;
@@ -360,20 +357,14 @@ int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
 		}
 
 		/* FIXME Cope if LV not yet read in */
-		if ((pv = hash_lookup(pv_hash, cv->v.str))) {
-			seg->area[s].type = AREA_PV;
-			seg->area[s].u.pv.pv = pv;
-			seg->area[s].u.pv.pe = cv->next->v.i;
-			/*
-			 * Adjust extent counts in the pv and vg.
-			 */
-			pv->pe_alloc_count += seg->area_len;
-			seg->lv->vg->free_count -= seg->area_len;
-
+		if ((pv = dm_hash_lookup(pv_hash, cv->v.str))) {
+			if (!set_lv_segment_area_pv(seg, s, pv, cv->next->v.i)) {
+				stack;
+				return 0;
+			}
 		} else if ((lv1 = find_lv(seg->lv->vg, cv->v.str))) {
-			seg->area[s].type = AREA_LV;
-			seg->area[s].u.lv.lv = lv1;
-			seg->area[s].u.lv.le = cv->next->v.i;
+			set_lv_segment_area_lv(seg, s, lv1, cv->next->v.i,
+					       flags);
 		} else {
 			log_error("Couldn't find volume '%s' "
 				  "for segment '%s'.",
@@ -396,9 +387,9 @@ int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
 	return 1;
 }
 
-static int _read_segments(struct pool *mem, struct volume_group *vg,
+static int _read_segments(struct dm_pool *mem, struct volume_group *vg,
 			  struct logical_volume *lv, struct config_node *lvn,
-			  struct hash_table *pv_hash)
+			  struct dm_hash_table *pv_hash)
 {
 	struct config_node *sn;
 	int count = 0, seg_count;
@@ -437,7 +428,7 @@ static int _read_segments(struct pool *mem, struct volume_group *vg,
 	/*
 	 * Check there are no gaps or overlaps in the lv.
 	 */
-	if (!lv_check_segments(lv)) {
+	if (!check_lv_segments(lv, 0)) {
 		stack;
 		return 0;
 	}
@@ -453,23 +444,23 @@ static int _read_segments(struct pool *mem, struct volume_group *vg,
 	return 1;
 }
 
-static int _read_lvnames(struct format_instance *fid, struct pool *mem,
+static int _read_lvnames(struct format_instance *fid, struct dm_pool *mem,
 			 struct volume_group *vg, struct config_node *lvn,
-			 struct config_node *vgn, struct hash_table *pv_hash)
+			 struct config_node *vgn, struct dm_hash_table *pv_hash)
 {
 	struct logical_volume *lv;
 	struct lv_list *lvl;
 	struct config_node *cn;
 
-	if (!(lvl = pool_zalloc(mem, sizeof(*lvl))) ||
-	    !(lvl->lv = pool_zalloc(mem, sizeof(*lvl->lv)))) {
+	if (!(lvl = dm_pool_zalloc(mem, sizeof(*lvl))) ||
+	    !(lvl->lv = dm_pool_zalloc(mem, sizeof(*lvl->lv)))) {
 		stack;
 		return 0;
 	}
 
 	lv = lvl->lv;
 
-	if (!(lv->name = pool_strdup(mem, lvn->key))) {
+	if (!(lv->name = dm_pool_strdup(mem, lvn->key))) {
 		stack;
 		return 0;
 	}
@@ -508,6 +499,8 @@ static int _read_lvnames(struct format_instance *fid, struct pool *mem,
 	if (!_read_int32(lvn, "read_ahead", &lv->read_ahead))
 		lv->read_ahead = 0;
 
+	lv->snapshot = NULL;
+	list_init(&lv->snapshot_segs);
 	list_init(&lv->segments);
 	list_init(&lv->tags);
 
@@ -526,9 +519,9 @@ static int _read_lvnames(struct format_instance *fid, struct pool *mem,
 	return 1;
 }
 
-static int _read_lvsegs(struct format_instance *fid, struct pool *mem,
+static int _read_lvsegs(struct format_instance *fid, struct dm_pool *mem,
 			struct volume_group *vg, struct config_node *lvn,
-			struct config_node *vgn, struct hash_table *pv_hash)
+			struct config_node *vgn, struct dm_hash_table *pv_hash)
 {
 	struct logical_volume *lv;
 	struct lv_list *lvl;
@@ -561,24 +554,29 @@ static int _read_lvsegs(struct format_instance *fid, struct pool *mem,
 
 	lv->size = (uint64_t) lv->le_count * (uint64_t) vg->extent_size;
 
-	/* Skip this for now for snapshots */
-	if (!(lv->status & SNAPSHOT)) {
-		lv->minor = -1;
-		if ((lv->status & FIXED_MINOR) &&
-		    !_read_int32(lvn, "minor", &lv->minor)) {
-			log_error("Couldn't read minor number for logical "
-				  "volume %s.", lv->name);
-			return 0;
-		}
-		lv->major = -1;
-		if ((lv->status & FIXED_MINOR) &&
-		    !_read_int32(lvn, "major", &lv->major)) {
-			log_error("Couldn't read major number for logical "
-				  "volume %s.", lv->name);
-		}
-	} else {
+	/*
+	 * FIXME We now have 2 LVs for each snapshot. The real one was
+	 * created by vg_add_snapshot from the segment text_import.
+	 */
+	if (lv->status & SNAPSHOT) {
 		vg->lv_count--;
 		list_del(&lvl->list);
+		return 1;
+	}
+
+	lv->minor = -1;
+	if ((lv->status & FIXED_MINOR) &&
+	    !_read_int32(lvn, "minor", &lv->minor)) {
+		log_error("Couldn't read minor number for logical "
+			  "volume %s.", lv->name);
+		return 0;
+	}
+
+	lv->major = -1;
+	if ((lv->status & FIXED_MINOR) &&
+	    !_read_int32(lvn, "major", &lv->major)) {
+		log_error("Couldn't read major number for logical "
+			  "volume %s.", lv->name);
 	}
 
 	return 1;
@@ -586,9 +584,9 @@ static int _read_lvsegs(struct format_instance *fid, struct pool *mem,
 
 static int _read_sections(struct format_instance *fid,
 			  const char *section, section_fn fn,
-			  struct pool *mem,
+			  struct dm_pool *mem,
 			  struct volume_group *vg, struct config_node *vgn,
-			  struct hash_table *pv_hash, int optional)
+			  struct dm_hash_table *pv_hash, int optional)
 {
 	struct config_node *n;
 
@@ -616,8 +614,8 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 {
 	struct config_node *vgn, *cn;
 	struct volume_group *vg;
-	struct hash_table *pv_hash = NULL;
-	struct pool *mem = fid->fmt->cmd->mem;
+	struct dm_hash_table *pv_hash = NULL;
+	struct dm_pool *mem = fid->fmt->cmd->mem;
 
 	/* skip any top-level values */
 	for (vgn = cft->root; (vgn && vgn->v); vgn = vgn->sib) ;
@@ -627,7 +625,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 		return NULL;
 	}
 
-	if (!(vg = pool_zalloc(mem, sizeof(*vg)))) {
+	if (!(vg = dm_pool_zalloc(mem, sizeof(*vg)))) {
 		stack;
 		return NULL;
 	}
@@ -637,12 +635,12 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 	/* eg Set to instance of fmt1 here if reading a format1 backup? */
 	vg->fid = fid;
 
-	if (!(vg->name = pool_strdup(mem, vgn->key))) {
+	if (!(vg->name = dm_pool_strdup(mem, vgn->key))) {
 		stack;
 		goto bad;
 	}
 
-	if (!(vg->system_id = pool_zalloc(mem, NAME_LEN))) {
+	if (!(vg->system_id = dm_pool_zalloc(mem, NAME_LEN))) {
 		stack;
 		goto bad;
 	}
@@ -722,7 +720,7 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 	 * The pv hash memoises the pv section names -> pv
 	 * structures.
 	 */
-	if (!(pv_hash = hash_create(32))) {
+	if (!(pv_hash = dm_hash_create(32))) {
 		log_error("Couldn't create hash table.");
 		goto bad;
 	}
@@ -736,7 +734,6 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 	}
 
 	list_init(&vg->lvs);
-	list_init(&vg->snapshots);
 	list_init(&vg->tags);
 
 	/* Optional tags */
@@ -760,7 +757,13 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 		goto bad;
 	}
 
-	hash_destroy(pv_hash);
+	if (!fixup_imported_mirrors(vg)) {
+		log_error("Failed to fixup mirror pointers after import for "
+			  "volume group %s.", vg->name);
+		goto bad;
+	}
+
+	dm_hash_destroy(pv_hash);
 
 	if (vg->status & PARTIAL_VG) {
 		vg->status &= ~LVM_WRITE;
@@ -774,13 +777,13 @@ static struct volume_group *_read_vg(struct format_instance *fid,
 
       bad:
 	if (pv_hash)
-		hash_destroy(pv_hash);
+		dm_hash_destroy(pv_hash);
 
-	pool_free(mem, vg);
+	dm_pool_free(mem, vg);
 	return NULL;
 }
 
-static void _read_desc(struct pool *mem,
+static void _read_desc(struct dm_pool *mem,
 		       struct config_tree *cft, time_t *when, char **desc)
 {
 	const char *d;
@@ -789,7 +792,7 @@ static void _read_desc(struct pool *mem,
 	log_suppress(1);
 	d = find_config_str(cft->root, "description", "");
 	log_suppress(0);
-	*desc = pool_strdup(mem, d);
+	*desc = dm_pool_strdup(mem, d);
 
 	get_config_uint32(cft->root, "creation_time", &u);
 	*when = u;

lib/format_text/layout.h

@@ -37,6 +37,8 @@ struct data_area_list {
 /* On disk */
 struct pv_header {
 	uint8_t pv_uuid[ID_LEN];
+
+	/* This size can be overridden if PV belongs to a VG */
 	uint64_t device_size_xl;	/* Bytes */
 
 	/* NULL-terminated list of data areas followed by */
@@ -81,5 +83,6 @@ struct mda_context {
 #define FMTT_VERSION 1
 #define MDA_HEADER_SIZE 512
 #define LVM2_LABEL "LVM2 001"
+#define MDA_SIZE_MIN (8 * getpagesize())
 
 #endif

lib/format_text/tags.c

@@ -16,7 +16,6 @@
 #include "lib.h"
 #include "metadata.h"
 #include "import-export.h"
-#include "pool.h"
 #include "str_list.h"
 #include "lvm-string.h"
 
@@ -53,7 +52,7 @@ int print_tags(struct list *tags, char *buffer, size_t size)
 	return 1;
 }
 
-int read_tags(struct pool *mem, struct list *tags, struct config_value *cv)
+int read_tags(struct dm_pool *mem, struct list *tags, struct config_value *cv)
 {
 	if (cv->type == CFG_EMPTY_ARRAY)
 		return 1;
@@ -64,7 +63,7 @@ int read_tags(struct pool *mem, struct list *tags, struct config_value *cv)
 			return 0;
 		}
 
-		if (!str_list_add(mem, tags, pool_strdup(mem, cv->v.str))) {
+		if (!str_list_add(mem, tags, dm_pool_strdup(mem, cv->v.str))) {
 			stack;
 			return 0;
 		}

lib/format_text/text_export.h

@@ -17,6 +17,7 @@
 #define _LVM_TEXT_EXPORT_H
 
 #define outf(args...) do {if (!out_text(args)) {stack; return 0;}} while (0)
+#define outnl(f) do {if (!f->nl(f)) {stack; return 0;}} while (0)
 
 struct formatter;
 struct lv_segment;

lib/format_text/text_import.h

@@ -20,6 +20,7 @@ struct lv_segment;
 struct config_node;
 
 int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
-		      const struct config_node *cn, struct hash_table *pv_hash);
+		      const struct config_node *cn, struct dm_hash_table *pv_hash,
+		      uint32_t flags);
 
 #endif

lib/format_text/text_label.c

@@ -39,7 +39,6 @@ static int _write(struct label *label, char *buf)
 	struct pv_header *pvhdr;
 	struct lvmcache_info *info;
 	struct disk_locn *pvh_dlocn_xl;
-	struct list *mdash, *dash;
 	struct metadata_area *mda;
 	struct mda_context *mdac;
 	struct data_area_list *da;
@@ -57,9 +56,7 @@ static int _write(struct label *label, char *buf)
 	pvh_dlocn_xl = &pvhdr->disk_areas_xl[0];
 
 	/* List of data areas (holding PEs) */
-	list_iterate(dash, &info->das) {
-		da = list_item(dash, struct data_area_list);
-
+	list_iterate_items(da, &info->das) {
 		pvh_dlocn_xl->offset = xlate64(da->disk_locn.offset);
 		pvh_dlocn_xl->size = xlate64(da->disk_locn.size);
 		pvh_dlocn_xl++;
@@ -71,8 +68,7 @@ static int _write(struct label *label, char *buf)
 	pvh_dlocn_xl++;
 
 	/* List of metadata area header locations */
-	list_iterate(mdash, &info->mdas) {
-		mda = list_item(mdash, struct metadata_area);
+	list_iterate_items(mda, &info->mdas) {
 		mdac = (struct mda_context *) mda->metadata_locn;
 
 		if (mdac->area.dev != info->dev)
@@ -90,18 +86,18 @@ static int _write(struct label *label, char *buf)
 	return 1;
 }
 
-int add_da(const struct format_type *fmt, struct pool *mem, struct list *das,
+int add_da(const struct format_type *fmt, struct dm_pool *mem, struct list *das,
 	   uint64_t start, uint64_t size)
 {
 	struct data_area_list *dal;
 
 	if (!mem) {
-		if (!(dal = dbg_malloc(sizeof(*dal)))) {
+		if (!(dal = dm_malloc(sizeof(*dal)))) {
 			log_error("struct data_area_list allocation failed");
 			return 0;
 		}
 	} else {
-		if (!(dal = pool_alloc(mem, sizeof(*dal)))) {
+		if (!(dal = dm_pool_alloc(mem, sizeof(*dal)))) {
 			log_error("struct data_area_list allocation failed");
 			return 0;
 		}
@@ -123,11 +119,11 @@ void del_das(struct list *das)
 	list_iterate_safe(dah, tmp, das) {
 		da = list_item(dah, struct data_area_list);
 		list_del(&da->list);
-		dbg_free(da);
+		dm_free(da);
 	}
 }
 
-int add_mda(const struct format_type *fmt, struct pool *mem, struct list *mdas,
+int add_mda(const struct format_type *fmt, struct dm_pool *mem, struct list *mdas,
 	    struct device *dev, uint64_t start, uint64_t size)
 {
 /* FIXME List size restricted by pv_header SECTOR_SIZE */
@@ -136,23 +132,23 @@ int add_mda(const struct format_type *fmt, struct pool *mem, struct list *mdas,
 	struct mda_context *mdac;
 
 	if (!mem) {
-		if (!(mdal = dbg_malloc(sizeof(struct metadata_area)))) {
+		if (!(mdal = dm_malloc(sizeof(struct metadata_area)))) {
 			log_error("struct mda_list allocation failed");
 			return 0;
 		}
 
-		if (!(mdac = dbg_malloc(sizeof(struct mda_context)))) {
+		if (!(mdac = dm_malloc(sizeof(struct mda_context)))) {
 			log_error("struct mda_context allocation failed");
-			dbg_free(mdal);
+			dm_free(mdal);
 			return 0;
 		}
 	} else {
-		if (!(mdal = pool_alloc(mem, sizeof(struct metadata_area)))) {
+		if (!(mdal = dm_pool_alloc(mem, sizeof(struct metadata_area)))) {
 			log_error("struct mda_list allocation failed");
 			return 0;
 		}
 
-		if (!(mdac = pool_alloc(mem, sizeof(struct mda_context)))) {
+		if (!(mdac = dm_pool_alloc(mem, sizeof(struct mda_context)))) {
 			log_error("struct mda_context allocation failed");
 			return 0;
 		}
@@ -177,9 +173,9 @@ void del_mdas(struct list *mdas)
 
 	list_iterate_safe(mdah, tmp, mdas) {
 		mda = list_item(mdah, struct metadata_area);
-		dbg_free(mda->metadata_locn);
+		dm_free(mda->metadata_locn);
 		list_del(&mda->list);
-		dbg_free(mda);
+		dm_free(mda);
 	}
 }
 
@@ -198,7 +194,6 @@ static int _read(struct labeller *l, struct device *dev, char *buf,
 	struct lvmcache_info *info;
 	struct disk_locn *dlocn_xl;
 	uint64_t offset;
-	struct list *mdah;
 	struct metadata_area *mda;
 	char vgnamebuf[NAME_LEN + 2];
 	struct mda_context *mdac;
@@ -235,8 +230,7 @@ static int _read(struct labeller *l, struct device *dev, char *buf,
 		dlocn_xl++;
 	}
 
-	list_iterate(mdah, &info->mdas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &info->mdas) {
 		mdac = (struct mda_context *) mda->metadata_locn;
 		if (vgname_from_mda(info->fmt, &mdac->area, vgnamebuf,
 				    sizeof(vgnamebuf))) {
@@ -261,7 +255,7 @@ static void _destroy_label(struct labeller *l, struct label *label)
 
 static void _destroy(struct labeller *l)
 {
-	dbg_free(l);
+	dm_free(l);
 }
 
 struct label_ops _text_ops = {
@@ -278,7 +272,7 @@ struct labeller *text_labeller_create(const struct format_type *fmt)
 {
 	struct labeller *l;
 
-	if (!(l = dbg_malloc(sizeof(*l)))) {
+	if (!(l = dm_malloc(sizeof(*l)))) {
 		log_err("Couldn't allocate labeller object.");
 		return NULL;
 	}

lib/label/label.c

@@ -15,7 +15,6 @@
 
 #include "lib.h"
 #include "label.h"
-#include "list.h"
 #include "crc.h"
 #include "xlate.h"
 #include "lvmcache.h"
@@ -46,7 +45,7 @@ static struct labeller_i *_alloc_li(const char *name, struct labeller *l)
 
 	len = sizeof(*li) + strlen(name) + 1;
 
-	if (!(li = dbg_malloc(len))) {
+	if (!(li = dm_malloc(len))) {
 		log_error("Couldn't allocate memory for labeller list object.");
 		return NULL;
 	}
@@ -59,7 +58,7 @@ static struct labeller_i *_alloc_li(const char *name, struct labeller *l)
 
 static void _free_li(struct labeller_i *li)
 {
-	dbg_free(li);
+	dm_free(li);
 }
 
 int label_init(void)
@@ -98,14 +97,11 @@ int label_register_handler(const char *name, struct labeller *handler)
 
 struct labeller *label_get_handler(const char *name)
 {
-	struct list *lih;
 	struct labeller_i *li;
 
-	list_iterate(lih, &_labellers) {
-		li = list_item(lih, struct labeller_i);
+	list_iterate_items(li, &_labellers)
 		if (!strcmp(li->name, name))
 			return li->l;
-	}
 
 	return NULL;
 }
@@ -113,16 +109,20 @@ struct labeller *label_get_handler(const char *name)
 static struct labeller *_find_labeller(struct device *dev, char *buf,
 				       uint64_t *label_sector)
 {
-	struct list *lih;
 	struct labeller_i *li;
 	struct labeller *r = NULL;
 	struct label_header *lh;
+	struct lvmcache_info *info;
 	uint64_t sector;
 	int found = 0;
 	char readbuf[LABEL_SCAN_SIZE];
 
 	if (!dev_open(dev)) {
 		stack;
+
+		if ((info = info_from_pvid(dev->pvid)))
+			lvmcache_update_vgname(info, ORPHAN);
+
 		return NULL;
 	}
 
@@ -161,8 +161,7 @@ static struct labeller *_find_labeller(struct device *dev, char *buf,
 				continue;
 		}
 
-		list_iterate(lih, &_labellers) {
-			li = list_item(lih, struct labeller_i);
+		list_iterate_items(li, &_labellers) {
 			if (li->l->ops->can_handle(li->l, (char *) lh, sector)) {
 				log_very_verbose("%s: %s label detected",
 						 dev_name(dev), li->name);
@@ -182,10 +181,13 @@ static struct labeller *_find_labeller(struct device *dev, char *buf,
 		}
 	}
 
-	if (!found)
-		log_very_verbose("%s: No label detected", dev_name(dev));
-
       out:
+	if (!found) {
+		if ((info = info_from_pvid(dev->pvid)))
+			lvmcache_update_vgname(info, ORPHAN);
+		log_very_verbose("%s: No label detected", dev_name(dev));
+	}
+
 	if (!dev_close(dev))
 		stack;
 
@@ -200,7 +202,6 @@ int label_remove(struct device *dev)
 	int r = 1;
 	uint64_t sector;
 	int wipe;
-	struct list *lih;
 	struct labeller_i *li;
 	struct label_header *lh;
 
@@ -236,8 +237,7 @@ int label_remove(struct device *dev)
 			if (xlate64(lh->sector_xl) == sector)
 				wipe = 1;
 		} else {
-			list_iterate(lih, &_labellers) {
-				li = list_item(lih, struct labeller_i);
+			list_iterate_items(li, &_labellers) {
 				if (li->l->ops->can_handle(li->l, (char *) lh,
 							   sector)) {
 					wipe = 1;
@@ -279,7 +279,7 @@ int label_read(struct device *dev, struct label **result)
 		return 0;
 	}
 
-	if ((r = l->ops->read(l, dev, buf, result)) && result && *result)
+	if ((r = (l->ops->read)(l, dev, buf, result)) && result && *result)
 		(*result)->sector = sector;
 
 	return r;
@@ -309,7 +309,7 @@ int label_write(struct device *dev, struct label *label)
 	lh->sector_xl = xlate64(label->sector);
 	lh->offset_xl = xlate32(sizeof(*lh));
 
-	if (!label->labeller->ops->write(label, buf)) {
+	if (!(label->labeller->ops->write)(label, buf)) {
 		stack;
 		return 0;
 	}
@@ -352,14 +352,14 @@ int label_verify(struct device *dev)
 void label_destroy(struct label *label)
 {
 	label->labeller->ops->destroy_label(label->labeller, label);
-	dbg_free(label);
+	dm_free(label);
 }
 
 struct label *label_create(struct labeller *labeller)
 {
 	struct label *label;
 
-	if (!(label = dbg_malloc(sizeof(*label)))) {
+	if (!(label = dm_malloc(sizeof(*label)))) {
 		log_error("label allocaction failed");
 		return NULL;
 	}

lib/locking/cluster_locking.c

@@ -127,7 +127,7 @@ static int _send_request(char *inbuf, int inlen, char **retbuf)
 
 	/* Allocate buffer */
 	buflen = len + outheader->arglen;
-	*retbuf = dbg_malloc(buflen);
+	*retbuf = dm_malloc(buflen);
 	if (!*retbuf) {
 		errno = ENOMEM;
 		return 0;
@@ -139,8 +139,7 @@ static int _send_request(char *inbuf, int inlen, char **retbuf)
 
 	/* Read the returned values */
 	off = 1;		/* we've already read the first byte */
-
-	while (off < outheader->arglen && len > 0) {
+	while (off <= outheader->arglen && len > 0) {
 		len = read(_clvmd_sock, outheader->args + off,
 			   buflen - off - offsetof(struct clvm_header, args));
 		if (len > 0)
@@ -148,10 +147,16 @@ static int _send_request(char *inbuf, int inlen, char **retbuf)
 	}
 
 	/* Was it an error ? */
-	if (outheader->status < 0) {
-		errno = -outheader->status;
-		log_error("cluster send request failed: %s", strerror(errno));
-		return 0;
+	if (outheader->status != 0) {
+		errno = outheader->status;
+
+		/* Only return an error here if there are no node-specific
+		   errors present in the message that might have more detail */
+		if (!(outheader->flags & CLVMD_FLAG_NODEERRS)) {
+			log_error("cluster request failed: %s", strerror(errno));
+			return 0;
+		}
+
 	}
 
 	return 1;
@@ -231,7 +236,7 @@ static int _cluster_request(char cmd, const char *node, void *data, int len,
 	 * With an extra pair of INTs on the front to sanity
 	 * check the pointer when we are given it back to free
 	 */
-	outptr = dbg_malloc(sizeof(lvm_response_t) * num_responses +
+	outptr = dm_malloc(sizeof(lvm_response_t) * num_responses +
 			    sizeof(int) * 2);
 	if (!outptr) {
 		errno = ENOMEM;
@@ -254,12 +259,12 @@ static int _cluster_request(char cmd, const char *node, void *data, int len,
 		rarray[i].status = *(int *) inptr;
 		inptr += sizeof(int);
 
-		rarray[i].response = dbg_malloc(strlen(inptr) + 1);
+		rarray[i].response = dm_malloc(strlen(inptr) + 1);
 		if (rarray[i].response == NULL) {
 			/* Free up everything else and return error */
 			int j;
 			for (j = 0; j < i; j++)
-				dbg_free(rarray[i].response);
+				dm_free(rarray[i].response);
 			free(outptr);
 			errno = ENOMEM;
 			status = -1;
@@ -276,7 +281,7 @@ static int _cluster_request(char cmd, const char *node, void *data, int len,
 
       out:
 	if (retbuf)
-		dbg_free(retbuf);
+		dm_free(retbuf);
 
 	return status;
 }
@@ -297,10 +302,10 @@ static int _cluster_free_request(lvm_response_t * response)
 	num = ptr[1];
 
 	for (i = 0; i < num; i++) {
-		dbg_free(response[i].response);
+		dm_free(response[i].response);
 	}
 
-	dbg_free(ptr);
+	dm_free(ptr);
 
 	return 1;
 }
@@ -322,19 +327,20 @@ static int _lock_for_cluster(unsigned char cmd, unsigned int flags, char *name)
 	args = alloca(len);
 	strcpy(args + 2, name);
 
-	args[0] = flags & 0xBF; /* Maskoff LOCAL flag */
-	args[1] = 0;		/* Not used now */
+	args[0] = flags & 0x7F; /* Maskoff lock flags */
+	args[1] = flags & 0xC0; /* Bitmap flags */
 
 	/*
 	 * VG locks are just that: locks, and have no side effects
 	 * so we only need to do them on the local node because all
 	 * locks are cluster-wide.
-	 * Also, if the lock is exclusive it makes no sense to try to 
+	 * Also, if the lock is exclusive it makes no sense to try to
 	 * acquire it on all nodes, so just do that on the local node too.
 	 */
 	if (cmd == CLVMD_CMD_LOCK_VG ||
 	    (flags & LCK_TYPE_MASK) == LCK_EXCL ||
-	    (flags & LCK_LOCAL))
+	    (flags & LCK_LOCAL) ||
+	    !(flags & LCK_CLUSTER_VG))
 		node = ".";
 
 	status = _cluster_request(cmd, node, args, len,
@@ -342,10 +348,11 @@ static int _lock_for_cluster(unsigned char cmd, unsigned int flags, char *name)
 
 	/* If any nodes were down then display them and return an error */
 	for (i = 0; i < num_responses; i++) {
-		if (response[i].status == -EHOSTDOWN) {
+		if (response[i].status == EHOSTDOWN) {
 			log_error("clvmd not running on node %s",
 				  response[i].node);
 			status = 0;
+			errno = response[i].status;
 		} else if (response[i].status) {
 			log_error("Error locking on node %s: %s",
 				  response[i].node,
@@ -353,6 +360,7 @@ static int _lock_for_cluster(unsigned char cmd, unsigned int flags, char *name)
 				  	response[i].response :
 				  	strerror(response[i].status));
 			status = 0;
+			errno = response[i].status;
 		}
 	}
 
@@ -439,7 +447,7 @@ int init_cluster_locking(struct locking_type *locking, struct config_tree *cft)
 	locking->lock_resource = _lock_resource;
 	locking->fin_locking = _locking_end;
 	locking->reset_locking = _reset_locking;
-	locking->flags = LCK_PRE_MEMLOCK;
+	locking->flags = LCK_PRE_MEMLOCK | LCK_CLUSTERED;
 
 	_clvmd_sock = _open_local_sock();
 	if (_clvmd_sock == -1)
@@ -456,6 +464,7 @@ int locking_init(int type, struct config_tree *cf, uint32_t *flags)
 
 	/* Ask LVM to lock memory before calling us */
 	*flags |= LCK_PRE_MEMLOCK;
+	*flags |= LCK_CLUSTERED;
 
 	return 1;
 }

lib/locking/file_locking.c

@@ -41,7 +41,7 @@ static char _lock_dir[NAME_LEN];
 
 static sig_t _oldhandler;
 static sigset_t _fullsigset, _intsigset;
-static int _handler_installed;
+static volatile sig_atomic_t _handler_installed;
 
 static int _release_lock(const char *file, int unlock)
 {
@@ -71,8 +71,8 @@ static int _release_lock(const char *file, int unlock)
 			if (close(ll->lf) < 0)
 				log_sys_error("close", ll->res);
 
-			dbg_free(ll->res);
-			dbg_free(llh);
+			dm_free(ll->res);
+			dm_free(llh);
 
 			if (file)
 				return 1;
@@ -95,38 +95,40 @@ static void _reset_file_locking(void)
 static void _remove_ctrl_c_handler()
 {
 	siginterrupt(SIGINT, 0);
-	if (!_handler_installed || _oldhandler == SIG_ERR)
+	if (!_handler_installed)
 		return;
 
+	_handler_installed = 0;
+
 	sigprocmask(SIG_SETMASK, &_fullsigset, NULL);
 	if (signal(SIGINT, _oldhandler) == SIG_ERR)
 		log_sys_error("signal", "_remove_ctrl_c_handler");
-
-	_handler_installed = 0;
 }
 
 static void _trap_ctrl_c(int sig)
 {
 	_remove_ctrl_c_handler();
 	log_error("CTRL-c detected: giving up waiting for lock");
-	return;
 }
 
 static void _install_ctrl_c_handler()
 {
-	if ((_oldhandler = signal(SIGINT, _trap_ctrl_c)) == SIG_ERR)
+	_handler_installed = 1;
+
+	if ((_oldhandler = signal(SIGINT, _trap_ctrl_c)) == SIG_ERR) {
+		_handler_installed = 0;
 		return;
+	}
 
 	sigprocmask(SIG_SETMASK, &_intsigset, NULL);
 	siginterrupt(SIGINT, 1);
-
-	_handler_installed = 1;
 }
 
 static int _lock_file(const char *file, int flags)
 {
 	int operation;
 	int r = 1;
+	int old_errno;
 
 	struct lock_list *ll;
 	struct stat buf1, buf2;
@@ -148,11 +150,11 @@ static int _lock_file(const char *file, int flags)
 		return 0;
 	}
 
-	if (!(ll = dbg_malloc(sizeof(struct lock_list))))
+	if (!(ll = dm_malloc(sizeof(struct lock_list))))
 		return 0;
 
-	if (!(ll->res = dbg_strdup(file))) {
-		dbg_free(ll);
+	if (!(ll->res = dm_strdup(file))) {
+		dm_free(ll);
 		return 0;
 	}
 
@@ -176,10 +178,12 @@ static int _lock_file(const char *file, int flags)
 			_install_ctrl_c_handler();
 
 		r = flock(ll->lf, operation);
+		old_errno = errno;
 		if (!(flags & LCK_NONBLOCK))
 			_remove_ctrl_c_handler();
 
 		if (r) {
+			errno = old_errno;
 			log_sys_error("flock", ll->res);
 			goto err;
 		}
@@ -193,8 +197,8 @@ static int _lock_file(const char *file, int flags)
 	return 1;
 
       err:
-	dbg_free(ll->res);
-	dbg_free(ll);
+	dm_free(ll->res);
+	dm_free(ll);
 	return 0;
 }
 
@@ -239,7 +243,7 @@ static int _file_lock_resource(struct cmd_context *cmd, const char *resource,
 			break;
 		case LCK_READ:
 			log_debug("Locking LV %s (R)", resource);
-			if (!lv_activate_with_filter(cmd, resource))
+			if (!lv_activate_with_filter(cmd, resource, 0))
 				return 0;
 			break;
 		case LCK_WRITE:
@@ -249,7 +253,7 @@ static int _file_lock_resource(struct cmd_context *cmd, const char *resource,
 			break;
 		case LCK_EXCL:
 			log_debug("Locking LV %s (EX)", resource);
-			if (!lv_activate_with_filter(cmd, resource))
+			if (!lv_activate_with_filter(cmd, resource, 1))
 				return 0;
 			break;
 		default: