1.00.20

Allow user to kill clvmd during initialisation.

README

@@ -9,8 +9,8 @@ Installation instructions are in INSTALL.
 There is no warranty - see COPYING and COPYING.LIB.
 
 Tarballs are available from:
-  ftp://ftp.sistina.com/pub/LVM2/tools/
-  ftp://ftp.sistina.com/pub/LVM2/device-mapper/
+  ftp://sources.redhat.com/pub/lvm2/
+  ftp://sources.redhat.com/pub/dm/
 
 To access the CVS tree use:
   cvs -d :pserver:cvs@sources.redhat.com:/cvs/lvm2 login

VERSION

@@ -1 +1 @@
-2.00.20-cvs (2004-06-29)
+2.00.33-cvs (2004-12-22)

WHATS_NEW

@@ -1,5 +1,131 @@
-Version 2.00.20 -
-==============================
+Version 2.00.33 - 
+====================================
+  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.
+
+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.
+  Rename old segtypes files to segtype.
+  Some fixes to memory debugging code.
+  Exclude internal commands formats & segtypes from install.
+
+Version 2.00.23 - 15th September 2004
+=====================================
+  Export dm name build & split functions.
+  Use O_NOATIME on devices if available.
+  Write log message when each segtype/format gets initialised.
+  New commands 'segtypes' and 'formats'.
+  Suppress pvmove abort message in test mode.
+  Improve pvcreate/remove device not found error message.
+  Allow pvmove to move data within the same PV.
+  Describe how pvmove works on man page.
+  Test for incompatible format/segtype combinations in lv_extend.
+  Fix lvchange example on man page.
+
+Version 2.00.22 - 3rd September 2004
+====================================
+  Fix /dev/vgname perms.
+  Restructure xlate.h.
+  Add clvmd man page.
+
+Version 2.00.21 - 19th August 2004
+==================================
+  Update cnxman-socket.h from cman.
+  Recognise iseries/vd devices.
+  Use 'make install_cluster' to install cluster extensions only.
+  Cope with DT_UNKNOWN in sysfs.
+  Fix extents_moved metadata size comment.
+  Remove duplicate line in pvremove help text.
+  Support variable mirror region size.
+  Support PE ranges in pvmove source PV.
+  Fixes to as-yet-unused LV segment splitting code.
+  Change alloc_areas to pe_ranges and allow suppression of availability checks.
+  Add dev_size column to pvs.
+  Add report columns for in-kernel device number.
+
+Version 2.00.20 - 3 July 2004
+=============================
+  More autoconf fixes.
   Fix device number handling for 2.6 kernels.
 
 Version 2.00.19 - 29 June 2004

WHATS_NEW_DM

@@ -1,3 +1,13 @@
+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
 =============================
   More autoconf fixes.

configure.in

@@ -1,28 +1,25 @@
 ##
-##    Copyright 1999-2000 Sistina Software, Inc.
+## Copyright (C) 2000-2004 Sistina Software, Inc. All rights reserved.
+## Copyright (C) 2004 Red Hat, Inc. All rights reserved.
 ##
-##    This is free software released under the GNU General Public License.
-##    There is no warranty for this software.  See the file COPYING for
-##    details.
+## This file is part of the LVM2.
 ##
-##    See the file CONTRIBUTORS for a list of contributors.
+## 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.
 ##
-##    This file is maintained by:
-##      AJ Lewis <lewis@sistina.com>
-## 
-##    File name: configure.in
-##
-##    Description: Input file for autoconf.  Generates the configure script 
-##                 that tries to keep everything nice and portable.  It also
-##                 simplifies distribution package building considerably.
+## 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
 ################################################################################
 
+AC_PREREQ(2.53)
 ################################################################################
 dnl -- Process this file with autoconf to produce a configure script.
 AC_INIT(lib/device/dev-cache.h)
 
 ################################################################################
-dnl -- setup the directory where autoconf has auxilary files
+dnl -- Setup the directory where autoconf has auxilary files
 AC_CONFIG_AUX_DIR(autoconf) 
 
 ################################################################################
@@ -73,7 +70,18 @@ AC_PROG_RANLIB
 dnl -- Checks for header files.
 AC_HEADER_DIRENT
 AC_HEADER_STDC
-AC_CHECK_HEADERS(fcntl.h malloc.h sys/ioctl.h unistd.h)
+AC_HEADER_SYS_WAIT
+AC_HEADER_TIME
+
+AC_CHECK_HEADERS(fcntl.h limits.h locale.h stddef.h syslog.h sys/file.h sys/ioctl.h sys/param.h sys/time.h,,AC_MSG_ERROR(bailing out))
+AC_CHECK_HEADERS(assert.h ctype.h libgen.h signal.h stdio.h sys/mman.h sys/resource.h sys/stat.h sys/types.h sys/utsname.h sys/wait.h time.h,,AC_MSG_ERROR(bailing out))
+
+case "$host_os" in
+	linux*)
+		AC_CHECK_HEADERS(asm/byteorder.h linux/fs.h malloc.h,,AC_MSG_ERROR(bailing out)) ;;
+	darwin*)
+		AC_CHECK_HEADERS(machine/endian.h sys/disk.h,,AC_MSG_ERROR(bailing out)) ;;
+esac
 
 ################################################################################
 dnl -- Checks for typedefs, structures, and compiler characteristics.
@@ -82,8 +90,22 @@ AC_C_INLINE
 AC_TYPE_OFF_T
 AC_TYPE_PID_T
 AC_TYPE_SIZE_T
+AC_TYPE_MODE_T
 AC_STRUCT_ST_RDEV
-AC_HEADER_TIME
+AC_STRUCT_TM
+
+################################################################################
+dnl -- Check for functions
+AC_CHECK_FUNCS(gethostname getpagesize memset munmap setlocale strcasecmp strchr strdup strncasecmp strerror strrchr strstr strtol strtoul,,AC_MSG_ERROR(bailing out))
+AC_FUNC_ALLOCA
+AC_FUNC_CLOSEDIR_VOID
+AC_FUNC_FORK
+AC_FUNC_LSTAT
+AC_FUNC_MALLOC
+AC_FUNC_MEMCMP
+AC_FUNC_MMAP
+AC_FUNC_STAT
+AC_FUNC_STRTOD
 
 ################################################################################
 dnl -- Prefix is /usr by default, the exec_prefix default is setup later
@@ -95,13 +117,13 @@ AC_ARG_ENABLE(jobs, [  --enable-jobs=NUM       Number of jobs to run simultaneou
 
 ################################################################################
 dnl -- Setup the ownership of the files
-echo $ac_n "Setting file owner to""... $ac_c" 1>&6
+AC_MSG_CHECKING(file owner)
 OWNER="root"
 
 AC_ARG_WITH(user,
   [  --with-user=USER        Set the owner of installed files ],
   [ OWNER="$withval" ])
-echo "$ac_t""$OWNER" 1>&6
+AC_MSG_RESULT($OWNER)
 
 if test x$OWNER != x; then
 	OWNER="-o $OWNER"
@@ -109,12 +131,12 @@ fi
 
 ################################################################################
 dnl -- Setup the group ownership of the files
-echo $ac_n "Setting group owner to""... $ac_c" 1>&6
+AC_MSG_CHECKING(group owner)
 GROUP="root"
 AC_ARG_WITH(group,
   [  --with-group=GROUP      Set the group owner of installed files ],
   [ GROUP="$withval" ])
-echo "$ac_t""$GROUP" 1>&6
+AC_MSG_RESULT($GROUP)
 
 if test x$GROUP != x; then
 	GROUP="-g $GROUP"
@@ -122,10 +144,10 @@ fi
 
 ################################################################################
 dnl -- LVM1 tool fallback option
-echo $ac_n "checking whether to enable lvm1 fallback""... $ac_c" 1>&6
+AC_MSG_CHECKING(whether to enable lvm1 fallback)
 AC_ARG_ENABLE(lvm1_fallback, [  --enable-lvm1_fallback  Use this to fall back and use LVM1 binaries if
                           device-mapper is missing from the kernel],  LVM1_FALLBACK=$enableval, LVM1_FALLBACK=no)
-echo "$ac_t""$LVM1_FALLBACK" 1>&6
+AC_MSG_RESULT($LVM1_FALLBACK)
 
 if test x$LVM1_FALLBACK = xyes; then
 	CFLAGS="$CFLAGS -DLVM1_FALLBACK"
@@ -133,19 +155,18 @@ fi
 
 ################################################################################
 dnl -- format1 inclusion type
-echo $ac_n "checking whether to include support for lvm1 metadata""... $ac_c" 1>&6
+AC_MSG_CHECKING(whether to include support for lvm1 metadata)
 AC_ARG_WITH(lvm1,
   [  --with-lvm1=TYPE        LVM1 metadata support: internal/shared/none
                           [TYPE=internal] ],
   [ LVM1="$withval" ],
   [ LVM1="internal" ])
-echo "$ac_t""$LVM1" 1>&6
+AC_MSG_RESULT($LVM1)
 
 if [[ "x$LVM1" != xnone -a "x$LVM1" != xinternal -a "x$LVM1" != xshared ]];
  then  AC_MSG_ERROR(
 --with-lvm1 parameter invalid
 )
- exit
 fi;
 
 if test x$LVM1 = xinternal; then
@@ -154,19 +175,18 @@ fi
 
 ################################################################################
 dnl -- format_pool inclusion type
-echo $ac_n "checking whether to include support for GFS pool metadata""... $ac_c" 1>&6
+AC_MSG_CHECKING(whether to include support for GFS pool metadata)
 AC_ARG_WITH(pool,
   [  --with-pool=TYPE        GFS pool read-only support: internal/shared/none
                           [TYPE=internal] ],
   [ POOL="$withval" ],
   [ POOL="internal" ])
-echo "$ac_t""$POOL" 1>&6
+AC_MSG_RESULT($POOL)
 
 if [[ "x$POOL" != xnone -a "x$POOL" != xinternal -a "x$POOL" != xshared ]];
  then  AC_MSG_ERROR(
 --with-pool parameter invalid
 )
- exit
 fi;
 
 if test x$POOL = xinternal; then
@@ -175,18 +195,17 @@ fi
 
 ################################################################################
 dnl -- cluster_locking inclusion type
-echo $ac_n "checking whether to include support for cluster locking""... $ac_c" 1>&6
+AC_MSG_CHECKING(whether to include support for cluster locking)
 AC_ARG_WITH(cluster,
   [  --with-cluster=TYPE     Cluster LVM locking support: internal/shared/none
                           [TYPE=internal] ],
   [ CLUSTER="$withval" ])
-echo "$ac_t""$CLUSTER" 1>&6
+AC_MSG_RESULT($CLUSTER)
 
 if [[ "x$CLUSTER" != xnone -a "x$CLUSTER" != xinternal -a "x$CLUSTER" != xshared ]];
  then  AC_MSG_ERROR(
 --with-cluster parameter invalid
 )
- exit
 fi;
 
 if test x$CLUSTER = xinternal; then
@@ -195,19 +214,18 @@ fi
 
 ################################################################################
 dnl -- snapshots inclusion type
-echo $ac_n "checking whether to include snapshots""... $ac_c" 1>&6
+AC_MSG_CHECKING(whether to include snapshots)
 AC_ARG_WITH(snapshots,
   [  --with-snapshots=TYPE   Snapshot support: internal/shared/none
                           [TYPE=internal] ],
   [ SNAPSHOTS="$withval" ],
   [ SNAPSHOTS="internal" ])
-echo "$ac_t""$SNAPSHOTS" 1>&6
+AC_MSG_RESULT($SNAPSHOTS)
 
 if [[ "x$SNAPSHOTS" != xnone -a "x$SNAPSHOTS" != xinternal -a "x$SNAPSHOTS" != xshared ]];
  then  AC_MSG_ERROR(
 --with-snapshots parameter invalid
 )
- exit
 fi;
 
 if test x$SNAPSHOTS = xinternal; then
@@ -216,19 +234,18 @@ fi
 
 ################################################################################
 dnl -- mirrors inclusion type
-echo $ac_n "checking whether to include mirrors""... $ac_c" 1>&6
+AC_MSG_CHECKING(whether to include mirrors)
 AC_ARG_WITH(mirrors,
   [  --with-mirrors=TYPE     Mirror support: internal/shared/none
                           [TYPE=internal] ],
   [ MIRRORS="$withval" ],
   [ MIRRORS="internal" ])
-echo "$ac_t""$MIRRORS" 1>&6
+AC_MSG_RESULT($MIRRORS)
 
 if [[ "x$MIRRORS" != xnone -a "x$MIRRORS" != xinternal -a "x$MIRRORS" != xshared ]];
  then  AC_MSG_ERROR(
 --with-mirrors parameter invalid
 )
- exit
 fi;
 
 if test x$MIRRORS = xinternal; then
@@ -237,17 +254,17 @@ fi
 
 ################################################################################
 dnl -- Enables staticly-linked tools
-echo $ac_n "checking whether to use static linking""... $ac_c" 1>&6
+AC_MSG_CHECKING(whether to use static linking)
 AC_ARG_ENABLE(static_link, [  --enable-static_link    Use this to link the tools to their libraries
                           statically.  Default is dynamic linking],  STATIC_LINK=$enableval, STATIC_LINK=no)
-echo "$ac_t""$STATIC_LINK" 1>&6
+AC_MSG_RESULT($STATIC_LINK)
 
 ################################################################################
 dnl -- Enable readline
-echo $ac_n "checking whether to enable readline""... $ac_c" 1>&6
-AC_ARG_ENABLE(readline, [  --enable-readline       Enable readline support],  \
+AC_MSG_CHECKING(whether to enable readline)
+AC_ARG_ENABLE(readline, [  --enable-readline       Enable readline support],
 READLINE=$enableval, READLINE=no)
-echo "$ac_t""$READLINE" 1>&6
+AC_MSG_RESULT($READLINE)
 
 if test x$READLINE = xyes; then
 	CFLAGS="$CFLAGS -DREADLINE_SUPPORT"
@@ -255,29 +272,35 @@ fi
 
 ################################################################################
 dnl -- Disable selinux
-echo $ac_n "checking whether to enable selinux support""... $ac_c" 1>&6
-AC_ARG_ENABLE(selinux, [  --disable-selinux       Disable selinux support],  \
+AC_MSG_CHECKING(whether to enable selinux support)
+AC_ARG_ENABLE(selinux, [  --disable-selinux       Disable selinux support],
 SELINUX=$enableval)
-echo "$ac_t""$SELINUX" 1>&6
+AC_MSG_RESULT($SELINUX)
 
 ################################################################################
 dnl -- Build cluster LVM daemon
-echo $ac_n "checking whether to build cluster LVM daemon""... $ac_c" 1>&6
-AC_ARG_WITH(clvmd, [  --with-clvmd            Build cluster LVM Daemon],  \
-CLVMD=$withval, CLVMD=no)
-echo "$ac_t""$CLVMD" 1>&6
+AC_MSG_CHECKING(whether to build cluster LVM daemon)
+AC_ARG_WITH(clvmd,
+  [  --with-clvmd=TYPE       Build cluster LVM Daemon: cman/gulm/none
+                          [TYPE=none] ],
+  [ CLVMD="$withval" ],
+  [ CLVMD="none" ])
+if test x$CLVMD = xyes; then
+	CLVMD=cman
+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
 
 ################################################################################
 dnl -- Enable debugging
-echo $ac_n "checking whether to enable debugging""... $ac_c" 1>&6
-AC_ARG_ENABLE(debug,    [  --enable-debug          Enable debugging],  \
-DEBUG=yes, DEBUG=no)
-echo "$ac_t""$DEBUG" 1>&6
+AC_MSG_CHECKING(whether to enable debugging)
+AC_ARG_ENABLE(debug,    [  --enable-debug          Enable debugging],
+DEBUG=$enableval, DEBUG=no)
+AC_MSG_RESULT($DEBUG)
 
 dnl -- Normally turn off optimisation for debug builds
 if test x$DEBUG = xyes; then
@@ -286,18 +309,18 @@ fi
 
 ################################################################################
 dnl -- Override optimisation
-echo $ac_n "checking for C optimisation flag""... $ac_c" 1>&6
+AC_MSG_CHECKING(for C optimisation flag)
 AC_ARG_WITH(optimisation,
   [  --with-optimisation=OPT C optimisation flag [OPT=-O2] ],
   [ COPTIMISE_FLAG="$withval" ])
-echo "$ac_t""$COPTIMISE_FLAG" 1>&6
+AC_MSG_RESULT($COPTIMISE_FLAG)
 
 ################################################################################
 dnl -- Disable devmapper
-echo $ac_n "checking whether to use device-mapper""... $ac_c" 1>&6
-AC_ARG_ENABLE(devmapper, [  --disable-devmapper     Disable device-mapper interaction],  \
-DEVMAPPER=no)
-echo "$ac_t""$DEVMAPPER" 1>&6
+AC_MSG_CHECKING(whether to use device-mapper)
+AC_ARG_ENABLE(devmapper, [  --disable-devmapper     Disable device-mapper interaction],
+DEVMAPPER=$enableval)
+AC_MSG_RESULT($DEVMAPPER)
 
 if test x$DEVMAPPER = xyes; then
 	CFLAGS="$CFLAGS -DDEVMAPPER_SUPPORT"
@@ -305,10 +328,10 @@ fi
 
 ################################################################################
 dnl -- Disable O_DIRECT
-echo $ac_n "checking whether to enable O_DIRECT""... $ac_c" 1>&6
-AC_ARG_ENABLE(o_direct, [  --disable-o_direct      Disable O_DIRECT],  \
-ODIRECT=no)
-echo "$ac_t""$ODIRECT" 1>&6
+AC_MSG_CHECKING(whether to enable O_DIRECT)
+AC_ARG_ENABLE(o_direct, [  --disable-o_direct      Disable O_DIRECT],
+ODIRECT=$enableval)
+AC_MSG_RESULT($ODIRECT)
 
 if test x$ODIRECT = xyes; then
 	CFLAGS="$CFLAGS -DO_DIRECT_SUPPORT"
@@ -316,10 +339,10 @@ fi
 
 ################################################################################
 dnl -- Enable cmdlib
-echo $ac_n "checking whether to compile liblvm2cmd.so""... $ac_c" 1>&6
-AC_ARG_ENABLE(cmdlib, [  --enable-cmdlib         Build shared command library],  \
-CMDLIB=yes, CMDLIB=no)
-echo "$ac_t""$CMDLIB" 1>&6
+AC_MSG_CHECKING(whether to compile liblvm2cmd.so)
+AC_ARG_ENABLE(cmdlib, [  --enable-cmdlib         Build shared command library],
+CMDLIB=$enableval, CMDLIB=no)
+AC_MSG_RESULT($CMDLIB)
 
 if test x$CMDLIB = xyes; then
 	CFLAGS="$CFLAGS -DCMDLIB"
@@ -327,9 +350,10 @@ fi
 
 ################################################################################
 dnl -- Enable fsadm
-echo $ac_n "checking whether to build fsadm""... $ac_c" 1>&6
-AC_ARG_ENABLE(fsadm, [  --enable-fsadm          Enable fsadm], FSADM=yes)
-echo "$ac_t""$FSADM" 1>&6
+AC_MSG_CHECKING(whether to build fsadm)
+AC_ARG_ENABLE(fsadm, [  --enable-fsadm          Enable fsadm],
+FSADM=$enableval)
+AC_MSG_RESULT($FSADM)
 
 ################################################################################
 dnl -- Mess with default exec_prefix
@@ -342,7 +366,7 @@ dnl -- Checks for library functions.
 AC_PROG_GCC_TRADITIONAL
 AC_TYPE_SIGNAL
 AC_FUNC_VPRINTF
-AC_CHECK_FUNCS(mkdir rmdir uname)
+AC_CHECK_FUNCS(mkdir rmdir uname,,AC_MSG_ERROR(bailing out))
 
 ################################################################################
 dnl -- Check for termcap (Shamelessly copied from parted 1.4.17)
@@ -358,7 +382,6 @@ Note: if you are using precompiled packages you will also need the development
 Note: (n)curses also seems to work as a substitute for termcap.  This was
   not found either - but you could try installing that as well.
 )
-	exit
 	)
 fi
 
@@ -366,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
@@ -381,19 +404,20 @@ if [[ \( "x$LVM1" = xshared -o "x$POOL" = xshared -o "x$CLUSTER" = xshared \
  then  AC_MSG_ERROR(
 Features cannot be 'shared' when building statically
 )
- exit
 fi
 
 ################################################################################
 dnl -- Check for is_selinux_enabled
 if test x$SELINUX = xyes; then
+	AC_MSG_CHECKING(for is_selinux_enabled function)
 	AC_CHECK_LIB(selinux, is_selinux_enabled, HAVE_SELINUX=yes, HAVE_SELINUX=no)
+	AC_MSG_RESULT($HAVE_SELINUX)
 
 	if test x$HAVE_SELINUX = xyes; then
 		CFLAGS="$CFLAGS -DHAVE_SELINUX"
 		LIBS="-lselinux $LIBS"
 	else
-		echo "Disabling selinux" 1>&6
+		AC_MSG_WARN(Disabling selinux)
 	fi
 fi
 
@@ -413,7 +437,6 @@ support with --disable-readline or download and install readline from:
 Note: if you are using precompiled packages you will also need the development
 package as well (which may be called readline-devel or something similar).
 )
-		exit
 	)
 	AC_CHECK_FUNC(rl_completion_matches, CFLAGS="$CFLAGS -DHAVE_RL_COMPLETION_MATCHES")
 		
@@ -421,10 +444,10 @@ fi
 
 ################################################################################
 dnl -- Internationalisation stuff
-echo $ac_n "checking whether to enable internationalisation""... $ac_c" 1>&6
-AC_ARG_ENABLE(nls, [  --enable-nls            Enable Native Language Support],\
-		INTL=yes, INTL=no)
-echo "$ac_t""$INTL" 1>&6
+AC_MSG_CHECKING(whether to enable internationalisation)
+AC_ARG_ENABLE(nls, [  --enable-nls            Enable Native Language Support],
+		INTL=$enableval, INTL=no)
+AC_MSG_RESULT($INTL)
 
 if test x$INTL = xyes; then
 	INTL_PACKAGE="lvm2"
@@ -433,7 +456,6 @@ if test x$INTL = xyes; then
 		then  AC_MSG_ERROR(
 		msgfmt not found in path $PATH
 		)
-		exit  
 	fi;
 
 	AC_ARG_WITH(localedir,
@@ -453,6 +475,45 @@ AC_ARG_WITH(staticdir,
   	    [ STATICDIR="$withval" ],
  	    [ STATICDIR='${exec_prefix}/sbin' ])
 
+################################################################################
+dnl -- Ensure additional headers required
+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
+	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
+#	AC_FUNC_REALLOC
+	AC_FUNC_SELECT_ARGTYPES
+fi
+
+if test x$FSADM = xyes; then
+	AC_CHECK_HEADERS(fstab.h sys/mount.h sys/vfs.h,,AC_MSG_ERROR(bailing out))
+	AC_CHECK_FUNCS(memmove,,AC_MSG_ERROR(bailing out))
+fi
+
+if test x$CLUSTER != xnone; then
+	AC_CHECK_HEADERS(sys/socket.h sys/un.h,,AC_MSG_ERROR(bailing out))
+	AC_CHECK_FUNCS(socket,,AC_MSG_ERROR(bailing out))
+fi
+
+if test x$HAVE_LIBDL = xyes; then
+	AC_CHECK_HEADERS(dlfcn.h,,AC_MSG_ERROR(bailing out))
+fi
+
+if test x$INTL = xyes; then
+	AC_CHECK_HEADERS(libintl.h,,AC_MSG_ERROR(bailing out))
+fi
+
+if test x$DEVMAPPER = xyes; then
+	AC_CHECK_HEADERS(libdevmapper.h,,AC_MSG_ERROR(bailing out))
+fi
+
+if test x$HAVE_SELINUX = xyes; then
+	AC_CHECK_HEADERS(selinux/selinux.h,,AC_MSG_ERROR(bailing out))
+fi
 
 ################################################################################
 if test "-f VERSION"; then
@@ -525,14 +586,9 @@ test/filters/Makefile                                                   \
 )
 
 if test x$ODIRECT != xyes; then
-  echo
-  echo Warning: O_DIRECT disabled.
-  echo Use of pvmove may cause machine to lock up under low memory conditions.
-  echo
+  AC_MSG_WARN(Warning: O_DIRECT disabled: low-memory pvmove may lock up)
 fi
 
 if test x$FSADM == xyes; then
-  echo
-  echo Warning: fsadm support is untested.
-  echo
+  AC_MSG_WARN(fsadm support is untested)
 fi

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,36 @@ 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")
+	SOURCES += clvmd-gulm.c tcp-comms.c
+	LMLIBS += -lccs -lgulm
+	CFLAGS += -DUSE_GULM
+endif
+
+ifeq ("@CLVMD@", "cman")
+	SOURCES += clvmd-cman.c
+	LMLIBS += -ldlm
+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
 
@@ -44,3 +54,6 @@ install_clvmd: $(TARGETS)
 		$(sbindir)/clvmd
 
 install: $(INSTALL_TARGETS)
+
+install_cluster: $(INSTALL_TARGETS)
+

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);
@@ -75,7 +74,7 @@ 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");
+		syslog(LOG_ERR, "Can't open cluster manager socket: %m");
 		return -1;
 	}
 
@@ -87,7 +86,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,7 +97,7 @@ 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);
@@ -203,7 +202,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,
+int cluster_fd_callback(struct local_client *client, char *buf, int len, char *csid,
 			struct local_client **new_client)
 {
 	struct iovec iov[2];
@@ -247,7 +246,11 @@ 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;
 }
 
@@ -257,17 +260,18 @@ void add_up_node(char *csid)
 	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;
@@ -319,7 +323,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 +335,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);
 		}
 
@@ -441,6 +445,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,6 +471,7 @@ 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
@@ -477,6 +483,8 @@ 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);

daemons/clvmd/clvmd-command.c

@@ -66,6 +66,7 @@
 #include <errno.h>
 
 #include "list.h"
+#include "hash.h"
 #include "locking.h"
 #include "log.h"
 #include "lvm-functions.h"
@@ -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 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 hash_table *)client->bits.localsock.private;
+    }
+    else {
+	lock_hash = hash_create(3);
+	if (!lock_hash)
+	    return ENOMEM;
+	client->bits.localsock.private = (void *)lock_hash;
+    }
+
+    lock_cmd = args[0];
+    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)hash_lookup(lock_hash, lockname);
+	if (lkid == 0)
+	    return EINVAL;
+
+	status = sync_unlock(lockname, lkid);
+	if (status)
+	    status = errno;
+	else
+	    hash_remove(lock_hash, lockname);
+    }
+    else {
+
+	status = sync_lock(lockname, (int)lock_cmd, (int)lock_flags, &lkid);
+	if (status)
+	    status = errno;
+	else
+	    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,25 @@ 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 hash_node *v;
+	struct hash_table *lock_hash =
+	    (struct hash_table *)client->bits.localsock.private;
+
+	hash_iterate(v, lock_hash) {
+		int lkid = (int)(long)hash_get_data(lock_hash, v);
+
+		DEBUGLOG("cleanup: Unlocking lkid %x\n", lkid);
+		sync_unlock("DUMMY", lkid);
+	}
+
+	hash_destroy(lock_hash);
+	client->bits.localsock.private = 0;
+    }
+}

daemons/clvmd/clvmd-gulm.c

@@ -139,11 +139,30 @@ int init_cluster()
 {
     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 */
@@ -155,7 +174,8 @@ int init_cluster()
     lock_hash = 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 +194,7 @@ int init_cluster()
     }
 
     /* Initialise the inter-node comms */
-    status = init_comms();
+    status = init_comms(port);
     if (status)
 	return status;
 
@@ -226,7 +246,6 @@ void cluster_closedown()
     DEBUGLOG("cluster_closedown\n");
     lg_lock_logout(gulm_if);
     lg_core_logout(gulm_if);
-    lg_core_shutdown(gulm_if);
     lg_release(gulm_if);
 }
 
@@ -316,11 +335,11 @@ static void set_node_state(struct node_info *ninfo, char *csid, uint8_t nodestat
 	     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 = hash_lookup_binary(node_hash, (char *)ip, MAX_CSID_LEN);
     if (!ninfo)
     {
 	/* If we can't find that node then re-read the config file in case it
@@ -329,7 +348,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 = hash_lookup_binary(node_hash, (char *)ip, MAX_CSID_LEN);
 	if (!ninfo)
 	{
 	    DEBUGLOG("Ignoring node %s, not part of the SAN cluster\n", name);
@@ -342,7 +361,7 @@ static struct node_info *add_or_set_node(char *name, uint32_t ip, uint8_t state)
     return ninfo;
 }
 
-static int core_nodelist(void *misc, lglcb_t type, char *name, uint32_t ip, uint8_t state)
+static int core_nodelist(void *misc, lglcb_t type, char *name, struct in6_addr *ip, uint8_t state)
 {
     DEBUGLOG("CORE nodelist\n");
 
@@ -354,7 +373,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);
 	}
@@ -381,24 +400,24 @@ 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  corestate:%#x mastername:%s\n",
+	     corestate, mastername);
 
     current_corestate = corestate;
     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,7 +462,9 @@ 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;
@@ -530,8 +551,7 @@ int name_from_csid(char *csid, char *name)
     ninfo = hash_lookup_binary(node_hash, csid, 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;
     }
 
@@ -661,6 +681,7 @@ static int _lock_resource(char *resource, int mode, int flags, int *lockid)
     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)
     {
@@ -692,6 +713,7 @@ static int _unlock_resource(char *resource, int lockid)
 
     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)
@@ -819,26 +841,38 @@ 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 nodekey[256];
 	char nodeip[MAX_CSID_LEN];
-	char *clvmflag;
+	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;
 
@@ -863,9 +897,7 @@ static int get_all_cluster_nodes()
 	{
 	    DEBUGLOG("node %s has clvm disabled\n", nodename);
 	}
-	if (clvmflag) free(clvmflag);
 	free(nodename);
-	error = ccs_get(ctree, "//nodes/node/@name", &nodename);
     }
 
     /* Finished with config file */
@@ -874,7 +906,3 @@ static int get_all_cluster_nodes()
     return 0;
 }
 
-int gulm_fd(void)
-{
-    return lg_core_selector(gulm_if);
-}

daemons/clvmd/clvmd.c

@@ -39,6 +39,7 @@
 #include "clvmd-comms.h"
 #include "lvm-functions.h"
 #include "clvm.h"
+#include "version.h"
 #include "clvmd.h"
 #include "libdlm.h"
 #include "system-lv.h"
@@ -82,6 +83,14 @@ static pthread_mutex_t lvm_thread_mutex;
 static pthread_cond_t lvm_thread_cond;
 static struct list lvm_cmd_head;
 static int quit = 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);
@@ -129,6 +138,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;
@@ -166,7 +187,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 +210,12 @@ 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.
 	   PIPE should be ignored */
 	signal(SIGUSR2, sigusr2_handler);
-	signal(SIGTERM, sigterm_handler);
-	signal(SIGINT, sigterm_handler);
 	signal(SIGPIPE, SIG_IGN);
 
 	/* Block SIGUSR2 in the main process */
@@ -213,7 +233,7 @@ int main(int argc, char *argv[])
 	if (init_cluster()) {
 		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");
 
@@ -229,7 +249,7 @@ int main(int argc, char *argv[])
 	/* 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->type = LOCAL_RENDEZVOUS;
@@ -251,6 +271,11 @@ int main(int argc, char *argv[])
 #endif
 
 	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);
@@ -303,6 +328,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;
@@ -461,7 +487,6 @@ static void main_loop(int local_sock, int cmd_timeout)
 
 		if ((select_status = select(FD_SETSIZE, &in, NULL, NULL, &tv)) > 0) {
 			struct local_client *lastfd = NULL;
-			struct clvm_header *inheader;
 			char csid[MAX_CSID_LEN];
 			char buf[MAX_CLUSTER_MESSAGE];
 
@@ -490,12 +515,12 @@ 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;
+						cmd_client_cleanup(free_fd);
 						free(free_fd);
 						break;
 					}
@@ -506,33 +531,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;
 			}
@@ -579,26 +577,65 @@ static void main_loop(int local_sock, int cmd_timeout)
 	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 */
@@ -717,6 +754,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;
 
@@ -863,8 +901,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;
 }
@@ -1292,7 +1332,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 */
@@ -1630,6 +1671,19 @@ 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)
 {
@@ -1681,7 +1735,6 @@ static void ntoh_clvm(struct clvm_header *hdr)
 static void sigusr2_handler(int sig)
 {
 	DEBUGLOG("SIGUSR2 received\n");
-	pthread_exit((void *) -1);
 	return;
 }
 

daemons/clvmd/clvmd.h

@@ -111,9 +111,9 @@ 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);
 #endif

daemons/clvmd/cnxman-socket.h

@@ -17,26 +17,16 @@
 #ifndef __CNXMAN_SOCKET_H
 #define __CNXMAN_SOCKET_H
 
-/* Just made these up but the address family must be less than 32 (NPROTO) */
-#define AF_CLUSTER 31
+/* A currently unused number. TIPC also uses this number and you're unlikely
+   to be using both.
+ */
+#define AF_CLUSTER 30
 #define PF_CLUSTER AF_CLUSTER
 
 /* Protocol(socket) types */
 #define CLPROTO_MASTER 2
 #define CLPROTO_CLIENT 3
 
-/* Setsockopt -- maybe should be ioctls?? */
-#define CLU_SET_MULTICAST  100
-#define CLU_JOIN_CLUSTER   101
-#define CLU_LEAVE_CLUSTER  102
-#define CLU_SET_RCVONLY    103
-#define CLU_SET_UNICAST    104
-#define KCL_SET_MULTICAST  105
-#define KCL_SET_RCVONLY    106
-#define KCL_SET_UNICAST    107
-#define KCL_SET_NODENAME   108
-#define CLU_SET_NODENAME   109
-
 /* ioctls -- should register these properly */
 #define SIOCCLUSTER_NOTIFY            _IOW('x', 0x01, int)
 #define SIOCCLUSTER_REMOVENOTIFY      _IO( 'x', 0x02)
@@ -58,12 +48,20 @@
 #define SIOCCLUSTER_SERVICE_SETSIGNAL _IOW('x', 0x30, int)
 #define SIOCCLUSTER_SERVICE_STARTDONE _IOW('x', 0x40, unsigned int)
 #define SIOCCLUSTER_SERVICE_GETEVENT  _IOR('x', 0x50, struct cl_service_event)
-#define SIOCCLUSTER_SERVICE_GETMEMBERS _IOR('x', 0x60, struct cl_cluster_node)
+#define SIOCCLUSTER_SERVICE_GETMEMBERS _IOR('x', 0x60, struct cl_cluster_nodelist)
 #define SIOCCLUSTER_SERVICE_GLOBALID  _IOR('x', 0x70, uint32_t)
 #define SIOCCLUSTER_SERVICE_SETLEVEL  _IOR('x', 0x80, int)
 #define SIOCCLUSTER_GETNODE	      _IOWR('x', 0x90, struct cl_cluster_node)
 #define SIOCCLUSTER_BARRIER           _IOW('x', 0x0a0, struct cl_barrier_info)
 
+/* These were setsockopts */
+#define SIOCCLUSTER_PASS_SOCKET       _IOW('x', 0x0b0, struct cl_passed_sock)
+#define SIOCCLUSTER_SET_NODENAME      _IOW('x', 0x0b1, char *)
+#define SIOCCLUSTER_SET_NODEID        _IOW('x', 0x0b2, int)
+#define SIOCCLUSTER_JOIN_CLUSTER      _IOW('x', 0x0b3, struct cl_join_cluster_info)
+#define SIOCCLUSTER_LEAVE_CLUSTER     _IOW('x', 0x0b4, int)
+
+
 /* Maximum size of a cluster message */
 #define MAX_CLUSTER_MESSAGE          1500
 #define MAX_CLUSTER_MEMBER_NAME_LEN   255
@@ -107,9 +105,10 @@
 #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;
+	       NODESTATE_DEAD } nodestate_t;
 
 
 struct sockaddr_cl {
@@ -119,13 +118,14 @@ struct sockaddr_cl {
 	int           scl_nodeid;
 };
 
-/* This is how we pass the multicast socket into kernel space. addr is the
- * multicast address to use in the address family of the socket (eg for UDP it
- * might be 255.255.255.0) */
-struct cl_multicast_sock {
+/*
+ * This is how we pass the multicast & receive sockets into kernel space.
+ */
+struct cl_passed_sock {
 	int fd;			/* FD of master socket to do multicast on */
 	int number;		/* Socket number, to match up recvonly & bcast
 				 * sockets */
+        int multicast;          /* Is it multicast or receive ? */
 };
 
 /* Cluster configuration info passed when we join the cluster */

daemons/clvmd/lvm-functions.c

@@ -46,6 +46,7 @@
 
 static struct cmd_context *cmd = NULL;
 static struct hash_table *lv_hash = NULL;
+static pthread_mutex_t lv_hash_lock;
 
 struct lv_info {
 	int lock_id;
@@ -57,7 +58,9 @@ static int get_current_lock(char *resource)
 {
 	struct lv_info *lvi;
 
+	pthread_mutex_lock(&lv_hash_lock);
 	lvi = hash_lookup(lv_hash, resource);
+	pthread_mutex_unlock(&lv_hash_lock);
 	if (lvi) {
 		return lvi->lock_mode;
 	} else {
@@ -69,11 +72,14 @@ static int get_current_lock(char *resource)
 void unlock_all()
 {
 	struct hash_node *v;
+
+	pthread_mutex_lock(&lv_hash_lock);
 	hash_iterate(v, lv_hash) {
 		struct lv_info *lvi = hash_get_data(lv_hash, v);
 
 		sync_unlock(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 +91,9 @@ int hold_lock(char *resource, int mode, int flags)
 
 	flags &= LKF_NOQUEUE;	/* Only LKF_NOQUEUE is valid here */
 
+	pthread_mutex_lock(&lv_hash_lock);
 	lvi = hash_lookup(lv_hash, resource);
+	pthread_mutex_unlock(&lv_hash_lock);
 	if (lvi) {
 		/* Already exists - convert it */
 		status =
@@ -113,7 +121,9 @@ int hold_lock(char *resource, int mode, int flags)
 			DEBUGLOG("hold_lock. lock at %d failed: %s\n", mode,
 				 strerror(errno));
 		} else {
+		        pthread_mutex_lock(&lv_hash_lock);
 			hash_insert(lv_hash, resource, lvi);
+			pthread_mutex_unlock(&lv_hash_lock);
 		}
 		errno = saved_errno;
 	}
@@ -127,8 +137,9 @@ int hold_unlock(char *resource)
 	int status;
 	int saved_errno;
 
+	pthread_mutex_lock(&lv_hash_lock);
 	lvi = 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 +148,9 @@ int hold_unlock(char *resource)
 	status = sync_unlock(resource, lvi->lock_id);
 	saved_errno = errno;
 	if (!status) {
+	    	pthread_mutex_lock(&lv_hash_lock);
 		hash_remove(lv_hash, resource);
+		pthread_mutex_unlock(&lv_hash_lock);
 		free(lvi);
 	} else {
 		DEBUGLOG("hold_unlock. unlock failed(%d): %s\n", status,
@@ -394,9 +407,11 @@ static void *get_initial_state()
 		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\n", vg, lv, flags) == 3) {
+
 			/* 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? */
 				/* Convert hyphen-separated UUIDs into one */
 				memcpy(&uuid[0], &vg[0], 6);
 				memcpy(&uuid[6], &vg[7], 4);
@@ -427,6 +442,7 @@ void init_lvhash()
 {
 	/* Create hash table for keeping LV locks & status */
 	lv_hash = hash_create(100);
+	pthread_mutex_init(&lv_hash_lock, NULL);
 }
 
 /* Called to initialise the LVM context of the daemon */

daemons/clvmd/tcp-comms.c

@@ -34,7 +34,6 @@
 #include <netdb.h>
 #include <assert.h>
 
-#include "ccs.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
 #include "clvmd.h"
@@ -47,43 +46,19 @@ static int listen_fd = -1;
 static int tcp_port;
 struct 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);
+    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)
     {
@@ -95,11 +70,13 @@ int init_comms()
 	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &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;
@@ -142,7 +119,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));
@@ -199,7 +176,7 @@ int cluster_fd_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];
@@ -218,22 +195,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 (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);
@@ -250,7 +225,7 @@ int cluster_fd_callback(struct local_client *fd, char *buf, int len, char *csid,
 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);
     int status;
 
@@ -259,7 +234,7 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
 
     /* Get "csid" */
     getpeername(client->fd, (struct sockaddr *)&addr, &slen);
-    memcpy(csid, &addr.sin_addr.s_addr, MAX_CSID_LEN);
+    memcpy(csid, &addr.sin6_addr, MAX_CSID_LEN);
 
     status = read(client->fd, buf, len);
 
@@ -283,17 +258,21 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
 	/* Tell cluster manager layer */
 	add_down_node(remcsid);
     }
+    else {
+	    /* Send it back to clvmd */
+	    process_message(client, buf, len, csid);
+    }
     return status;
 }
 
 static int connect_csid(char *csid, struct local_client **newclient)
 {
     int fd;
-    struct sockaddr_in addr;
+    struct sockaddr_in6 addr;
     int status;
 
     DEBUGLOG("Connecting socket\n");
-    fd = socket(PF_INET, SOCK_STREAM, 0);
+    fd = socket(PF_INET6, SOCK_STREAM, 0);
 
     if (fd < 0)
     {
@@ -301,12 +280,12 @@ 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, 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");
 	DEBUGLOG("Unable to connect to remote node: %s\n", strerror(errno));
@@ -334,7 +313,7 @@ static int tcp_send_message(void *buf, int msglen, unsigned char *csid, const ch
 
     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);
@@ -383,55 +362,17 @@ 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
@@ -454,6 +395,14 @@ void get_our_csid(char *csid)
     memcpy(csid, our_csid, 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 */
 int get_ip_address(char *node, char *addr)
 {
@@ -467,14 +416,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

@@ -4,4 +4,5 @@
 #define MAX_CSID_LEN sizeof(struct in6_addr)
 #define MAX_CLUSTER_MEMBER_NAME_LEN 128
 
-extern int init_comms(void);
+extern int init_comms(unsigned short);
+extern char *print_csid(char *);

doc/example.conf

@@ -27,6 +27,12 @@ devices {
     # the device will be accepted or rejected (ignored).  Devices that
     # don't match any patterns are accepted.
 
+    # Be careful if there there are symbolic links or multiple filesystem 
+    # entries for the same device as each name is checked separately against
+    # the list of patterns.  The effect is that if 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.
+
     # Remember to run vgscan after you change this parameter to ensure 
     # that the cache file gets regenerated (see below).
 

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

@@ -31,7 +31,7 @@
 ../lib/log/log.h
 ../lib/metadata/lv_alloc.h
 ../lib/metadata/metadata.h
-../lib/metadata/segtypes.h
+../lib/metadata/segtype.h
 ../lib/mm/dbg_malloc.h
 ../lib/mm/memlock.h
 ../lib/mm/pool.h
@@ -47,3 +47,4 @@
 ../lib/report/report.h
 ../lib/uuid/uuid.h
 ../po/pogen.h
+../tools/version.h

include/Makefile.in

@@ -20,6 +20,8 @@ VPATH = @srcdir@
 
 LN_S = @LN_S@
 
+.PHONY: clean distclean all install pofile install_cluster
+
 all: .symlinks_created
 
 .symlinks_created: .symlinks
@@ -37,5 +39,5 @@ clean:
 
 install:
 
-.PHONY: clean distclean all install pofile
+install_cluster:
 

lib/Makefile.in

@@ -43,6 +43,7 @@ SOURCES =\
 	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 \
@@ -70,11 +71,12 @@ SOURCES =\
 	metadata/metadata.c \
 	metadata/mirror.c \
 	metadata/pv_map.c \
-	metadata/segtypes.c \
+	metadata/segtype.c \
 	metadata/snapshot_manip.c \
 	misc/crc.c \
 	misc/lvm-file.c \
 	misc/lvm-string.c \
+	mm/dbg_malloc.c \
 	mm/memlock.c \
 	mm/pool.c \
 	regex/matcher.c \
@@ -120,10 +122,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 \

lib/activate/dev_manager.c

@@ -21,7 +21,7 @@
 #include "lvm-string.h"
 #include "fs.h"
 #include "defaults.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "display.h"
 #include "toolcontext.h"
 #include "targets.h"
@@ -165,89 +165,6 @@ static inline void _clear_flag(struct dev_layer *dl, int bit)
 	dl->flags &= ~(1 << bit);
 }
 
-/*
- * Device layer names are all of the form <vg>-<lv>-<layer>, any
- * other hyphens that appear in these names are quoted with yet
- * another hyphen.  The top layer of any device has no layer
- * name.  eg, vg0-lvol0.
- */
-static void _count_hyphens(const char *str, size_t *len, int *hyphens)
-{
-	const char *ptr;
-
-	for (ptr = str; *ptr; ptr++, (*len)++)
-		if (*ptr == '-')
-			(*hyphens)++;
-}
-
-/*
- * Copies a string, quoting hyphens with hyphens.
- */
-static void _quote_hyphens(char **out, const char *src)
-{
-	while (*src) {
-		if (*src == '-')
-			*(*out)++ = '-';
-
-		*(*out)++ = *src++;
-	}
-}
-
-/*
- * <vg>-<lv>-<layer> or if !layer just <vg>-<lv>.
- */
-static char *_build_name(struct pool *mem, const char *vg,
-			 const char *lv, const char *layer)
-{
-	size_t len = 0;
-	int hyphens = 0;
-	char *r, *out;
-
-	_count_hyphens(vg, &len, &hyphens);
-	_count_hyphens(lv, &len, &hyphens);
-
-	if (layer && *layer)
-		_count_hyphens(layer, &len, &hyphens);
-
-	len += hyphens + 2;
-
-	if (!(r = pool_alloc(mem, len))) {
-		stack;
-		return NULL;
-	}
-
-	out = r;
-	_quote_hyphens(&out, vg);
-	*out++ = '-';
-	_quote_hyphens(&out, lv);
-
-	if (layer && *layer) {
-		*out++ = '-';
-		_quote_hyphens(&out, layer);
-	}
-	*out = '\0';
-
-	return r;
-}
-
-/* Find start of LV component in hyphenated name */
-static char *_find_lv_name(char *vg)
-{
-	char *c = vg;
-
-	while (*c && *(c + 1)) {
-		if (*c == '-') {
-			if (*(c + 1) == '-')
-				c++;
-			else
-				return (c + 1);
-		}
-		c++;
-	}
-
-	return NULL;
-}
-
 static char *_build_dlid(struct pool *mem, const char *lvid, const char *layer)
 {
 	char *dlid;
@@ -519,10 +436,16 @@ static int _percent(struct dev_manager *dm, const char *name, const char *uuid,
 	return 0;
 }
 
-static int _rename(struct dev_layer *dl, char *newname)
+static int _rename(struct dev_manager *dm, struct dev_layer *dl, char *newname)
 {
 	int r = 1;
 	struct dm_task *dmt;
+	char *vgname, *lvname, *layer;
+
+	if (!split_dm_name(dm->mem, dl->name, &vgname, &lvname, &layer)) {
+		log_error("Couldn't split up dm layer name %s", dl->name);
+		return 0;
+	}
 
 	log_verbose("Renaming %s to %s", dl->name, newname);
 
@@ -537,11 +460,13 @@ static int _rename(struct dev_layer *dl, char *newname)
 		goto out;
 	}
 
-	if (!(r = dm_task_run(dmt)))
+	if (!(r = dm_task_run(dmt))) {
 		log_error("Couldn't rename device '%s'.", dl->name);
+		goto out;
+	}
 
 	if (r && _get_flag(dl, VISIBLE))
-		fs_rename_lv(dl->lv, newname, _find_lv_name(dl->name));
+		fs_rename_lv(dl->lv, newname, lvname);
 
 	dl->name = newname;
 
@@ -994,7 +919,7 @@ struct dev_manager *dev_manager_create(struct cmd_context *cmd,
 	struct pool *mem;
 	struct dev_manager *dm;
 
-	if (!(mem = pool_create(16 * 1024))) {
+	if (!(mem = pool_create("dev_manager", 16 * 1024))) {
 		stack;
 		return NULL;
 	}
@@ -1052,7 +977,7 @@ int dev_manager_info(struct dev_manager *dm, const struct logical_volume *lv,
 	/*
 	 * Build a name for the top layer.
 	 */
-	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, NULL))) {
+	if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, NULL))) {
 		stack;
 		return 0;
 	}
@@ -1077,7 +1002,7 @@ int dev_manager_snapshot_percent(struct dev_manager *dm,
 	/*
 	 * Build a name for the top layer.
 	 */
-	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, NULL))) {
+	if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, NULL))) {
 		stack;
 		return 0;
 	}
@@ -1109,7 +1034,7 @@ int dev_manager_mirror_percent(struct dev_manager *dm,
 	/*
 	 * Build a name for the top layer.
 	 */
-	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, NULL))) {
+	if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, NULL))) {
 		stack;
 		return 0;
 	}
@@ -1173,7 +1098,7 @@ static struct dev_layer *_create_layer(struct dev_manager *dm,
 	char *name, *dlid;
 	struct dev_layer *dl;
 
-	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, layer))) {
+	if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, layer))) {
 		stack;
 		return NULL;
 	}
@@ -1618,11 +1543,11 @@ static int _create_rec(struct dev_manager *dm, struct dev_layer *dl)
 	if (dl->info.exists) {
 		if ((suffix = rindex(dl->dlid, '-')))
 			suffix++;
-		newname = _build_name(dm->mem, dm->vg_name, dl->lv->name,
-				      suffix);
+		newname = build_dm_name(dm->mem, dm->vg_name, dl->lv->name,
+					suffix);
 		if (strcmp(newname, dl->name)) {
 			if (!_suspend_parents(dm, dl) ||
-			    !_suspend(dl) || !_rename(dl, newname)) {
+			    !_suspend(dl) || !_rename(dm, dl, newname)) {
 				stack;
 				return 0;
 			}
@@ -2227,8 +2152,8 @@ int dev_manager_lv_mknodes(const struct logical_volume *lv)
 {
 	char *name;
 
-	if (!(name = _build_name(lv->vg->cmd->mem, lv->vg->name,
-				 lv->name, NULL))) {
+	if (!(name = build_dm_name(lv->vg->cmd->mem, lv->vg->name,
+				   lv->name, NULL))) {
 		stack;
 		return 0;
 	}

lib/activate/fs.c

@@ -46,7 +46,7 @@ static int _mk_dir(const char *dev_dir, const char *vg_name)
 		return 1;
 
 	log_very_verbose("Creating directory %s", vg_path);
-	if (mkdir(vg_path, 0555)) {
+	if (mkdir(vg_path, 0777)) {
 		log_sys_error("mkdir", vg_path);
 		return 0;
 	}
@@ -65,10 +65,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 (is_empty_dir(vg_path)) {
+		log_very_verbose("Removing directory %s", vg_path);
 		rmdir(vg_path);
+	}
 
 	return 1;
 }
@@ -202,9 +202,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;
 	}
 

lib/commands/toolcontext.c

@@ -33,7 +33,7 @@
 #include "display.h"
 #include "memlock.h"
 #include "str_list.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "lvmcache.h"
 
 #ifdef HAVE_LIBDL
@@ -519,8 +519,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 +537,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++;
 	}
@@ -827,7 +828,7 @@ struct cmd_context *create_toolcontext(struct arg *the_args)
 	if (*cmd->sys_dir && !create_dir(cmd->sys_dir))
 		goto error;
 
-	if (!(cmd->libmem = pool_create(4 * 1024))) {
+	if (!(cmd->libmem = pool_create("library", 4 * 1024))) {
 		log_error("Library memory pool creation failed");
 		return 0;
 	}
@@ -858,7 +859,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 = pool_create("command", 4 * 1024))) {
 		log_error("Command memory pool creation failed");
 		return 0;
 	}

lib/config/config.c

@@ -99,7 +99,7 @@ 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 pool *mem = pool_create("config", 10 * 1024);
 
 	if (!mem) {
 		stack;

lib/config/defaults.h

@@ -96,9 +96,9 @@
 #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_LVS_COLS_VERB "lv_name,vg_name,seg_count,lv_attr,lv_size,lv_major,lv_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,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,pv_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_LVS_SORT "vg_name,lv_name"

lib/device/dev-cache.c

@@ -82,6 +82,7 @@ struct device *dev_create_file(const char *filename, struct device *dev,
 	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 +102,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);
@@ -387,7 +389,7 @@ int dev_cache_init(void)
 {
 	_cache.names = NULL;
 
-	if (!(_cache.mem = pool_create(10 * 1024))) {
+	if (!(_cache.mem = pool_create("dev_cache", 10 * 1024))) {
 		stack;
 		return 0;
 	}

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;
 }
 
@@ -212,12 +226,11 @@ static int _aligned_io(struct device_area *where, void *buffer,
  * Public functions
  *---------------------------------------------------------------*/
 
-int dev_get_size(struct device *dev, uint64_t *size)
+int dev_get_size(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 +238,27 @@ int dev_get_size(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;
 }
 
+/* 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 +272,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)
 {
@@ -274,8 +296,20 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 	const char *name;
 
 	if (dev->fd >= 0) {
-		dev->open_count++;
-		return 1;
+		if ((dev->flags & DEV_OPENED_RW) ||
+		    ((flags & O_ACCMODE) != O_RDWR)) {
+			dev->open_count++;
+			return 1;
+		}
+
+		if (dev->open_count) {
+			/* 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())
@@ -300,19 +334,29 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 		flags |= O_DIRECT;
 #endif
 
+#ifdef O_NOATIME
+	/* Don't update atime on device inodes */
+	if (!(dev->flags & DEV_REGULAR))
+		flags |= O_NOATIME;
+#endif
+
 	if ((dev->fd = open(name, flags, 0777)) < 0) {
 		log_sys_error("open", name);
 		return 0;
 	}
 
-	dev->open_count = 1;
+	dev->open_count++;
 	dev->flags &= ~DEV_ACCESSED_W;
+	if ((flags & O_ACCMODE) == O_RDWR)
+		dev->flags |= DEV_OPENED_RW;
+	else
+		dev->flags &= ~DEV_OPENED_RW;
 
 	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;
 	}
 
@@ -321,12 +365,13 @@ 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", dev_name(dev),
+		  dev->flags & DEV_OPENED_RW ? "RW" : "RO");
 
 	return 1;
 }
@@ -354,6 +399,7 @@ 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));
@@ -379,8 +425,11 @@ static int _dev_close(struct device *dev, int immediate)
 		dev_flush(dev);
 #endif
 
+	if (dev->open_count > 0)
+		dev->open_count--;
+
 	/* FIXME lookup device in cache to get vgname and see if it's locked? */
-	if (--dev->open_count < 1 && (immediate || !vgs_locked()))
+	if (immediate || (dev->open_count < 1 && !vgs_locked()))
 		_close(dev);
 
 	return 1;
@@ -412,8 +461,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;
@@ -431,8 +482,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;
@@ -447,8 +500,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;
@@ -495,6 +550,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)

lib/device/device.h

@@ -22,6 +22,7 @@
 #define DEV_ACCESSED_W		0x00000001	/* Device written to? */
 #define DEV_REGULAR		0x00000002	/* Regular file? */
 #define DEV_ALLOCED		0x00000004	/* dbg_malloc used */
+#define DEV_OPENED_RW		0x00000008	/* Opened RW */
 
 /*
  * All devices in LVM will be represented by one of these.
@@ -34,6 +35,7 @@ struct device {
 	/* private */
 	int fd;
 	int open_count;
+	int block_size;
 	uint32_t flags;
 	uint64_t end;
 	struct list open_list;
@@ -55,7 +57,7 @@ struct device_area {
 /*
  * All io should use these routines.
  */
-int dev_get_size(struct device *dev, uint64_t *size);
+int dev_get_size(const struct device *dev, uint64_t *size);
 int dev_get_sectsize(struct device *dev, uint32_t *size);
 
 /* Use quiet version if device number could change e.g. when opening LV */
@@ -89,15 +91,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

@@ -18,7 +18,7 @@
 #include "display.h"
 #include "activate.h"
 #include "toolcontext.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 #define SIZE_BUF 128
 
@@ -662,3 +662,22 @@ void vgdisplay_short(struct volume_group *vg)
 			       SIZE_SHORT));
 	return;
 }
+
+void display_formats(struct cmd_context *cmd)
+{
+	struct format_type *fmt;
+
+	list_iterate_items(fmt, &cmd->formats) {
+		log_print("%s", fmt->name);
+	}
+}
+
+void display_segtypes(struct cmd_context *cmd)
+{
+	struct segment_type *segtype;
+
+	list_iterate_items(segtype, &cmd->segtypes) {
+		log_print("%s", segtype->name);
+	}
+}
+

lib/display/display.h

@@ -45,6 +45,9 @@ void vgdisplay_full(struct volume_group *vg);
 void vgdisplay_colons(struct volume_group *vg);
 void vgdisplay_short(struct volume_group *vg);
 
+void display_formats(struct cmd_context *cmd);
+void display_segtypes(struct cmd_context *cmd);
+
 /*
  * Allocation policy display conversion routines.
  */

lib/error/errseg.c

@@ -16,7 +16,7 @@
 #include "pool.h"
 #include "list.h"
 #include "toolcontext.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "display.h"
 #include "text_export.h"
 #include "text_import.h"
@@ -97,5 +97,7 @@ struct segment_type *init_error_segtype(struct cmd_context *cmd)
 	segtype->private = NULL;
 	segtype->flags = SEG_CAN_SPLIT | SEG_VIRTUAL;
 
+	log_very_verbose("Initialised segtype: %s", segtype->name);
+
 	return segtype;
 }

lib/filters/filter-md.c

@@ -28,42 +28,24 @@
 
 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;
 }
 

lib/filters/filter-persistent.c

@@ -212,13 +212,10 @@ static int _lookup_p(struct dev_filter *f, struct device *dev)
 			sl = list_item(ah, struct str_list);
 			hash_insert(pf->devices, sl->str, l);
 		}
-	}
+	} else if (l == PF_BAD_DEVICE)
+			log_debug("%s: Skipping (cached)", dev_name(dev));
 
-	if (l == PF_BAD_DEVICE) {
-		log_debug("%s: Skipping (cached)", dev_name(dev));
-		return 0;
-	} else
-		return 1;
+	return (l == PF_BAD_DEVICE) ? 0 : 1;
 }
 
 static void _destroy(struct dev_filter *f)

lib/filters/filter-regex.c

@@ -101,7 +101,7 @@ static int _build_matcher(struct rfilter *rf, struct config_value *val)
 	unsigned count = 0;
 	int i, r = 0;
 
-	if (!(scratch = pool_create(1024))) {
+	if (!(scratch = pool_create("filter matcher", 1024))) {
 		stack;
 		return 0;
 	}
@@ -186,6 +186,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.
@@ -201,7 +204,7 @@ static void _destroy(struct dev_filter *f)
 
 struct dev_filter *regex_filter_create(struct config_value *patterns)
 {
-	struct pool *mem = pool_create(10 * 1024);
+	struct pool *mem = pool_create("filter regex", 10 * 1024);
 	struct rfilter *rf;
 	struct dev_filter *f;
 

lib/filters/filter-sysfs.c

@@ -169,6 +169,8 @@ static int _read_devs(struct dev_set *ds, const char *dir)
 {
         struct dirent *d;
         DIR *dr;
+	unsigned char dtype;
+	struct stat info;
 	char path[PATH_MAX];
 	dev_t dev;
 	int r = 1;
@@ -189,19 +191,31 @@ static int _read_devs(struct dev_set *ds, const char *dir)
 			continue;
 		}
 
-		if (d->d_type == DT_DIR) {
+		dtype = d->d_type;
+
+		if (dtype == DT_UNKNOWN) {
+			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;
+			}
+		}
+
+		if (dtype == DT_DIR) {
 			if (!_read_devs(ds, path)) {
 				r = 0;
 				break;
 			}
 		}
 
-		if ((d->d_type == DT_REG && !strcmp(d->d_name, "dev")))
+		if ((dtype == DT_REG && !strcmp(d->d_name, "dev")))
 			if (!_read_dev(path, &dev) || !_set_insert(ds, dev)) {
 				r = 0;
 				break;
 			}
-
 	}
 
         if (closedir(dr))
@@ -234,7 +248,11 @@ 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)
@@ -253,7 +271,7 @@ struct dev_filter *sysfs_filter_create(const char *proc)
 	if (!_locate_sysfs_blocks(proc, sys_block, sizeof(sys_block)))
 		return NULL;
 
-	if (!(mem = pool_create(256))) {
+	if (!(mem = pool_create("sysfs", 256))) {
 		log_error("sysfs pool creation failed");
 		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,10 @@
 
 #define NUMBER_OF_MAJORS 4096
 
+/* FIXME Make this sparse */
+/* 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 +44,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,37 +65,59 @@ 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 */
 	{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, 0)) {
+		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];
@@ -93,36 +127,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')
@@ -157,13 +186,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 */
@@ -171,7 +200,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;
@@ -180,24 +209,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,
@@ -212,8 +246,9 @@ struct dev_filter *lvm_type_filter_create(const char *proc,
 
 	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;
 	}
@@ -223,7 +258,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);
 	return;
 }

lib/filters/filter.h

@@ -37,4 +37,6 @@ void lvm_type_filter_destroy(struct dev_filter *f);
 
 int md_major(void);
 
+int max_partitions(int major);
+
 #endif

lib/format1/Makefile.in

@@ -29,8 +29,6 @@ LIB_SHARED = liblvm2format1.so
 
 include $(top_srcdir)/make.tmpl
 
-.PHONY: install
-
 install: liblvm2format1.so
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
 		$(libdir)/liblvm2format1.so.$(LIB_VERSION)

lib/format1/format1.c

@@ -24,6 +24,7 @@
 #include "lvmcache.h"
 #include "lvm1-label.h"
 #include "format1.h"
+#include "segtype.h"
 
 #define FMT_LVM1_NAME "lvm1"
 
@@ -182,7 +183,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 pool *mem = pool_create("lvm1 vg_read", 1024 * 10);
 	struct list pvs;
 	struct volume_group *vg = NULL;
 	list_init(&pvs);
@@ -275,7 +276,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 pool *mem = pool_create("lvm1 vg_write", 1024 * 10);
 	struct list pvds;
 	int r = 0;
 
@@ -298,7 +299,7 @@ static int _vg_write(struct format_instance *fid, struct volume_group *vg,
 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 pool *mem = pool_create("lvm1 pv_read", 1024);
 	struct disk_list *dl;
 	struct device *dev;
 	int r = 0;
@@ -420,7 +421,7 @@ 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 = pool_create("lvm1 pv_write", 1024))) {
 		stack;
 		return 0;
 	}
@@ -492,6 +493,17 @@ static int _vg_setup(struct format_instance *fid, struct volume_group *vg)
 	return 1;
 }
 
+static int _segtype_supported (struct format_instance *fid, 
+			       struct segment_type *segtype)
+{
+	if (!(segtype->flags & SEG_FORMAT1_SUPPORT)) {
+		stack;
+		return 0;
+	}
+
+	return 1;
+}
+
 static struct metadata_area_ops _metadata_format1_ops = {
 	vg_read:_vg_read,
 	vg_write:_vg_write,
@@ -542,6 +554,7 @@ static struct format_handler _format1_ops = {
 	pv_write:_pv_write,
 	lv_setup:_lv_setup,
 	vg_setup:_vg_setup,
+	segtype_supported:_segtype_supported,
 	create_instance:_create_instance,
 	destroy_instance:_destroy_instance,
 	destroy:_destroy,
@@ -578,5 +591,7 @@ struct format_type *init_format(struct cmd_context *cmd)
 		return NULL;
 	}
 
+	log_very_verbose("Initialised format: %s", fmt->name);
+
 	return fmt;
 }

lib/format1/import-export.c

@@ -25,7 +25,7 @@
 #include "lvm-string.h"
 #include "filter.h"
 #include "toolcontext.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 #include <time.h>
 

lib/format1/import-extents.c

@@ -20,7 +20,7 @@
 #include "disk-rep.h"
 #include "lv_alloc.h"
 #include "display.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 /*
  * After much thought I have decided it is easier,
@@ -344,7 +344,7 @@ 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 pool *scratch = pool_create("lvm1 import_extents", 10 * 1024);
 	struct hash_table *maps;
 
 	if (!scratch) {

lib/format1/vg_number.c

@@ -30,7 +30,7 @@ int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 	struct list *pvh;
 	struct list all_pvs;
 	struct disk_list *dl;
-	struct pool *mem = pool_create(10 * 1024);
+	struct pool *mem = pool_create("lvm1 vg_number", 10 * 1024);
 	int numbers[MAX_VG], i, r = 0;
 
 	list_init(&all_pvs);

lib/format_pool/Makefile.in

@@ -26,8 +26,6 @@ LIB_SHARED = liblvm2formatpool.so
 
 include $(top_srcdir)/make.tmpl
 
-.PHONY: install
-
 install: liblvm2formatpool.so
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
 		$(libdir)/liblvm2formatpool.so.$(LIB_VERSION)

lib/format_pool/disk_rep.c

@@ -259,7 +259,7 @@ 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 = pool_create("pool read_vg", 512))) {
 		stack;
 		return 0;
 	}

lib/format_pool/format_pool.c

@@ -181,7 +181,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 pool *mem = pool_create("pool vg_read", 1024);
 	struct list pds;
 	struct volume_group *vg = NULL;
 
@@ -227,7 +227,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 pool *mem = pool_create("pool pv_read", 1024);
 	struct pool_list *pl;
 	struct device *dev;
 	int r = 0;
@@ -357,5 +357,7 @@ struct format_type *init_format(struct cmd_context *cmd)
 		return NULL;
 	}
 
+	log_very_verbose("Initialised format: %s", fmt->name);
+
 	return fmt;
 }

lib/format_pool/import_export.c

@@ -22,7 +22,7 @@
 #include "lv_alloc.h"
 #include "str_list.h"
 #include "display.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 /* This file contains only imports at the moment... */
 
@@ -146,7 +146,7 @@ int import_pool_pvs(const struct format_type *fmt, struct volume_group *vg,
 		}
 		pl->pv = pvl->pv;
 		pvl->mdas = NULL;
-		pvl->alloc_areas = NULL;
+		pvl->pe_ranges = NULL;
 		list_add(pvs, &pvl->list);
 	}
 

lib/format_text/export.c

@@ -20,7 +20,7 @@
 #include "pool.h"
 #include "display.h"
 #include "lvm-string.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "text_export.h"
 
 #include <stdarg.h>
@@ -652,7 +652,7 @@ static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 	struct physical_volume *pv;
 	char buffer[32], *name;
 
-	if (!(f->mem = pool_create(512))) {
+	if (!(f->mem = pool_create("text pv_names", 512))) {
 		stack;
 		goto bad;
 	}

lib/format_text/format-text.c

@@ -1682,14 +1682,15 @@ struct format_type *create_text_format(struct cmd_context *cmd)
 		}
 	}
 
-	if (!(cn = find_config_node(cmd->cft->root, "metadata/disk_areas")))
-		return fmt;
-
-	for (cn = cn->child; cn; cn = cn->sib) {
-		if (!_get_config_disk_area(cmd, cn, &mda_lists->raws))
-			goto err;
+	if ((cn = find_config_node(cmd->cft->root, "metadata/disk_areas"))) {
+		for (cn = cn->child; cn; cn = cn->sib) {
+			if (!_get_config_disk_area(cmd, cn, &mda_lists->raws))
+				goto err;
+		}
 	}
 
+	log_very_verbose("Initialised format: %s", fmt->name);
+
 	return fmt;
 
       err:

lib/format_text/import_vsn1.c

@@ -22,7 +22,7 @@
 #include "toolcontext.h"
 #include "lvmcache.h"
 #include "lv_alloc.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "text_import.h"
 
 typedef int (*section_fn) (struct format_instance * fid, struct pool * mem,

lib/locking/Makefile.in

@@ -22,9 +22,7 @@ LIB_SHARED = liblvm2clusterlock.so
 
 include $(top_srcdir)/make.tmpl
 
-.PHONY: install
-
-install: liblvm2clusterlock.so
+install install_cluster: liblvm2clusterlock.so
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
 		$(libdir)/liblvm2clusterlock.so.$(LIB_VERSION)
 	$(LN_S) -f liblvm2clusterlock.so.$(LIB_VERSION) \

lib/log/log.c

@@ -28,6 +28,7 @@ static struct str_list _log_dev_alias;
 static int _verbose_level = VERBOSE_BASE_LEVEL;
 static int _test = 0;
 static int _partial = 0;
+static int _md_filtering = 0;
 static int _pvmove = 0;
 static int _debug_level = 0;
 static int _syslog = 0;
@@ -138,6 +139,11 @@ void init_partial(int level)
 	_partial = level;
 }
 
+void init_md_filtering(int level)
+{
+	_md_filtering = level;
+}
+
 void init_pvmove(int level)
 {
 	_pvmove = level;
@@ -187,6 +193,11 @@ int partial_mode()
 	return _partial;
 }
 
+int md_filtering()
+{
+	return _md_filtering;
+}
+
 int pvmove_mode()
 {
 	return _pvmove;
@@ -215,7 +226,7 @@ int debug_level()
 void print_log(int level, const char *file, int line, const char *format, ...)
 {
 	va_list ap;
-	char buf[1024], buf2[4096];
+	char buf[1024], buf2[4096], locn[4096];
 	int bufused, n;
 	const char *message;
 	const char *trformat;		/* Translated format string */
@@ -243,36 +254,46 @@ void print_log(int level, const char *file, int line, const char *format, ...)
 
       log_it:
 	if (!_log_suppress) {
+		if (_verbose_level > _LOG_DEBUG)
+			lvm_snprintf(locn, sizeof(locn), "#%s:%d ",
+				     file, line);
+		else
+			locn[0] = '\0';
+
 		va_start(ap, format);
 		switch (level) {
 		case _LOG_DEBUG:
-			if (!strcmp("<backtrace>", format))
+			if (!strcmp("<backtrace>", format) &&
+			    _verbose_level <= _LOG_DEBUG)
 				break;
 			if (_verbose_level >= _LOG_DEBUG) {
-				printf("%s%s", _cmd_name, _msg_prefix);
+				fprintf(stderr, "%s%s%s", locn, _cmd_name,
+					_msg_prefix);
 				if (_indent)
-					printf("      ");
-				vprintf(trformat, ap);
-				putchar('\n');
+					fprintf(stderr, "      ");
+				vfprintf(stderr, trformat, ap);
+				fputc('\n', stderr);
 			}
 			break;
 
 		case _LOG_INFO:
 			if (_verbose_level >= _LOG_INFO) {
-				printf("%s%s", _cmd_name, _msg_prefix);
+				fprintf(stderr, "%s%s%s", locn, _cmd_name,
+					_msg_prefix);
 				if (_indent)
-					printf("    ");
-				vprintf(trformat, ap);
-				putchar('\n');
+					fprintf(stderr, "    ");
+				vfprintf(stderr, trformat, ap);
+				fputc('\n', stderr);
 			}
 			break;
 		case _LOG_NOTICE:
 			if (_verbose_level >= _LOG_NOTICE) {
-				printf("%s%s", _cmd_name, _msg_prefix);
+				fprintf(stderr, "%s%s%s", locn, _cmd_name,
+					_msg_prefix);
 				if (_indent)
-					printf("  ");
-				vprintf(trformat, ap);
-				putchar('\n');
+					fprintf(stderr, "  ");
+				vfprintf(stderr, trformat, ap);
+				fputc('\n', stderr);
 			}
 			break;
 		case _LOG_WARN:
@@ -284,7 +305,8 @@ void print_log(int level, const char *file, int line, const char *format, ...)
 			break;
 		case _LOG_ERR:
 			if (_verbose_level >= _LOG_ERR) {
-				fprintf(stderr, "%s%s", _cmd_name, _msg_prefix);
+				fprintf(stderr, "%s%s%s", locn, _cmd_name,
+					_msg_prefix);
 				vfprintf(stderr, trformat, ap);
 				fputc('\n', stderr);
 			}
@@ -292,7 +314,8 @@ void print_log(int level, const char *file, int line, const char *format, ...)
 		case _LOG_FATAL:
 		default:
 			if (_verbose_level >= _LOG_FATAL) {
-				fprintf(stderr, "%s%s", _cmd_name, _msg_prefix);
+				fprintf(stderr, "%s%s%s", locn, _cmd_name,
+					_msg_prefix);
 				vfprintf(stderr, trformat, ap);
 				fputc('\n', stderr);
 			}

lib/log/log.h

@@ -63,6 +63,7 @@ void fin_syslog(void);
 void init_verbose(int level);
 void init_test(int level);
 void init_partial(int level);
+void init_md_filtering(int level);
 void init_pvmove(int level);
 void init_debug(int level);
 void init_cmd_name(int status);
@@ -75,6 +76,7 @@ void set_cmd_name(const char *cmd_name);
 
 int test_mode(void);
 int partial_mode(void);
+int md_filtering(void);
 int pvmove_mode(void);
 int debug_level(void);
 int ignorelockingfailure(void);

lib/metadata/lv_manip.c

@@ -21,7 +21,7 @@
 #include "toolcontext.h"
 #include "lv_alloc.h"
 #include "display.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 /*
  * These functions adjust the pe counts in pv's
@@ -458,7 +458,7 @@ static int _allocate(struct volume_group *vg, struct logical_volume *lv,
 	if (segtype->flags & SEG_VIRTUAL)
 		return _alloc_virtual(lv, allocated, segtype);
 
-	if (!(scratch = pool_create(1024))) {
+	if (!(scratch = pool_create("allocation", 1024))) {
 		stack;
 		return 0;
 	}
@@ -623,6 +623,16 @@ int lv_extend(struct format_instance *fid,
 	lv->le_count += extents;
 	lv->size += (uint64_t) extents *lv->vg->extent_size;
 
+	if (fid->fmt->ops->segtype_supported &&
+	    !fid->fmt->ops->segtype_supported(fid, segtype)) {
+		log_error("Metadata format (%s) does not support required "
+			  "LV segment type (%s).", fid->fmt->name,
+			  segtype->name);
+		log_error("Consider changing the metadata format by running "
+			  "vgconvert.");
+		return 0;
+	}
+
 	if (!_allocate(lv->vg, lv, allocatable_pvs, old_le_count, alloc,
 		       segtype, stripes, stripe_size, mirrors, mirrored_pv,
 		       mirrored_pe, status)) {

lib/metadata/merge.c

@@ -18,7 +18,7 @@
 #include "toolcontext.h"
 #include "lv_alloc.h"
 #include "str_list.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 /*
  * Attempt to merge two adjacent segments.
@@ -39,6 +39,9 @@ int lv_merge_segments(struct logical_volume *lv)
 	struct list *segh, *t;
 	struct lv_segment *current, *prev = NULL;
 
+	if (lv->status & LOCKED || lv->status & PVMOVE)
+		return 1;
+
 	list_iterate_safe(segh, t, &lv->segments) {
 		current = list_item(segh, struct lv_segment);
 
@@ -77,6 +80,7 @@ int lv_check_segments(struct logical_volume *lv)
 
 /*
  * Split the supplied segment at the supplied logical extent
+ * NB Use LE numbering that works across stripes PV1: 0,2,4 PV2: 1,3,5 etc.
  */
 static int _lv_split_segment(struct logical_volume *lv, struct lv_segment *seg,
 			     uint32_t le)
@@ -85,6 +89,7 @@ static int _lv_split_segment(struct logical_volume *lv, struct lv_segment *seg,
 	struct lv_segment *split_seg;
 	uint32_t s;
 	uint32_t offset = le - seg->le;
+	uint32_t area_offset;
 
 	if (!(seg->segtype->flags & SEG_CAN_SPLIT)) {
 		log_error("Unable to split the %s segment at LE %" PRIu32
@@ -107,8 +112,9 @@ static int _lv_split_segment(struct logical_volume *lv, struct lv_segment *seg,
 	}
 
 	/* In case of a striped segment, the offset has to be / stripes */
+	area_offset = offset;
 	if (seg->segtype->flags & SEG_AREAS_STRIPED)
-		offset /= seg->area_count;
+		area_offset /= seg->area_count;
 
 	/* Adjust the PV mapping */
 	for (s = 0; s < seg->area_count; s++) {
@@ -116,12 +122,19 @@ static int _lv_split_segment(struct logical_volume *lv, struct lv_segment *seg,
 		switch (seg->area[s].type) {
 		case AREA_LV:
 			split_seg->area[s].u.lv.le =
-			    seg->area[s].u.lv.le + offset;
+			    seg->area[s].u.lv.le + area_offset;
+			log_debug("Split %s:%u[%u] at %u: %s LE %u", lv->name,
+				  seg->le, s, le, seg->area[s].u.lv.lv->name,
+				  split_seg->area[s].u.lv.le);
 			break;
 
 		case AREA_PV:
 			split_seg->area[s].u.pv.pe =
-			    seg->area[s].u.pv.pe + offset;
+			    seg->area[s].u.pv.pe + area_offset;
+			log_debug("Split %s:%u[%u] at %u: %s PE %u", lv->name,
+				  seg->le, s, le,
+				  dev_name(seg->area[s].u.pv.pv->dev),
+				  split_seg->area[s].u.pv.pe);
 			break;
 
 		default:
@@ -131,8 +144,13 @@ static int _lv_split_segment(struct logical_volume *lv, struct lv_segment *seg,
 		}
 	}
 
-	split_seg->area_len = seg->area_len - offset;
-	seg->area_len = offset;
+	split_seg->area_len -= area_offset;
+	seg->area_len = area_offset;
+
+	split_seg->len -= offset;
+	seg->len = offset;
+
+	split_seg->le = seg->le + seg->len;
 
 	/* Add split off segment to the list _after_ the original one */
 	list_add_h(&seg->list, &split_seg->list);

lib/metadata/metadata.h

@@ -265,7 +265,7 @@ struct name_list {
 	char *name;
 };
 
-struct alloc_area {
+struct pe_range {
 	struct list list;
 	uint32_t start;		/* PEs */
 	uint32_t count;		/* PEs */
@@ -275,7 +275,7 @@ struct pv_list {
 	struct list list;
 	struct physical_volume *pv;
 	struct list *mdas;	/* Metadata areas */
-	struct list *alloc_areas;	/* Areas we may allocate from */
+	struct list *pe_ranges;	/* Ranges of PEs e.g. for allocation */
 };
 
 struct lv_list {
@@ -341,6 +341,12 @@ struct format_handler {
 	 */
 	int (*vg_setup) (struct format_instance * fi, struct volume_group * vg);
 
+	/*
+	 * Check whether particular segment type is supported.
+	 */
+	int (*segtype_supported) (struct format_instance *fid,
+				  struct segment_type *segtype);
+
 	/*
 	 * Create format instance with a particular metadata area
 	 */
@@ -501,7 +507,7 @@ int vg_remove_snapshot(struct volume_group *vg, struct logical_volume *cow);
  */
 int insert_pvmove_mirrors(struct cmd_context *cmd,
 			  struct logical_volume *lv_mirr,
-			  struct physical_volume *pv,
+			  struct list *source_pvl,
 			  struct logical_volume *lv,
 			  struct list *allocatable_pvs,
 			  struct list *lvs_changed);

lib/metadata/mirror.c

@@ -16,7 +16,7 @@
 #include "lib.h"
 #include "metadata.h"
 #include "toolcontext.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "display.h"
 #include "activate.h"
 
@@ -26,7 +26,7 @@
  */
 int insert_pvmove_mirrors(struct cmd_context *cmd,
 			  struct logical_volume *lv_mirr,
-			  struct physical_volume *pv,
+			  struct list *source_pvl,
 			  struct logical_volume *lv,
 			  struct list *allocatable_pvs,
 			  struct list *lvs_changed)
@@ -34,9 +34,15 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
 	struct list *segh;
 	struct lv_segment *seg;
 	struct lv_list *lvl;
+	struct pv_list *pvl;
 	int lv_used = 0;
 	uint32_t s, start_le, extent_count = 0u;
 	struct segment_type *segtype;
+	struct pe_range *per;
+	uint32_t pe_start, pe_end, per_end, stripe_multiplier;
+
+	/* Only 1 PV may feature in source_pvl */
+	pvl = list_item(source_pvl->n, struct pv_list);
 
 	if (!(segtype = get_segtype_from_string(lv->vg->cmd, "mirror"))) {
 		stack;
@@ -50,43 +56,113 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
                 return 0;
         }
 
+	/* Split LV segments to match PE ranges */
+	list_iterate(segh, &lv->segments) {
+		seg = list_item(segh, struct lv_segment);
+		for (s = 0; s < seg->area_count; s++) {
+			if (seg->area[s].type != AREA_PV ||
+			    seg->area[s].u.pv.pv->dev != pvl->pv->dev)
+				continue;
+
+			/* Do these PEs need moving? */
+			list_iterate_items(per, pvl->pe_ranges) {
+				pe_start = seg->area[s].u.pv.pe;
+				pe_end = pe_start + seg->area_len - 1;
+				per_end = per->start + per->count - 1;
+
+				/* No overlap? */
+				if ((pe_end < per->start) ||
+				    (pe_start > per_end))
+					continue;
+
+				if (seg->segtype->flags & SEG_AREAS_STRIPED)
+					stripe_multiplier = seg->area_count;
+				else
+					stripe_multiplier = 1;
+
+				if ((per->start != pe_start &&
+				     per->start > pe_start) &&
+				    !lv_split_segment(lv, seg->le +
+						      (per->start - pe_start) *
+						      stripe_multiplier)) {
+					stack;
+					return 0;
+				}
+
+				if ((per_end != pe_end &&
+				     per_end < pe_end) &&
+				    !lv_split_segment(lv, seg->le +
+						      (per_end - pe_start + 1) *
+						      stripe_multiplier)) {
+					stack;
+					return 0;
+				}
+			}
+		}
+	}
+
 	/* Work through all segments on the supplied PV */
 	list_iterate(segh, &lv->segments) {
 		seg = list_item(segh, struct lv_segment);
 		for (s = 0; s < seg->area_count; s++) {
 			if (seg->area[s].type != AREA_PV ||
-			    seg->area[s].u.pv.pv->dev != pv->dev)
+			    seg->area[s].u.pv.pv->dev != pvl->pv->dev)
 				continue;
 
-			/* First time, add LV to list of LVs affected */
-			if (!lv_used) {
-				if (!(lvl = pool_alloc(cmd->mem, sizeof(*lvl)))) {
-					log_error("lv_list alloc failed");
+			pe_start = seg->area[s].u.pv.pe;
+
+			/* Do these PEs need moving? */
+			list_iterate_items(per, pvl->pe_ranges) {
+				per_end = per->start + per->count - 1;
+
+				if ((pe_start < per->start) ||
+				    (pe_start > per_end))
+					continue;
+
+				log_debug("Matched PE range %u-%u against "
+					  "%s %u len %u", per->start, per_end,
+					  dev_name(seg->area[s].u.pv.pv->dev),
+					  seg->area[s].u.pv.pe, seg->area_len);
+
+				/* First time, add LV to list of LVs affected */
+				if (!lv_used) {
+					if (!(lvl = pool_alloc(cmd->mem, sizeof(*lvl)))) {
+						log_error("lv_list alloc failed");
+						return 0;
+					}
+					lvl->lv = lv;
+					list_add(lvs_changed, &lvl->list);
+					lv_used = 1;
+				}
+	
+				log_very_verbose("Moving %s:%u-%u of %s/%s",
+						 dev_name(pvl->pv->dev),
+						 seg->area[s].u.pv.pe,
+						 seg->area[s].u.pv.pe +
+						     seg->area_len - 1,
+						 lv->vg->name, lv->name);
+
+				start_le = lv_mirr->le_count;
+				if (!lv_extend(lv->vg->fid, lv_mirr, segtype, 1,
+				       	seg->area_len, 0u, seg->area_len,
+				       	seg->area[s].u.pv.pv,
+				       	seg->area[s].u.pv.pe,
+				       	PVMOVE, allocatable_pvs,
+				       	lv->alloc)) {
+					log_error("Unable to allocate "
+						  "temporary LV for pvmove.");
 					return 0;
 				}
-				lvl->lv = lv;
-				list_add(lvs_changed, &lvl->list);
-				lv_used = 1;
+				seg->area[s].type = AREA_LV;
+				seg->area[s].u.lv.lv = lv_mirr;
+				seg->area[s].u.lv.le = start_le;
+	
+				extent_count += seg->area_len;
+	
+				lv->status |= LOCKED;
+
+				break;
 			}
-
-			start_le = lv_mirr->le_count;
-			if (!lv_extend(lv->vg->fid, lv_mirr, segtype, 1,
-				       seg->area_len, 0u, seg->area_len,
-				       seg->area[s].u.pv.pv,
-				       seg->area[s].u.pv.pe,
-				       PVMOVE, allocatable_pvs,
-				       lv->alloc)) {
-				log_error("Allocation for temporary "
-					  "pvmove LV failed");
-				return 0;
-			}
-			seg->area[s].type = AREA_LV;
-			seg->area[s].u.lv.lv = lv_mirr;
-			seg->area[s].u.lv.le = start_le;
-
-			extent_count += seg->area_len;
-
-			lv->status |= LOCKED;
 		}
 	}
 
@@ -167,8 +243,12 @@ int remove_pvmove_mirrors(struct volume_group *vg,
 				lv1->status &= ~LOCKED;
 			}
 		}
+		if (!lv_merge_segments(lv1))
+			stack;
+
 	}
 
+
 	return 1;
 }
 

lib/metadata/pv_map.c

@@ -206,13 +206,13 @@ static int _create_areas(struct pool *mem, struct pv_map *pvm, uint32_t start,
 static int _create_allocatable_areas(struct pool *mem, struct pv_map *pvm)
 {
 	struct list *alloc_areas, *aah;
-	struct alloc_area *aa;
+	struct pe_range *aa;
 
-	alloc_areas = pvm->pvl->alloc_areas;
+	alloc_areas = pvm->pvl->pe_ranges;
 
 	if (alloc_areas) {
 		list_iterate(aah, alloc_areas) {
-			aa = list_item(aah, struct alloc_area);
+			aa = list_item(aah, struct pe_range);
 			if (!_create_areas(mem, pvm, aa->start, aa->count)) {
 				stack;
 				return 0;

lib/metadata/segtype.c

@@ -15,7 +15,7 @@
 
 #include "lib.h"
 #include "toolcontext.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 struct segment_type *get_segtype_from_string(struct cmd_context *cmd,
 					     const char *str)

lib/metadata/segtype.h

@@ -85,4 +85,8 @@ struct segment_type *init_snapshot_segtype(struct cmd_context *cmd);
 struct segment_type *init_mirrored_segtype(struct cmd_context *cmd);
 #endif
 
+#ifdef CRYPT_INTERNAL
+struct segment_type *init_crypt_segtype(struct cmd_context *cmd);
+#endif
+
 #endif

lib/mirror/Makefile.in

@@ -22,8 +22,6 @@ LIB_SHARED = liblvm2mirror.so
 
 include $(top_srcdir)/make.tmpl
 
-.PHONY: install
-
 install: liblvm2mirror.so
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
 		$(libdir)/liblvm2mirror.so.$(LIB_VERSION)

lib/mirror/mirrored.c

@@ -18,7 +18,7 @@
 #include "list.h"
 #include "toolcontext.h"
 #include "metadata.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "display.h"
 #include "text_export.h"
 #include "text_import.h"
@@ -95,7 +95,7 @@ static int _text_export(const struct lv_segment *seg, struct formatter *f)
 {
 	outf(f, "mirror_count = %u", seg->area_count);
 	if (seg->status & PVMOVE)
-		out_size(f, (uint64_t) seg->extents_copied,
+		out_size(f, (uint64_t) seg->extents_copied * seg->lv->vg->extent_size,
 			 "extents_moved = %u", seg->extents_copied);
 
 	return out_areas(f, seg, "mirror");
@@ -130,6 +130,7 @@ static int _compose_target_line(struct dev_manager *dm, struct pool *mem,
 	int mirror_status = MIRR_RUNNING;
 	int areas = seg->area_count;
 	int start_area = 0u;
+	uint32_t region_size, region_max;
 
 	if (!*target_state)
 		*target_state = _init_target(mem, cft);
@@ -143,7 +144,7 @@ static int _compose_target_line(struct dev_manager *dm, struct pool *mem,
 		if (seg->extents_copied == seg->area_len) {
 			mirror_status = MIRR_COMPLETED;
 			start_area = 1;
-		} else if (*pvmove_mirror_count++) {
+		} else if ((*pvmove_mirror_count)++) {
 			mirror_status = MIRR_DISABLED;
 			areas = 1;
 		}
@@ -153,8 +154,20 @@ static int _compose_target_line(struct dev_manager *dm, struct pool *mem,
 		*target = "linear";
 	} else {
 		*target = "mirror";
+
+		/* Find largest power of 2 region size unit we can use */
+		region_max = (1 << (ffs(seg->area_len) - 1)) *
+			      seg->lv->vg->extent_size;
+
+		region_size = mirr_state->region_size;
+		if (region_max < region_size) {
+			region_size = region_max;
+			log_verbose("Using reduced mirror region size of %u sectors",
+				    region_size);
+		}
+
 		if ((*pos = lvm_snprintf(params, paramsize, "core 1 %u %u ",
-					 mirr_state->region_size, areas)) < 0) {
+					 region_size, areas)) < 0) {
 			stack;
 			return -1;
 		}
@@ -162,7 +175,6 @@ static int _compose_target_line(struct dev_manager *dm, struct pool *mem,
 
 	return compose_areas_line(dm, seg, params, paramsize, pos, start_area,
 				  areas);
-
 }
 
 static int _target_percent(void **target_state, struct pool *mem,
@@ -188,8 +200,7 @@ static int _target_percent(void **target_state, struct pool *mem,
 	*total_denominator += denominator;
 
 	if (seg)
-		seg->extents_copied = mirr_state->region_size *
-		    numerator / seg->lv->vg->extent_size;
+		seg->extents_copied = seg->area_len * numerator / denominator;
 
 	return 1;
 }
@@ -247,5 +258,7 @@ struct segment_type *init_segtype(struct cmd_context *cmd)
 	segtype->private = NULL;
 	segtype->flags = SEG_AREAS_MIRRORED;
 
+	log_very_verbose("Initialised segtype: %s", segtype->name);
+
 	return segtype;
 }

lib/misc/lvm-string.c

@@ -16,6 +16,7 @@
 #include "lib.h"
 #include "lvm-types.h"
 #include "lvm-string.h"
+#include "pool.h"
 
 #include <ctype.h>
 
@@ -98,3 +99,109 @@ int split_words(char *buffer, unsigned max, char **argv)
 
 	return arg;
 }
+
+/*
+ * Device layer names are all of the form <vg>-<lv>-<layer>, any
+ * other hyphens that appear in these names are quoted with yet
+ * another hyphen.  The top layer of any device has no layer
+ * name.  eg, vg0-lvol0.
+ */
+static void _count_hyphens(const char *str, size_t *len, int *hyphens)
+{
+	const char *ptr;
+
+	for (ptr = str; *ptr; ptr++, (*len)++)
+		if (*ptr == '-')
+			(*hyphens)++;
+}
+
+/*
+ * Copies a string, quoting hyphens with hyphens.
+ */
+static void _quote_hyphens(char **out, const char *src)
+{
+	while (*src) {
+		if (*src == '-')
+			*(*out)++ = '-';
+
+		*(*out)++ = *src++;
+	}
+}
+
+/*
+ * <vg>-<lv>-<layer> or if !layer just <vg>-<lv>.
+ */
+char *build_dm_name(struct pool *mem, const char *vg,
+		    const char *lv, const char *layer)
+{
+	size_t len = 1;
+	int hyphens = 1;
+	char *r, *out;
+
+	_count_hyphens(vg, &len, &hyphens);
+	_count_hyphens(lv, &len, &hyphens);
+
+	if (layer && *layer) {
+		_count_hyphens(layer, &len, &hyphens);
+		hyphens++;
+	}
+
+	len += hyphens;
+
+	if (!(r = pool_alloc(mem, len))) {
+		stack;
+		return NULL;
+	}
+
+	out = r;
+	_quote_hyphens(&out, vg);
+	*out++ = '-';
+	_quote_hyphens(&out, lv);
+
+	if (layer && *layer) {
+		*out++ = '-';
+		_quote_hyphens(&out, layer);
+	}
+	*out = '\0';
+
+	return r;
+}
+
+/*
+ * Remove hyphen quoting from a component of a name.
+ * NULL-terminates the component and returns start of next component.
+ */
+static char *_unquote(char *component)
+{
+	char *c = component;
+	char *o = c;
+
+	while (*c) {
+		if (*(c + 1)) {
+			if (*c == '-') {
+				if (*(c + 1) == '-')
+					c++;
+				else
+					break;
+			}
+		}
+		*o = *c;
+		o++;
+		c++;
+	}
+
+	*o = '\0';
+	return (c + 1);
+}
+
+int split_dm_name(struct pool *mem, const char *dmname,
+		  char **vgname, char **lvname, char **layer)
+{
+	if (!(*vgname = pool_strdup(mem, dmname)))
+		return 0;
+
+	_unquote(*layer = _unquote(*lvname = _unquote(*vgname)));
+
+	return 1;
+}
+

lib/misc/lvm-string.h

@@ -19,6 +19,8 @@
 #include <stdio.h>
 #include <stdarg.h>
 
+struct pool;
+
 /*
  * On error, up to glibc 2.0.6, snprintf returned -1 if buffer was too small;
  * From glibc 2.1 it returns number of chars (excl. trailing null) that would 
@@ -32,4 +34,10 @@ int emit_to_buffer(char **buffer, size_t *size, const char *fmt, ...);
 
 int split_words(char *buffer, unsigned max, char **argv);
 
+char *build_dm_name(struct pool *mem, const char *vg,
+                    const char *lv, const char *layer);
+
+int split_dm_name(struct pool *mem, const char *dmname,
+                  char **vgname, char **lvname, char **layer);
+
 #endif

lib/mm/dbg_malloc.c

@@ -19,6 +19,8 @@
 
 #include <stdarg.h>
 
+#ifdef DEBUG_MEM
+
 struct memblock {
 	struct memblock *prev, *next;	/* All allocated blocks are linked */
 	size_t length;		/* Size of the requested block */
@@ -29,11 +31,13 @@ struct memblock {
 };
 
 static struct {
-	unsigned int blocks, mblocks;
+	unsigned block_serialno;/* Non-decreasing serialno of block */
+	unsigned blocks_allocated; /* Current number of blocks allocated */
+	unsigned blocks_max;	/* Max no of concurrently-allocated blocks */
 	unsigned int bytes, mbytes;
 
 } _mem_stats = {
-0, 0, 0, 0};
+0, 0, 0, 0, 0};
 
 static struct memblock *_head = 0;
 static struct memblock *_tail = 0;
@@ -45,7 +49,7 @@ void *malloc_aux(size_t s, const char *file, int line)
 
 	if (s > 50000000) {
 		log_error("Huge memory allocation (size %" PRIuPTR
-			  ") rejected - bug?", s);
+			  ") rejected - metadata corruption?", s);
 		return 0;
 	}
 
@@ -65,7 +69,7 @@ void *malloc_aux(size_t s, const char *file, int line)
 	/* setup fields */
 	nb->magic = nb + 1;
 	nb->length = s;
-	nb->id = ++_mem_stats.blocks;
+	nb->id = ++_mem_stats.block_serialno;
 	nb->next = 0;
 	nb->prev = _tail;
 
@@ -89,8 +93,9 @@ void *malloc_aux(size_t s, const char *file, int line)
 			*ptr++ = (char) nb->id;
 	}
 
-	if (_mem_stats.blocks > _mem_stats.mblocks)
-		_mem_stats.mblocks = _mem_stats.blocks;
+	_mem_stats.blocks_allocated++;
+	if (_mem_stats.blocks_allocated > _mem_stats.blocks_max)
+		_mem_stats.blocks_max = _mem_stats.blocks_allocated;
 
 	_mem_stats.bytes += s;
 	if (_mem_stats.bytes > _mem_stats.mbytes)
@@ -140,8 +145,8 @@ void free_aux(void *p)
 	else
 		_tail = mb->prev;
 
-	assert(_mem_stats.blocks);
-	_mem_stats.blocks--;
+	assert(_mem_stats.blocks_allocated);
+	_mem_stats.blocks_allocated--;
 	_mem_stats.bytes -= mb->length;
 
 	/* free the memory */
@@ -163,7 +168,6 @@ void *realloc_aux(void *p, unsigned int s, const char *file, int line)
 	return r;
 }
 
-#ifdef DEBUG_MEM
 int dump_memory(void)
 {
 	unsigned long tot = 0;
@@ -210,10 +214,18 @@ void bounds_check(void)
 		mb = mb->next;
 	}
 }
-#endif
 
-/*
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
+#else
+
+void *malloc_aux(size_t s, const char *file, int line)
+{
+	if (s > 50000000) {
+		log_error("Huge memory allocation (size %" PRIuPTR
+			  ") rejected - metadata corruption?", s);
+		return 0;
+	}
+
+	return malloc(s);
+}
+
+#endif

lib/mm/dbg_malloc.h

@@ -20,22 +20,26 @@
 #include <stdlib.h>
 #include <string.h>
 
-#ifdef DEBUG_MEM
 void *malloc_aux(size_t s, const char *file, int line);
+#  define dbg_malloc(s) malloc_aux((s), __FILE__, __LINE__)
+
+#ifdef DEBUG_MEM
+
 void free_aux(void *p);
 void *realloc_aux(void *p, unsigned int s, const char *file, int line);
 int dump_memory(void);
 void bounds_check(void);
 
-#  define dbg_malloc(s) malloc_aux((s), __FILE__, __LINE__)
 #  define dbg_free(p) free_aux(p)
 #  define dbg_realloc(p, s) realloc_aux(p, s, __FILE__, __LINE__)
+
 #else
-#  define dbg_malloc(s) malloc(s)
+
 #  define dbg_free(p) free(p)
 #  define dbg_realloc(p, s) realloc(p, s)
 #  define dump_memory()
 #  define bounds_check()
+
 #endif
 
 static inline char *dbg_strdup(const char *str)

lib/mm/pool-debug.c

@@ -22,38 +22,64 @@ struct block {
 	void *data;
 };
 
+typedef struct {
+	unsigned block_serialno;	/* Non-decreasing serialno of block */
+	unsigned blocks_allocated;	/* Current number of blocks allocated */
+	unsigned blocks_max;	/* Max no of concurrently-allocated blocks */
+	unsigned int bytes, maxbytes;
+} pool_stats;
+
 struct pool {
+	const char *name;
+
 	int begun;
 	struct block *object;
 
 	struct block *blocks;
 	struct block *tail;
+
+	pool_stats stats;
 };
 
 /* by default things come out aligned for doubles */
 #define DEFAULT_ALIGNMENT __alignof__ (double)
 
-struct pool *pool_create(size_t chunk_hint)
+struct pool *pool_create(const char *name, size_t chunk_hint)
 {
 	struct pool *mem = dbg_malloc(sizeof(*mem));
 
 	if (!mem) {
-		log_error("Couldn't create memory pool (size %" PRIsize_t ")",
-			  sizeof(*mem));
+		log_error("Couldn't create memory pool %s (size %"
+			  PRIsize_t ")", name, sizeof(*mem));
 		return NULL;
 	}
 
+	mem->name = name;
 	mem->begun = 0;
 	mem->object = 0;
 	mem->blocks = mem->tail = NULL;
+
+	mem->stats.block_serialno = 0;
+	mem->stats.blocks_allocated = 0;
+	mem->stats.blocks_max = 0;
+	mem->stats.bytes = 0;
+	mem->stats.maxbytes = 0;
+
+#ifdef DEBUG_POOL
+	log_debug("Created mempool %s", name);
+#endif
+
 	return mem;
 }
 
-static void _free_blocks(struct block *b)
+static void _free_blocks(struct pool *p, struct block *b)
 {
 	struct block *n;
 
 	while (b) {
+		p->stats.bytes -= b->size;
+		p->stats.blocks_allocated--;
+
 		n = b->next;
 		dbg_free(b->data);
 		dbg_free(b);
@@ -61,9 +87,22 @@ static void _free_blocks(struct block *b)
 	}
 }
 
+static void _pool_stats(struct pool *p, const char *action)
+{
+#ifdef DEBUG_POOL
+	log_debug("%s mempool %s: %u/%u bytes, %u/%u blocks, "
+		  "%u allocations)", action, p->name, p->stats.bytes,
+		  p->stats.maxbytes, p->stats.blocks_allocated,
+		  p->stats.blocks_max, p->stats.block_serialno);
+#else
+	;
+#endif
+}
+
 void pool_destroy(struct pool *p)
 {
-	_free_blocks(p->blocks);
+	_pool_stats(p, "Destroying");
+	_free_blocks(p, p->blocks);
 	dbg_free(p);
 }
 
@@ -79,11 +118,20 @@ static void _append_block(struct pool *p, struct block *b)
 		p->tail = b;
 	} else
 		p->blocks = p->tail = b;
+
+	p->stats.block_serialno++;
+	p->stats.blocks_allocated++;
+	if (p->stats.blocks_allocated > p->stats.blocks_max)
+		p->stats.blocks_max = p->stats.blocks_allocated;
+
+	p->stats.bytes += b->size;
+	if (p->stats.bytes > p->stats.maxbytes)
+		p->stats.maxbytes = p->stats.bytes;
 }
 
 static struct block *_new_block(size_t s, unsigned alignment)
 {
-	static char *_oom = "Out of memory";
+	static const char *_oom = "Out of memory";
 
 	/* FIXME: I'm currently ignoring the alignment arg. */
 	size_t len = sizeof(struct block) + s;
@@ -121,12 +169,14 @@ void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment)
 		return NULL;
 
 	_append_block(p, b);
+
 	return b->data;
 }
 
 void pool_empty(struct pool *p)
 {
-	_free_blocks(p->blocks);
+	_pool_stats(p, "Emptying");
+	_free_blocks(p, p->blocks);
 	p->blocks = p->tail = NULL;
 }
 
@@ -134,6 +184,8 @@ void pool_free(struct pool *p, void *ptr)
 {
 	struct block *b, *prev = NULL;
 
+	_pool_stats(p, "Freeing (before)");
+
 	for (b = p->blocks; b; b = b->next) {
 		if (b->data == ptr)
 			break;
@@ -147,13 +199,15 @@ void pool_free(struct pool *p, void *ptr)
 	 */
 	assert(b);
 
-	_free_blocks(b);
+	_free_blocks(p, b);
 
 	if (prev) {
 		p->tail = prev;
 		prev->next = NULL;
 	} else
 		p->blocks = p->tail = NULL;
+
+	_pool_stats(p, "Freeing (after)");
 }
 
 int pool_begin_object(struct pool *p, size_t init_size)
@@ -180,10 +234,13 @@ int pool_grow_object(struct pool *p, const void *buffer, size_t delta)
 
 	if (p->object) {
 		memcpy(new->data, p->object->data, p->object->size);
+		dbg_free(p->object->data);
 		dbg_free(p->object);
 	}
 	p->object = new;
 
+	memcpy(new->data + size - delta, buffer, delta);
+
 	return 1;
 }
 

lib/mm/pool-fast.c

@@ -36,14 +36,14 @@ struct chunk *_new_chunk(struct pool *p, size_t s);
 /* by default things come out aligned for doubles */
 #define DEFAULT_ALIGNMENT __alignof__ (double)
 
-struct pool *pool_create(size_t chunk_hint)
+struct pool *pool_create(const char *name, size_t chunk_hint)
 {
 	size_t new_size = 1024;
 	struct pool *p = dbg_malloc(sizeof(*p));
 
 	if (!p) {
-		log_error("Couldn't create memory pool (size %" PRIsize_t ")",
-			  sizeof(*p));
+		log_error("Couldn't create memory pool %s (size %"
+			  PRIsize_t ")", name, sizeof(*p));
 		return 0;
 	}
 	memset(p, 0, sizeof(*p));
@@ -109,8 +109,8 @@ void pool_empty(struct pool *p)
 	for (c = p->chunk; c && c->prev; c = c->prev)
 		;
 
-	if (p->chunk)
-		pool_free(p, (char *) (p->chunk + 1));
+	if (c)
+		pool_free(p, (char *) (c + 1));
 }
 
 void pool_free(struct pool *p, void *ptr)

lib/mm/pool.h

@@ -55,7 +55,7 @@
 struct pool;
 
 /* constructor and destructor */
-struct pool *pool_create(size_t chunk_hint);
+struct pool *pool_create(const char *name, size_t chunk_hint);
 void pool_destroy(struct pool *p);
 
 /* simple allocation/free routines */

lib/mm/xlate.h

@@ -17,6 +17,41 @@
 #define _LVM_XLATE_H
 
 #ifdef linux
+#  include <endian.h>
+#  include <byteswap.h>
+#else
+#  include <machine/endian.h>
+#  define bswap_16(x) (((x) & 0x00ffU) << 8 | \
+		       ((x) & 0xff00U) >> 8)
+#  define bswap_32(x) (((x) & 0x000000ffU) << 24 | \
+		       ((x) & 0xff000000U) >> 24 | \
+		       ((x) & 0x0000ff00U) << 8  | \
+		       ((x) & 0x00ff0000U) >> 8)
+#  define bswap_64(x) (((x) & 0x00000000000000ffU) << 56 | \
+		       ((x) & 0xff00000000000000U) >> 56 | \
+		       ((x) & 0x000000000000ff00U) << 40 | \
+		       ((x) & 0x00ff000000000000U) >> 40 | \
+		       ((x) & 0x0000000000ff0000U) << 24 | \
+		       ((x) & 0x0000ff0000000000U) >> 24 | \
+		       ((x) & 0x00000000ff000000U) << 8 | \
+		       ((x) & 0x000000ff00000000U) >> 8)
+#endif
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+#  define xlate16(x) (x)
+#  define xlate32(x) (x)
+#  define xlate64(x) (x)
+#  define xlate16_be(x) bswap_16(x)
+#  define xlate32_be(x) bswap_32(x)
+#  define xlate64_be(x) bswap_64(x)
+#elif BYTE_ORDER == BIG_ENDIAN
+#  define xlate16(x) bswap_16(x)
+#  define xlate32(x) bswap_32(x)
+#  define xlate64(x) bswap_64(x)
+#  define xlate16_be(x) (x)
+#  define xlate32_be(x) (x)
+#  define xlate64_be(x) (x)
+#else
 #  include <asm/byteorder.h>
 #  define xlate16(x) __cpu_to_le16((x))
 #  define xlate32(x) __cpu_to_le32((x))
@@ -24,41 +59,6 @@
 #  define xlate16_be(x) __cpu_to_be16((x))
 #  define xlate32_be(x) __cpu_to_be32((x))
 #  define xlate64_be(x) __cpu_to_be64((x))
-#else
-#  include <machine/endian.h>
-#  if !defined(BYTE_ORDER) || \
-      (BYTE_ORDER != BIG_ENDIAN && BYTE_ORDER != LITTLE_ENDIAN)
-#    error "Undefined or unrecognised BYTE_ORDER";
-#  endif
-#  define __xlate16(x) (((x) & 0x00ffU) << 8 | \
-			((x) & 0xff00U) >> 8)
-#  define __xlate32(x) (((x) & 0x000000ffU) << 24 | \
-			((x) & 0xff000000U) >> 24 | \
-			((x) & 0x0000ff00U) << 8  | \
-			((x) & 0x00ff0000U) >> 8)
-#  define __xlate64(x) (((x) & 0x00000000000000ffU) << 56 | \
-			((x) & 0xff00000000000000U) >> 56 | \
-			((x) & 0x000000000000ff00U) << 40 | \
-			((x) & 0x00ff000000000000U) >> 40 | \
-			((x) & 0x0000000000ff0000U) << 24 | \
-			((x) & 0x0000ff0000000000U) >> 24 | \
-			((x) & 0x00000000ff000000U) << 8 | \
-			((x) & 0x000000ff00000000U) >> 8)
-#  if BYTE_ORDER == LITTLE_ENDIAN
-#    define xlate16(x) (x)
-#    define xlate32(x) (x)
-#    define xlate64(x) (x)
-#    define xlate16_be(x) __xlate16(x)
-#    define xlate32_be(x) __xlate32(x)
-#    define xlate64_be(x) __xlate64(x)
-#  else
-#    define xlate16(x) __xlate16(x)
-#    define xlate32(x) __xlate32(x)
-#    define xlate64(x) __xlate64(x)
-#    define xlate16_be(x) (x)
-#    define xlate32_be(x) (x)
-#    define xlate64_be(x) (x)
-#  endif
 #endif
 
 #endif

lib/regex/matcher.c

@@ -275,7 +275,7 @@ struct matcher *matcher_create(struct pool *mem, const char **patterns,
 	int i;
 	size_t len = 0;
 	struct rx_node *rx;
-	struct pool *scratch = pool_create(10 * 1024);
+	struct pool *scratch = pool_create("regex matcher", 10 * 1024);
 	struct matcher *m;
 
 	if (!scratch) {

lib/report/columns.h

@@ -23,6 +23,8 @@ FIELD(LVS, lv, STR, "LV", name, 4, string, "lv_name")
 FIELD(LVS, lv, STR, "Attr", lvid, 4, lvstatus, "lv_attr")
 FIELD(LVS, lv, NUM, "Maj", major, 3, int32, "lv_major")
 FIELD(LVS, lv, NUM, "Min", minor, 3, int32, "lv_minor")
+FIELD(LVS, lv, STR, "KMaj", lvid, 4, lvkmaj, "lv_kernel_major")
+FIELD(LVS, lv, STR, "KMin", lvid, 4, lvkmin, "lv_kernel_minor")
 FIELD(LVS, lv, NUM, "LSize", size, 5, size64, "lv_size")
 FIELD(LVS, lv, NUM, "#Seg", lvid, 4, lvsegcount, "seg_count")
 FIELD(LVS, lv, STR, "Origin", lvid, 6, origin, "origin")
@@ -34,6 +36,7 @@ FIELD(LVS, lv, STR, "LV Tags", tags, 7, tags, "lv_tags")
 FIELD(PVS, pv, STR, "Fmt", id, 3, pvfmt, "pv_fmt")
 FIELD(PVS, pv, STR, "PV UUID", id, 38, uuid, "pv_uuid")
 FIELD(PVS, pv, NUM, "PSize", id, 5, pvsize, "pv_size")
+FIELD(PVS, pv, NUM, "DevSize", dev, 7, devsize, "dev_size")
 FIELD(PVS, pv, NUM, "PFree", id, 5, pvfree, "pv_free")
 FIELD(PVS, pv, NUM, "Used", id, 4, pvused, "pv_used")
 FIELD(PVS, pv, STR, "PV", dev, 10, dev_name, "pv_name")

lib/report/report.c

@@ -21,7 +21,7 @@
 #include "lvm-string.h"
 #include "display.h"
 #include "activate.h"
-#include "segtypes.h"
+#include "segtype.h"
 
 /* 
  * For macro use
@@ -259,6 +259,65 @@ static int _pvfmt_disp(struct report_handle *rh, struct field *field,
 	return _string_disp(rh, field, &pv->fmt->name);
 }
 
+static int _int_disp(struct report_handle *rh, struct field *field,
+		     const void *data)
+{
+	const int value = *(const int *) data;
+	uint64_t *sortval;
+	char *repstr;
+
+	if (!(repstr = pool_zalloc(rh->mem, 13))) {
+		log_error("pool_alloc failed");
+		return 0;
+	}
+
+	if (!(sortval = pool_alloc(rh->mem, sizeof(int64_t)))) {
+		log_error("pool_alloc failed");
+		return 0;
+	}
+
+	if (lvm_snprintf(repstr, 12, "%d", value) < 0) {
+		log_error("int too big: %d", value);
+		return 0;
+	}
+
+	*sortval = (const uint64_t) value;
+	field->sort_value = sortval;
+	field->report_string = repstr;
+
+	return 1;
+}
+
+static int _lvkmaj_disp(struct report_handle *rh, struct field *field,
+			const void *data)
+{
+	const struct logical_volume *lv = (const struct logical_volume *) data;
+	struct lvinfo info;
+	uint64_t minusone = UINT64_C(-1);
+
+	if (lv_info(lv, &info) && info.exists)
+		return _int_disp(rh, field, &info.major);
+	else
+		return _int_disp(rh, field, &minusone);
+
+	return 1;
+}
+
+static int _lvkmin_disp(struct report_handle *rh, struct field *field,
+			const void *data)
+{
+	const struct logical_volume *lv = (const struct logical_volume *) data;
+	struct lvinfo info;
+	uint64_t minusone = UINT64_C(-1);
+
+	if (lv_info(lv, &info) && info.exists)
+		return _int_disp(rh, field, &info.minor);
+	else
+		return _int_disp(rh, field, &minusone);
+
+	return 1;
+}
+
 static int _lvstatus_disp(struct report_handle *rh, struct field *field,
 			  const void *data)
 {
@@ -586,6 +645,18 @@ static int _pvsize_disp(struct report_handle *rh, struct field *field,
 	return _size64_disp(rh, field, &size);
 }
 
+static int _devsize_disp(struct report_handle *rh, struct field *field,
+			const void *data)
+{
+	const struct device *dev = *(const struct device **) data;
+	uint64_t size;
+
+	if (!dev_get_size(dev, &size))
+		size = 0;
+
+	return _size64_disp(rh, field, &size);
+}
+
 static int _vgfree_disp(struct report_handle *rh, struct field *field,
 			const void *data)
 {
@@ -1010,7 +1081,7 @@ void *report_init(struct cmd_context *cmd, const char *format, const char *keys,
 		rh->field_prefix = "";
 	}
 
-	if (!(rh->mem = pool_create(10 * 1024))) {
+	if (!(rh->mem = pool_create("report", 10 * 1024))) {
 		log_error("Allocation of memory pool for report failed");
 		return NULL;
 	}

lib/snapshot/Makefile.in

@@ -22,8 +22,6 @@ LIB_SHARED = liblvm2snapshot.so
 
 include $(top_srcdir)/make.tmpl
 
-.PHONY: install
-
 install: liblvm2snapshot.so
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
 		$(libdir)/liblvm2snapshot.so.$(LIB_VERSION)

lib/snapshot/snapshot.c

@@ -18,7 +18,7 @@
 #include "list.h"
 #include "toolcontext.h"
 #include "metadata.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "text_export.h"
 #include "config.h"
 #include "activate.h"
@@ -161,5 +161,7 @@ struct segment_type *init_segtype(struct cmd_context *cmd)
 	segtype->private = NULL;
 	segtype->flags = SEG_SNAPSHOT;
 
+	log_very_verbose("Initialised segtype: %s", segtype->name);
+
 	return segtype;
 }

lib/striped/striped.c

@@ -17,7 +17,7 @@
 #include "pool.h"
 #include "list.h"
 #include "toolcontext.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "display.h"
 #include "text_export.h"
 #include "text_import.h"
@@ -217,5 +217,7 @@ struct segment_type *init_striped_segtype(struct cmd_context *cmd)
 	segtype->flags =
 	    SEG_CAN_SPLIT | SEG_AREAS_STRIPED | SEG_FORMAT1_SUPPORT;
 
+	log_very_verbose("Initialised segtype: %s", segtype->name);
+
 	return segtype;
 }

lib/zero/zero.c

@@ -16,7 +16,7 @@
 #include "pool.h"
 #include "list.h"
 #include "toolcontext.h"
-#include "segtypes.h"
+#include "segtype.h"
 #include "display.h"
 #include "text_export.h"
 #include "text_import.h"
@@ -97,5 +97,7 @@ struct segment_type *init_zero_segtype(struct cmd_context *cmd)
 	segtype->private = NULL;
 	segtype->flags = SEG_CAN_SPLIT | SEG_VIRTUAL;
 
+	log_very_verbose("Initialised segtype: %s", segtype->name);
+
 	return segtype;
 }

libdm/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 device-mapper userspace tools.
 #
@@ -17,13 +17,16 @@ top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 interface = @interface@
 
-SOURCES = libdm-common.c $(interface)/libdm-iface.c
+SOURCES = libdm-common.c libdm-file.c $(interface)/libdm-iface.c
 
 INCLUDES = -I$(interface)
 
 LIB_STATIC = $(interface)/libdevmapper.a
 LIB_SHARED = $(interface)/libdevmapper.so
 
+CFLAGS += -DDEVICE_UID=@DEVICE_UID@ -DDEVICE_GID=@DEVICE_GID@ \
+	  -DDEVICE_MODE=@DEVICE_MODE@
+
 include ../make.tmpl
 
 .PHONY: install_dynamic install_static \

libdm/ioctl/libdm-iface.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 the device-mapper userspace tools.
  *
@@ -13,22 +13,17 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "libdm-targets.h"
 #include "libdm-common.h"
-#include "log.h"
+#include "libdm-file.h"
 
 #ifdef DM_COMPAT
 #  include "libdm-compat.h"
 #endif
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
 #include <fcntl.h>
 #include <dirent.h>
-#include <errno.h>
-#include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <limits.h>
 
@@ -53,6 +48,13 @@
 #error The version of dm-ioctl.h included is incompatible.
 #endif
 
+/* FIXME This should be exported in device-mapper.h */
+#define DM_NAME "device-mapper"
+
+#define PROC_MISC "/proc/misc"
+#define PROC_DEVICES "/proc/devices"
+#define MISC_NAME "misc"
+
 /* dm major version no for running kernel */
 static int _dm_version = DM_VERSION_MAJOR;
 static int _log_suppress = 0;
@@ -114,22 +116,144 @@ static void *_align(void *ptr, unsigned int a)
 	return (void *) (((unsigned long) ptr + agn) & ~agn);
 }
 
+static int _get_proc_number(const char *file, const char *name,
+			    uint32_t *number)
+{
+	FILE *fl;
+	char nm[256];
+	int c;
+
+	if (!(fl = fopen(file, "r"))) {
+		log_error("%s: fopen failed: %s", file, strerror(errno));
+		return 0;
+	}
+
+	while (!feof(fl)) {
+		if (fscanf(fl, "%d %255s\n", number, &nm[0]) == 2) {
+			if (!strcmp(name, nm)) {
+				fclose(fl);
+				return 1;
+			}
+		}
+		do {
+			c = fgetc(fl);
+		} while (c != EOF && c != '\n');
+	}
+	fclose(fl);
+
+	log_error("%s: No entry for %s found", file, name);
+	return 0;
+}
+
+static int _control_device_number(uint32_t *major, uint32_t *minor)
+{
+	if (!_get_proc_number(PROC_DEVICES, MISC_NAME, major) ||
+	    !_get_proc_number(PROC_MISC, DM_NAME, minor)) {
+		*major = 0;
+		return 0;
+	}
+
+	return 1;
+}
+
+/*
+ * Returns 1 if exists; 0 if it doesn't; -1 if it's wrong
+ */
+static int _control_exists(const char *control, uint32_t major, uint32_t minor)
+{
+	struct stat buf;
+
+	if (stat(control, &buf) < 0) {
+		if (errno != ENOENT)
+			log_error("%s: stat failed: %s", control,
+				  strerror(errno));
+		return 0;
+	}
+
+	if (!S_ISCHR(buf.st_mode)) {
+		log_verbose("%s: Wrong inode type", control);
+		if (!unlink(control))
+			return 0;
+		log_error("%s: unlink failed: %s", control,
+			  strerror(errno));
+		return -1;
+	}
+
+	if (major && buf.st_rdev != MKDEV(major, minor)) {
+		log_verbose("%s: Wrong device number: (%u, %u) instead of "
+			    "(%u, %u)", control,
+			    MAJOR(buf.st_mode), MINOR(buf.st_mode),
+			    major, minor);
+		if (!unlink(control))
+			return 0;
+		log_error("%s: unlink failed: %s", control,
+			  strerror(errno));
+		return -1;
+	}
+
+	return 1;
+}
+
+static int _create_control(const char *control, uint32_t major, uint32_t minor)
+{
+	int ret;
+	mode_t old_umask;
+
+	if (!major)
+		return 0;
+
+	old_umask = umask(0022);
+	ret = create_dir(dm_dir());
+	umask(old_umask);
+
+	if (!ret)
+		return 0;
+
+	log_verbose("Creating device %s (%u, %u)", control, major, minor);
+
+	if (mknod(control, S_IFCHR | S_IRUSR | S_IWUSR,
+		  MKDEV(major, minor)) < 0)  {
+		log_error("%s: mknod failed: %s", control, strerror(errno));
+		return 0;
+	}
+
+#ifdef HAVE_SELINUX
+        if (!set_selinux_context(control)) {
+                stack;
+                return 0;
+        }
+#endif
+
+	return 1;
+}
+
 static int _open_control(void)
 {
 	char control[PATH_MAX];
+	uint32_t major = 0, minor;
 
 	if (_control_fd != -1)
 		return 1;
 
 	snprintf(control, sizeof(control), "%s/control", dm_dir());
 
+	if (!_control_device_number(&major, &minor))
+		log_error("Is device-mapper driver missing from kernel?");
+
+	if (!_control_exists(control, major, minor) &&
+	    !_create_control(control, major, minor))
+		goto error;
+
 	if ((_control_fd = open(control, O_RDWR)) < 0) {
 		log_error("%s: open failed: %s", control, strerror(errno));
-		log_error("Is device-mapper driver missing from kernel?");
-		return 0;
+		goto error;
 	}
 
 	return 1;
+
+error:
+	log_error("Failure to communicate with kernel device-mapper driver.");
+	return 0;
 }
 
 void dm_task_destroy(struct dm_task *dmt)
@@ -495,9 +619,14 @@ static int _dm_task_run_v1(struct dm_task *dmt)
 		goto bad;
 	}
 
+	if (dmi->flags & DM_BUFFER_FULL_FLAG)
+		/* FIXME Increase buffer size and retry operation (if query) */
+		log_error("Warning: libdevmapper buffer too small for data");
+
 	switch (dmt->type) {
 	case DM_DEVICE_CREATE:
-		add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev));
+		add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev),
+			     dmt->uid, dmt->gid, dmt->mode);
 		break;
 
 	case DM_DEVICE_REMOVE:
@@ -511,7 +640,8 @@ static int _dm_task_run_v1(struct dm_task *dmt)
 	case DM_DEVICE_MKNODES:
 		if (dmi->flags & DM_EXISTS_FLAG)
 			add_dev_node(dmt->dev_name, MAJOR(dmi->dev),
-				     MINOR(dmi->dev));
+				     MINOR(dmi->dev),
+				     dmt->uid, dmt->gid, dmt->mode);
 		else
 			rm_dev_node(dmt->dev_name);
 		break;
@@ -1152,7 +1282,8 @@ int dm_task_run(struct dm_task *dmt)
 	if (dmt->type == DM_DEVICE_CREATE && dmt->head)
 		return _create_and_load_v4(dmt);
 
-	if (dmt->type == DM_DEVICE_MKNODES && !dmt->dev_name)
+	if (dmt->type == DM_DEVICE_MKNODES && !dmt->dev_name &&
+	    !dmt->uuid && dmt->major <= 0)
 		return _mknodes_v4(dmt);
 
 	if (!_open_control())
@@ -1189,22 +1320,28 @@ int dm_task_run(struct dm_task *dmt)
       ignore_error:
 	switch (dmt->type) {
 	case DM_DEVICE_CREATE:
-		add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev));
+		add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev),
+			     dmt->uid, dmt->gid, dmt->mode);
 		break;
 
 	case DM_DEVICE_REMOVE:
-		rm_dev_node(dmt->dev_name);
+		/* FIXME Kernel needs to fill in dmi->name */
+		if (dmt->dev_name)
+			rm_dev_node(dmt->dev_name);
 		break;
 
 	case DM_DEVICE_RENAME:
-		rename_dev_node(dmt->dev_name, dmt->newname);
+		/* FIXME Kernel needs to fill in dmi->name */
+		if (dmt->dev_name)
+			rename_dev_node(dmt->dev_name, dmt->newname);
 		break;
 
 	case DM_DEVICE_MKNODES:
 		if (dmi->flags & DM_EXISTS_FLAG)
-			add_dev_node(dmt->dev_name, MAJOR(dmi->dev),
-				     MINOR(dmi->dev));
-		else
+			add_dev_node(dmi->name, MAJOR(dmi->dev),
+				     MINOR(dmi->dev),
+				     dmt->uid, dmt->gid, dmt->mode);
+		else if (dmt->dev_name)
 			rm_dev_node(dmt->dev_name);
 		break;
 

libdm/ioctl/libdm-targets.h

@@ -17,6 +17,7 @@
 #define LIB_DMTARGETS_H
 
 #include <inttypes.h>
+#include <sys/types.h>
 
 struct dm_ioctl;
 struct dm_ioctl_v1;
@@ -40,6 +41,9 @@ struct dm_task {
 	uint32_t event_nr;
 	int major;
 	int minor;
+	uid_t uid;
+	gid_t gid;
+	mode_t mode;
 	union {
 		struct dm_ioctl *v4;
 		struct dm_ioctl_v1 *v1;

libdm/libdm-common.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 the device-mapper userspace tools.
  *
@@ -13,20 +13,14 @@
  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "libdm-targets.h"
 #include "libdm-common.h"
 #include "list.h"
-#include "log.h"
 #include "kdev_t.h"
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <stdarg.h>
-#include <string.h>
 #include <sys/param.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <errno.h>
 #include <linux/dm-ioctl.h>
 
 #ifdef HAVE_SELINUX
@@ -63,7 +57,7 @@ static void _default_log(int level, const char *file, int line,
 	if (level < _LOG_WARN)
 		fprintf(stderr, "\n");
 	else
-		printf("\n");
+		fprintf(stdout, "\n");
 }
 
 dm_log_fn _log = _default_log;
@@ -100,19 +94,22 @@ struct dm_task *dm_task_create(int type)
 {
 	struct dm_task *dmt = malloc(sizeof(*dmt));
 
-	if (!dm_check_version())
-		return NULL;
-
 	if (!dmt) {
 		log_error("dm_task_create: malloc(%d) failed", sizeof(*dmt));
 		return NULL;
 	}
 
+	if (!dm_check_version())
+		return NULL;
+
 	memset(dmt, 0, sizeof(*dmt));
 
 	dmt->type = type;
 	dmt->minor = -1;
 	dmt->major = -1;
+	dmt->uid = DEVICE_UID;
+	dmt->gid = DEVICE_GID;
+	dmt->mode = DEVICE_MODE;
 
 	return dmt;
 }
@@ -202,7 +199,7 @@ int dm_task_add_target(struct dm_task *dmt, uint64_t start, uint64_t size,
 }
 
 #ifdef HAVE_SELINUX
-static int _set_selinux_context(const char *path)
+int set_selinux_context(const char *path)
 {
 	security_context_t scontext;
 
@@ -226,11 +223,13 @@ static int _set_selinux_context(const char *path)
 }
 #endif
 
-static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor)
+static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
+			 uid_t uid, gid_t gid, mode_t mode)
 {
 	char path[PATH_MAX];
 	struct stat info;
 	dev_t dev = MKDEV(major, minor);
+	mode_t old_mask;
 
 	_build_dev_path(path, sizeof(path), dev_name);
 
@@ -241,6 +240,7 @@ static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor)
 			return 0;
 		}
 
+		/* If right inode already exists we don't touch uid etc. */
 		if (info.st_rdev == dev)
 			return 1;
 
@@ -251,12 +251,20 @@ static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor)
 		}
 	}
 
-	if (mknod(path, S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP, dev) < 0) {
+	old_mask = umask(0);
+	if (mknod(path, S_IFBLK | mode, dev) < 0) {
 		log_error("Unable to make device node for '%s'", dev_name);
 		return 0;
 	}
+	umask(old_mask);
+
+	if (chown(path, uid, gid) < 0) {
+		log_error("%s: chown failed: %s", path, strerror(errno));
+		return 0;
+	}
+
 #ifdef HAVE_SELINUX
-	if (!_set_selinux_context(path))
+	if (!set_selinux_context(path))
 		return 0;
 #endif
 
@@ -324,11 +332,12 @@ typedef enum {
 } node_op_t;
 
 static int _do_node_op(node_op_t type, const char *dev_name, uint32_t major,
-		       uint32_t minor, const char *old_name)
+		       uint32_t minor, uid_t uid, gid_t gid, mode_t mode,
+		       const char *old_name)
 {
 	switch (type) {
 	case NODE_ADD:
-		return _add_dev_node(dev_name, major, minor);
+		return _add_dev_node(dev_name, major, minor, uid, gid, mode);
 	case NODE_DEL:
 		return _rm_dev_node(dev_name);
 	case NODE_RENAME:
@@ -346,6 +355,9 @@ struct node_op_parms {
 	char *dev_name;
 	uint32_t major;
 	uint32_t minor;
+	uid_t uid;
+	gid_t gid;
+	mode_t mode;
 	char *old_name;
 	char names[0];
 };
@@ -358,7 +370,8 @@ static void _store_str(char **pos, char **ptr, const char *str)
 }
 
 static int _stack_node_op(node_op_t type, const char *dev_name, uint32_t major,
-			  uint32_t minor, const char *old_name)
+			  uint32_t minor, uid_t uid, gid_t gid, mode_t mode,
+			  const char *old_name)
 {
 	struct node_op_parms *nop;
 	size_t len = strlen(dev_name) + strlen(old_name) + 2;
@@ -373,6 +386,9 @@ static int _stack_node_op(node_op_t type, const char *dev_name, uint32_t major,
 	nop->type = type;
 	nop->major = major;
 	nop->minor = minor;
+	nop->uid = uid;
+	nop->gid = gid;
+	nop->mode = mode;
 
 	_store_str(&pos, &nop->dev_name, dev_name);
 	_store_str(&pos, &nop->old_name, old_name);
@@ -390,25 +406,27 @@ static void _pop_node_ops(void)
 	list_iterate_safe(noph, nopht, &_node_ops) {
 		nop = list_item(noph, struct node_op_parms);
 		_do_node_op(nop->type, nop->dev_name, nop->major, nop->minor,
-			    nop->old_name);
+			    nop->uid, nop->gid, nop->mode, nop->old_name);
 		list_del(&nop->list);
 		free(nop);
 	}
 }
 
-int add_dev_node(const char *dev_name, uint32_t major, uint32_t minor)
+int add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
+		 uid_t uid, gid_t gid, mode_t mode)
 {
-	return _stack_node_op(NODE_ADD, dev_name, major, minor, "");
+	return _stack_node_op(NODE_ADD, dev_name, major, minor, uid, gid, mode,
+			      "");
 }
 
 int rename_dev_node(const char *old_name, const char *new_name)
 {
-	return _stack_node_op(NODE_RENAME, new_name, 0, 0, old_name);
+	return _stack_node_op(NODE_RENAME, new_name, 0, 0, 0, 0, 0, old_name);
 }
 
 int rm_dev_node(const char *dev_name)
 {
-	return _stack_node_op(NODE_DEL, dev_name, 0, 0, "");
+	return _stack_node_op(NODE_DEL, dev_name, 0, 0, 0, 0, 0, "");
 }
 
 void update_devs(void)

libdm/libdm-common.h.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 device-mapper userspace tools.
  *
@@ -22,11 +22,14 @@ struct target *create_target(uint64_t start,
 			     uint64_t len,
 			     const char *type, const char *params);
 
-int add_dev_node(const char *dev_name, uint32_t minor, uint32_t major);
+int add_dev_node(const char *dev_name, uint32_t minor, uint32_t major,
+		 uid_t uid, gid_t gid, mode_t mode);
 int rm_dev_node(const char *dev_name);
 int rename_dev_node(const char *old_name, const char *new_name);
 void update_devs(void);
 
+int set_selinux_context(const char *path);
+
 #define DM_LIB_VERSION @DM_LIB_VERSION@
 
 #endif

libdm/libdm-file.c

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-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 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
+ */
+
+#include "lib.h"
+#include "libdm-file.h"
+
+#include <sys/file.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <malloc.h>
+
+static int _create_dir_recursive(const char *dir)
+{
+	char *orig, *s;
+	int rc;
+
+	log_verbose("Creating directory \"%s\"", dir);
+	/* Create parent directories */
+	orig = s = strdup(dir);
+	while ((s = strchr(s, '/')) != NULL) {
+		*s = '\0';
+		if (*orig) {
+			rc = mkdir(orig, 0777);
+			if (rc < 0 && errno != EEXIST) {
+				log_error("%s: mkdir failed: %s", orig,
+					  strerror(errno));
+				free(orig);
+				return 0;
+			}
+		}
+		*s++ = '/';
+	}
+	free(orig);
+
+	/* Create final directory */
+	rc = mkdir(dir, 0777);
+	if (rc < 0 && errno != EEXIST) {
+		log_error("%s: mkdir failed: %s", orig,
+			  strerror(errno));
+		return 0;
+	}
+	return 1;
+}
+
+int create_dir(const char *dir)
+{
+	struct stat info;
+
+	if (!*dir)
+		return 1;
+
+	if (stat(dir, &info) < 0)
+		return _create_dir_recursive(dir);
+
+	if (S_ISDIR(info.st_mode))
+		return 1;
+
+	log_error("Directory \"%s\" not found", dir);
+	return 0;
+}
+

libdm/libdm-file.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-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 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 LIB_DMFILE_H
+#define LIB_DMFILE_H
+
+/*
+ * Create directory (recursively) if necessary.  Return 1
+ * if directory was successfully created (or already exists), else 0.
+ */
+int create_dir(const char *dir);
+
+#endif

make.tmpl.in

@@ -99,20 +99,22 @@ DEPS = $(top_srcdir)/make.tmpl $(top_srcdir)/VERSION Makefile $(INC_LNS)
 OBJECTS = $(SOURCES:%.c=%.o)
 POTFILES = $(SOURCES:%.c=%.pot)
 
+.PHONY: all install install_cluster pofile distclean clean
+.PHONY: $(SUBDIRS) $(SUBDIRS.install) $(SUBDIRS.clean) $(SUBDIRS.distclean)
+.PHONY: $(SUBDIRS.pofile) $(SUBDIRS.install_cluster)
+
 SUBDIRS.install := $(SUBDIRS:=.install)
+SUBDIRS.install_cluster := $(SUBDIRS:=.install_cluster)
 SUBDIRS.pofile := $(SUBDIRS:=.pofile)
 SUBDIRS.clean := $(SUBDIRS:=.clean)
 SUBDIRS.distclean := $(SUBDIRS:=.distclean)
 
-.PHONY: all install pofile distclean clean
-.PHONY: $(SUBDIRS) $(SUBDIRS.install) $(SUBDIRS.clean) $(SUBDIRS.distclean)
-.PHONY: $(SUBDIRS.pofile)
-
 TARGETS += $(LIB_SHARED) $(LIB_STATIC)
 
 all: $(SUBDIRS) $(TARGETS)
 
 install: all $(SUBDIRS.install)
+install_cluster: all $(SUBDIRS.install_cluster)
 
 $(SUBDIRS):
 	$(MAKE) -C $@
@@ -120,6 +122,9 @@ $(SUBDIRS):
 $(SUBDIRS.install): $(SUBDIRS)
 	$(MAKE) -C $(@:.install=) install
 
+$(SUBDIRS.install_cluster): $(SUBDIRS)
+	$(MAKE) -C $(@:.install_cluster=) install_cluster
+
 $(SUBDIRS.clean):
 	-$(MAKE) -C $(@:.clean=) clean
 

man/Makefile.in

@@ -24,11 +24,16 @@ MAN8=lvchange.8 lvcreate.8 lvdisplay.8 lvextend.8 lvm.8 lvmchange.8 \
 	vgconvert.8 vgdisplay.8 vgexport.8 vgextend.8 vgimport.8 \
 	vgmerge.8 vgmknodes.8 vgreduce.8 vgremove.8 vgrename.8 \
 	vgs.8 vgscan.8 vgsplit.8
+MAN8CLUSTER=clvmd.8
 MAN5DIR=${mandir}/man5
 MAN8DIR=${mandir}/man8
 
 include $(top_srcdir)/make.tmpl
 
+ifneq ("@CLVMD@", "none")
+  install: install_cluster
+endif
+
 install:
 	@echo "Installing $(MAN8) in $(MAN8DIR)"
 	@for f in $(MAN8); \
@@ -43,3 +48,11 @@ install:
 	   $(RM) $(MAN5DIR)/$$f; \
 	   @INSTALL@ -D $(OWNER) $(GROUP) -m 444 $$f $(MAN5DIR)/$$f; \
 	done
+
+install_cluster:
+	@echo "Installing $(MAN8CLUSTER) in $(MAN8DIR)"
+	@for f in $(MAN8CLUSTER); \
+	do \
+	   $(RM) $(MAN8DIR)/$$f; \
+	   @INSTALL@ -D $(OWNER) $(GROUP) -m 444 $$f $(MAN8DIR)/$$f; \
+	done

man/clvmd.8

@@ -0,0 +1,28 @@
+.TH CLVMD 8 "LVM TOOLS" "Red Hat Inc" \" -*- nroff -*-
+.SH NAME
+clvmd \- cluster LVM daemon
+.SH SYNOPSIS
+.B clvmd
+[\-d] [\-h]
+[\-t <timeout>]
+[\-V]
+.SH DESCRIPTION
+clvmd is the daemon that distributes LVM metadata updates around a cluster.
+It must be running on all nodes in the cluster and will give an error 
+if a node in the cluster does not have this daemon running.
+.SH OPTIONS
+.TP
+.I \-d
+Runs in the foreground and prints debugging information (if compiled in) to
+stderr. By default, clvmd will fork into the background when invoked.
+.TP
+.I \-t <timeout>
+Specifies the timeout for commands to run around the cluster. This should not
+be so small that commands with many disk updates to do will fail, so you
+may need to increase this on systems with very large disk farms. 
+The default is 30 seconds.
+.TP
+.I \-V
+Display the version of the cluster LVM daemon.
+.SH SEE ALSO
+.BR lvm (8)

man/lvchange.8

@@ -4,26 +4,34 @@ lvchange \- change attributes of a logical volume
 .SH SYNOPSIS
 .B lvchange
 [\-\-addtag Tag]
-[\-A/\-\-autobackup y/n] [\-a/\-\-available y/n]
+[\-A/\-\-autobackup y/n] [\-a/\-\-available y/n/ey/en/ly/ln]
+[\-\-alloc AllocationPolicy]
 [\-C/\-\-contiguous y/n] [\-d/\-\-debug] [\-\-deltag Tag]
 [\-h/\-?/\-\-help]
 [\-\-ignorelockingfailure]
 [\-M/\-\-persistent y/n] [\-\-minor minor]
 [\-P/\-\-partial y/n]
 [\-p/\-\-permission r/w] [\-r/\-\-readahead ReadAheadSectors]
+[\-\-refresh]
 [\-t/\-\-test]
 [\-v/\-\-verbose] LogicalVolumePath [LogicalVolumePath...]
 .SH DESCRIPTION
-lvchange allows you to change the attributes of a logical volume.
+lvchange allows you to change the attributes of a logical volume
+including making them known to the kernel ready for use.
 .SH OPTIONS
 See \fBlvm\fP for common options.
 .TP
-.I \-a, \-\-available y/n
+.I \-a, \-\-available y/n/ey/en/ly/ln
 Controls the availability of the logical volumes for use.
-This is (among others) useful for changing the logical volume's name
-( see
-.B lvrename(8)
-) safely.
+Communicates with the kernel device-mapper driver via
+libdevmapper to activate (-ay) or deactivate (-an) the 
+logical volumes.
+.IP
+If clustered locking is enabled, -ae will activate exclusively
+on one node and -aly will activate only on the local node.
+To deactivate only on the local node use -aln.
+Logical volumes with single-host snapshots are always activated 
+exclusively because they can only be used on one node at once.
 .TP
 .I \-C, \-\-contiguous y/n
 Tries to set or reset the contiguous allocation policy for
@@ -42,10 +50,18 @@ Change access permission to read-only or read/write.
 .TP
 .I \-r, \-\-readahead ReadAheadSectors
 Change read ahead sector count per logical between 2 and 120.
-Not used by device-mapper.
+For compatability with LVM1 only. Ignored by LVM2.
+.TP
+.I \-\-refresh
+If the logical volume is active, reload its metadata.
+This is not necessary in normal operation, but may be useful
+if something has gone wrong or if you're doing clustering 
+manually without a clustered lock manager.
 .SH Examples
-"lvchange -x n vg00/lvol1" prevents the allocation of any physical
-extents on logical volume lvol1 in volume group vg00.
+"lvchange -pr vg00/lvol1" changes the permission on 
+volume lvol1 in volume group vg00 to be read-only.
+
 .SH SEE ALSO
 .BR lvm (8), 
-.BR lvcreate (8)
+.BR lvcreate (8),
+.BR vgchange (8)

man/lvcreate.8

@@ -4,6 +4,7 @@ lvcreate \- create a logical volume in an existing volume group
 .SH SYNOPSIS
 .B lvcreate
 [\-\-addtag Tag]
+[\-\-alloc AllocationPolicy]
 [\-A/\-\-autobackup y/n] [\-C/\-\-contiguous y/n] [\-d/\-\-debug]
 [\-h/\-?/\-\-help]
 [\-i/\-\-stripes Stripes [\-I/\-\-stripesize StripeSize]]

man/lvdisplay.8

@@ -10,12 +10,15 @@ lvdisplay \- display attributes of a logical volume
 .SH DESCRIPTION
 lvdisplay allows you to see the attributes of a logical volume
 like size, read/write status, snapshot information etc.
+.P
+\fBlvs\fP (8) is an alternative that provides the same information 
+in the style of \fBps\fP (1).
 .SH OPTIONS
 See \fBlvm\fP for common options.
 .TP
 .I \-c, \-\-colon
-Deprecated.  To be replaced with a more-powerful reporting tool.
 Generate colon separated output for easier parsing in scripts or programs.
+N.B. \fBlvs\fP (8) provides considerably more control over the output.
 .nf
 
 The values are:

man/lvextend.8

@@ -3,6 +3,7 @@
 lvextend \- extend the size of a logical volume
 .SH SYNOPSIS
 .B lvextend
+[\-\-alloc AllocationPolicy]
 [\-A/\-\-autobackup y/n] [\-d/\-\-debug] [\-h/\-?/\-\-help]
 [\-i/\-\-stripes Stripes [\-I/\-\-stripesize StripeSize]]
 {\-l/\-\-extents [+]LogicalExtentsNumber |

man/lvm.8

@@ -18,23 +18,44 @@ If \fBlvm\fP is invoked with argv[0] set to the name of a specific
 LVM command (for example by using a hard or soft link) it acts as 
 that command.  
 .LP
+Where commands take VG or LV names as arguments, the full path name is
+optional.  An LV called "lvol0" in a VG called "vg0" can be specified
+as "vg0/lvol0".  Where a list of VGs is required but is left empty, 
+a list of all VGs will be substituted.  Where a list of LVs is required
+but a VG is given, a list of all the LVs in that VG will be substituted.
+So "lvdisplay vg0" will display all the LVs in "vg0".
+Tags can also be used - see \fBaddtag\fP below.
+.LP
 One advantage of using the built-in shell is that configuration 
-information is cached internally between commands.  
+information gets cached internally between commands.  
 .LP
 A file containing a simple script with one command per line 
 can also be given on the command line.  The script can also be
 executed directly if the first line is #! followed by the absolute
 path of \fBlvm\fP.
+.SH BUILT-IN COMMANDS
+The following commands are built into lvm without links normally
+being created in the filesystem for them.
+.TP
+\fBdumpconfig\fP \(em Display the configuration information after 
+loading \fBlvm.conf\fP (8) and any other configuration files.
+.TP
+\fBformats\fP \(em Display recognised metadata formats.
+.TP
+\fBhelp\fP \(em Display the help text.
+.TP
+\fBpvdata\fP \(em Not implemented in LVM2.
+.TP
+\fBsegtypes\fP \(em Display recognised logical volume segment types.
+.TP
+\fBversion\fP \(em Display version information.
 .LP
-Where commands take VG or LV names as arguments, the full path name is
-optional.  An LV called "lvol0" in a VG called "vg0" can be specified
-as "vg0/lvol0".  If a list of VGs is required but is left empty, a list of
-all VGs will be substituted.  If a list of LVs is required
-but a VG is given, a list of all the LVs in that VG will be substituted.
-So "lvdisplay vg0" will display all the LVs in "vg0".
+The following commands are not implemented in LVM2 but might be
+in future: lvmsadc, lvmsar, pvdata, pvresize.
 .SH OPTIONS
-The following options are available for many of the commands and are 
-not documented on individual manual pages.
+The following options are available for many of the commands. 
+They are implemented generically and documented here rather 
+than repeated on individual manual pages.
 .TP
 \fB-h | --help\fP \(em Display the help text.
 .TP
@@ -54,6 +75,10 @@ Overrides -d and -v.
 .TP
 \fB-t | --test\fP \(em Run in test mode.
 Commands will not update metadata.
+This is implemented by disabling all metadata writing but nevertheless
+returning success to the calling function.  This may lead to unusual
+error messages in multi-stage operations if a tool relies on reading
+back metadata it believes has changed but hasn't.
 .TP
 \fB--driverloaded\fP { \fBy\fP | \fBn\fP }
 Whether or not the device-mapper kernel driver is loaded.
@@ -109,6 +134,27 @@ Characters allowed in tags are: A-Z a-z 0-9 _ + . -
 .TP
 \fB--deltag tag\fP
 Delete the tag \fBtag\fP from a PV, VG or LV, if it's present.
+.TP
+\fB--alloc AllocationPolicy\fP
+The allocation policy to use: \fBcontiguous\fP, \fBnormal\fP, \fBanywhere\fP or \fBinherit\fP.
+When a command needs to allocate physical extents from the volume group,
+the allocation policy controls how they are chosen.  
+Each volume group and logical volume has an allocation policy.
+The default for a volume group is \fBnormal\fP which applies
+common-sense rules such as not placing parallel stripes on the same
+physical volume.  The default for a logical volume is \fBinherit\fP
+which applies the same policy as for the volume group.  These policies can
+be changed using \fBlvchange\fP (8) and \fBvgchange\fP (8) or over-ridden
+on the command line of any command that performs allocation.
+The \fBcontiguous\fP policy requires that new extents are adjacent to
+existing extents. If there are sufficient free extents to satisfy
+an allocation request but \fBnormal\fP doesn't use them,
+\fBanywhere\fP will - even if that reduces performance by
+placing two stripes on the same physical volume.
+.IP
+N.B. The policies described above are not implemented fully yet.
+In particular, \fBcontiguous\fP does not place new extents adjacent to existing
+extents and \fBanywhere\fP is not implemented at all.
 .SH ENVIRONMENT VARIABLES
 .TP
 \fBLVM_SYSTEM_DIR\fP 
@@ -131,31 +177,42 @@ All tools return a status code of zero on success or non-zero on failure.
 .br
 .I $HOME/.lvm_history
 .SH SEE ALSO
+.BR clvmd (8),
 .BR lvchange (8),
 .BR lvcreate (8),
 .BR lvdisplay (8),
 .BR lvextend (8),
 .BR lvmchange (8),
+.BR lvmdiskscan (8),
 .BR lvreduce (8),
 .BR lvremove (8),
 .BR lvrename (8),
 .BR lvresize (8),
+.BR lvs (8),
 .BR lvscan (8),
 .BR pvchange (8),
 .BR pvcreate (8),
 .BR pvdisplay (8),
+.BR pvmove (8),
+.BR pvremove (8),
+.BR pvs (8),
 .BR pvscan (8),
 .BR vgcfgbackup (8),
 .BR vgchange  (8),
 .BR vgck (8),
+.BR vgconvert (8),
 .BR vgcreate (8),
 .BR vgdisplay (8),
 .BR vgextend (8),
+.BR vgimport (8),
 .BR vgmerge (8),
+.BR vgmknodes (8),
 .BR vgreduce (8),
 .BR vgremove (8),
 .BR vgrename (8),
+.BR vgs (8),
 .BR vgscan (8),
+.BR vgsplit (8),
 .BR readline (3),
 .BR lvm.conf (5)
 

man/lvm.conf.5

@@ -4,9 +4,13 @@ lvm.conf \- Configuration file for LVM2
 .SH SYNOPSIS
 .B /etc/lvm/lvm.conf
 .SH DESCRIPTION
-lvm.conf is loaded once, during the initialisation phase of 
-\fBlvm\fP.
+lvm.conf is loaded during the initialisation phase of 
+\fBlvm\fP (8).  This file can in turn lead to other files
+being loaded - settings read in later override earlier
+settings.  File timestamps are checked between commands and if 
+any have changed, all the files are reloaded.  
 .LP
+Use \fBlvm dumpconfig\fP to check what settings are in use.
 .SH SYNTAX
 .LP
 This section describes the configuration file syntax.
@@ -69,7 +73,8 @@ The sections that may be present in the file are:
 \fBdevices\fP \(em Device settings
 .IP
 \fBdir\fP \(em Directory in which to create volume group device nodes.
-Defaults to "/dev".
+Defaults to "/dev".  Commands also accept this as a prefix on volume 
+group names.
 .IP
 \fBscan\fP \(em List of directories to scan recursively for 
 LVM physical volumes.
@@ -81,8 +86,13 @@ Patterns are regular expressions delimited by any character and preceded
 by \fBa\fP (for accept) or \fBr\fP (for reject).  The list is traversed
 in order, and the first regex that matches determines if the device
 will be accepted or rejected (ignored).  Devices that don't match
-any patterns are accepted.
-For example, to ignore /dev/cdrom you could use:
+any patterns are accepted. If you want to reject patterns that
+don't match, end the list with "r/.*/".
+If there are several names for the same device (e.g. symbolic links
+in /dev), if any name matches any \fBa\fP pattern, the
+device is accepted; otherwise if any name matches any \fBr\fP
+pattern it is rejected; otherwise it is accepted.
+As an example, to ignore /dev/cdrom you could use:
 \fBdevices { filter=["r|cdrom|"] }\fP 
 .IP
 \fBcache\fP \(em Persistent filter cache file.
@@ -95,9 +105,24 @@ Defaults to 1.
 \fBtypes\fP \(em List of pairs of additional acceptable block device types
 found in /proc/devices together with maximum (non-zero) number of
 partitions (normally 16).  By default, LVM2 supports ide, sd, md, loop, 
-dasd, dac960, nbd, ida, cciss, ubd and ataraid.  Block devices with major
-numbers of different types are ignored by LVM2.  Example:
-\fBtypes = ["fd", 16]\fP
+dasd, dac960, nbd, ida, cciss, ubd, ataraid, drbd, power2, i2o_block
+and iseries/vd.  Block devices with major
+numbers of different types are ignored by LVM2.  
+Example: \fBtypes = ["fd", 16]\fP.
+To create physical volumes on device-mapper volumes
+created outside LVM2, perhaps encrypted ones from \fBcryptsetup\fP,
+you'll need \fBtypes = ["device-mapper", 16]\fP.  But if you do this,
+be careful to avoid recursion within LVM2.  The figure for number 
+of partitions is not currently used in LVM2 - and might never be.
+.IP
+\fBsysfs_scan\fP (em If set to 1 and your kernel supports sysfs and 
+it is mounted, sysfs will be used as a quick way of filtering out
+block devices that are not present.
+.IP
+\fBmd_component_detection\fP (em If set to 1, LVM2 will ignore devices
+used as components of software RAID (md) devices by looking for md
+superblocks. This doesn't always work satisfactorily e.g. if a device 
+has been reused without wiping the md superblocks first.
 .TP
 \fBlog\fP \(em Default log settings
 .IP
@@ -120,7 +145,8 @@ See /usr/include/sys/syslog.h for safe facility values to use.
 For example, LOG_LOCAL0 might be 128.
 .IP
 \fBindent\fP \(em When set to 1 (the default) messages are indented 
-according to their severity.  Set to 0 to turn off indentation.
+according to their severity, two spaces per level.  
+Set to 0 to turn off indentation.
 .IP
 \fBcommand_names\fP \(em When set to 1, the command name is used as a
 prefix for each message.
@@ -128,6 +154,11 @@ Default is 0 (off).
 .IP
 \fBprefix\fP \(em Prefix used for all messages (after the command name).
 Default is two spaces.
+.IP
+\fBactivation\fP \(em Set to 1 to log messages while
+devices are suspended during activation.  
+Only set this temporarily while debugging a problem because
+in low memory situations this setting can cause your machine to lock up.
 .TP
 \fBbackup\fP \(em Configuration for metadata backups.
 .IP
@@ -165,8 +196,13 @@ Defaults to 30.
 .TP
 \fBglobal\fP \(em Global settings
 .IP
-\fBtest\fP \(em If set to 1, run tools in test mode i.e. no metadata
-gets updated.
+\fBtest\fP \(em If set to 1, run tools in test mode i.e. no changes to
+the on-disk metadata will get made.  It's equivalent to having the
+-t option on every command.
+.IP
+\fBactivation\fP \(em Set to 0 to turn off all communication with
+the device-mapper driver.  Useful if you want to manipulate logical
+volumes while device-mapper is not present in your kernel.
 .IP
 \fBproc\fP \(em Mount point of proc filesystem.
 Defaults to /proc.
@@ -175,12 +211,167 @@ Defaults to /proc.
 Interpreted as octal if the first digit is zero.
 Defaults to 077.  
 Use 022 to allow other users to read the files by default.
+.IP
+\fBformat\fP \(em The default value of \fB--metadatatype\fP used
+to determine which format of metadata to use when creating new 
+physical volumes and volume groups. \fBlvm1\fP or \fBlvm2\fP.
+.IP
+\fBfallback_to_lvm1\fP \(em Set this to 1 if you need to 
+be able to switch between 2.4 kernels using LVM1 and kernels
+including device-mapper.
+The LVM2 tools should be installed as normal and
+the LVM1 tools should be installed with a .lvm1 suffix e.g.
+vgscan.lvm1.  
+If an LVM2 tool is then run but unable to communicate
+with device-mapper, it will automatically invoke the equivalent LVM1 
+version of the tool.  Note that for LVM1 tools to 
+manipulate physical volumes and volume groups created by LVM2 you 
+must use \fB--metadataformat lvm1\fP when creating them.
+.IP
+\fBlibrary_dir\fP \(em A directory searched for LVM2's shared libraries
+ahead of the places \fBdlopen\fP (3) searches.
+.IP
+\fBformat_libraries\fP \(em A list of shared libraries to load that contain
+code to process different formats of metadata. For example, liblvm2formatpool.so
+is needed to read GFS pool metadata if LVM2 was configured \fB--with-pool=shared\fP.
+.IP
+\fBlocking_type\fP \(em What type of locking to use.
+1 is the default, which use flocks on files in \fBlocking_dir\fP
+(see below) to
+avoid conflicting LVM2 commands running concurrently on a single
+machine. 0 disables locking and risks corrupting your metadata.
+If set to 2, the tools will load the external \fBlocking_library\fP
+(see below).
+If the tools were configured \fB--with-cluster=internal\fP 
+(the default) then 3 means to use built-in cluster-wide locking.
+All changes to logical volumes and their states are communicated
+using locks.
+.IP
+\fBlocking_dir\fP \(em The directory LVM2 places its file locks
+if \fBlocking_type\fP is set to 1.  The default is \fB/var/lock/lvm\fP.
+.IP
+\fBlocking_library\fP \(em The name of the external locking
+library to load if \fBlocking_type\fP is set to 2.
+The default is \fBlvm2_locking.so\fP.  If you need to write
+such a library, look at the lib/locking source code directory.
+.TP
+\fBtags\fP \(em Host tag settings
+.IP
+\fBhosttags\fP \(em If set to 1, create a host tag with the machine name.
+Setting this to 0 does nothing, neither creating nor destroying any tag.
+The machine name used is the nodename as returned by \fBuname\fP (2).
+.IP
+Additional host tags to be set can be listed here as subsections. 
+The @ prefix for tags is optional.
+Each of these host tag subsections can contain a \fBhost_list\fP 
+array of host names. If any one of these entries matches the machine 
+name exactly then the host tag gets defined on this particular host, 
+otherwise it doesn't.
+.IP
+After lvm.conf has been processed, LVM2 works through each host
+tag that has been defined in turn, and if there is a configuration
+file called lvm_\fB<host_tag>\fP.conf it attempts to load it.
+Any settings read in override settings found in earlier files.
+Any additional host tags defined get appended to the search list,
+so in turn they can lead to further configuration files being processed.
+Use \fBlvm dumpconfig\fP to check the result of config
+file processing.
+.IP
+The following example always sets host tags \fBtag1\fP and
+sets \fBtag2\fP on machines fs1 and fs2:
+.IP
+tags { tag1 { } tag2 { host_list = [ "fs1", "fs2" ] } }
+.IP
+These options are useful if you are replicating configuration files
+around a cluster.  Use of \fBhosttags = 1\fP means every machine
+can have static and identical local configuration files yet use 
+different settings and activate different logical volumes by
+default.  See also \fBvolume_list\fP below and \fB--addtag\fP 
+in \fBlvm\fP (8).
+.TP
+\fBactivation\fP \(em Settings affecting device-mapper activation
+.IP
+\fBmissing_stripe_filler\fP \(em When activating an incomplete
+logical volume in partial mode, this missing data is replaced
+with this device.  It could perhaps be a block device that always
+returns an error when it is accessed, or one that always
+returns zeros.  See \fBlvcreate\fP (8) for how to create
+such devices.
+.IP
+\fBmirror_region_size\fP \(em Unit size in KB for copy operations
+when mirroring.
+.IP
+\fBreserved_memory\fP, \fBreserved_stack\fP \(em How many KB to reserve 
+for LVM2 to use while logical volumes are suspended.  If insufficient 
+memory is reserved before suspension, there is a risk of machine deadlock.
+.IP
+\fBprocess_priority\fP \(em The nice value to use while devices are
+suspended.  This is set to a high priority so that logical volumes
+are suspended (with I/O generated by other processes to those
+logical volumes getting queued) for the shortest possible time.
+.IP
+\fBvolume_list\fP \(em This acts as a filter through which
+all requests to activate a logical volume on this machine
+are passed.  A logical volume is only activated if it matches
+an item in the list.  Tags must be preceded by @ and are checked
+against all tags defined in the logical volume and volume group 
+metadata for a match.
+@* is short-hand to check every tag set on the host machine (see
+\fBtags\fP above).
+Logical volume and volume groups can also be included in the list
+by name e.g. vg00, vg00/lvol1.
+.TP
+\fBmetadata\fP \(em Advanced metadata settings
+.IP
+\fBpvmetadatacopies\fP \(em When creating a physical volume using the
+LVM2 metadata format, this is the default number of copies of metadata
+to store on each physical volume.  
+Currently it can be set to 0, 1 or 2.  The default is 1.  
+If set to 2, one copy is placed at the beginning of the disk
+and the other is placed at the end.
+It can be overridden on the command line with \fB--metadatacopies\fP.
+If creating a volume group with just one physical volume, it's a
+good idea to have 2 copies.  If creating a large volume group with
+many physical volumes, you may decide that 3 copies of the metadata
+is sufficient, i.e. setting it to 1 on three of the physical volumes,
+and 0 on the rest.  Every volume group must contain at least one 
+physical volume with at least 1 copy of the metadata (unless using
+the text files described below).  The disadvantage of having lots
+of copies is that every time the tools access the volume group, every
+copy of the metadata has to be accessed, and this slows down the
+tools.
+.IP
+\fBpvmetadatasize\fP \(em Approximate number of sectors to set aside
+for each copy of the metadata. Volume groups with large numbers of
+physical or logical volumes, or volumes groups containing complex 
+logical volume structures will need additional space for their metadata.
+The metadata areas are treated as circular buffers, so
+unused space becomes filled with an archive of the most recent
+previous versions of the metadata.
+.IP
+\fBdirs\fP \(em List of directories holding live copies of LVM2
+metadata as text files.  These directories must not be on logical
+volumes.  It is possible to use LVM2 with a couple of directories
+here, preferably on different (non-logical-volume) filesystems
+and with no other on-disk metadata, \fBpvmetadatacopies = 0\fP.
+Alternatively these directories can be in addition to the
+on-disk metadata areas.  This feature was created during the
+development of the LVM2 metadata before the new on-disk metadata
+areas were designed and no longer gets tested.  
+It is not supported under low-memory conditions, and it is 
+important never to edit these metadata files unless you fully 
+understand how things work: to make changes you should always use 
+the tools as normal, or else vgcfgbackup, edit backup, vgcfgrestore.
 .SH FILES
 .I /etc/lvm/lvm.conf
-.br
-.I $HOME/.lvm_history
+.I /etc/lvm/.cache
+.I /etc/lvm/archive
+.I /etc/lvm/backup
+.I /var/lock/lvm
 .SH SEE ALSO
-.BR lvm (8)
-.BR umask (2)
-.BR syslog (3)
+.BR lvm (8),
+.BR umask (2),
+.BR uname (2),
+.BR dlopen (3),
+.BR syslog (3),
 .BR syslog.conf (5)

man/lvreduce.8

@@ -15,12 +15,16 @@ reduced part is lost!!!
 .br 
 You should therefore ensure that any filesystem on the volume is 
 resized
-.i before
+.I before
 running lvreduce so that the extents that are to be removed are not in use.
-.br.
+.br
 Shrinking snapshot logical volumes (see
 .B lvcreate(8)
 for information to create snapshots) is supported as well.
+.br
+Sizes will be rounded if necessary - for example, the volume size must
+be an exact number of extents and the size of a striped segment must
+be a multiple of the number of stripes.
 .SH OPTIONS
 See \fBlvm\fP for common options.
 .TP
@@ -41,11 +45,12 @@ With the - sign the value will be subtracted from
 the logical volume's actual size and without it it will be taken as
 an absolute size.
 .SH Example
-"lvreduce -l -3 /dev/vg00/lvol1" reduces the size of logical volume lvol1
+"lvreduce -l -3 vg00/lvol1" reduces the size of logical volume lvol1
 in volume group vg00 by 3 logical extents.
 .SH SEE ALSO
-.BR lvm (8), 
+.BR lvchange (8),
 .BR lvcreate (8), 
 .BR lvextend (8), 
-.BR lvresize (8), 
-.BR lvchange (8)
+.BR lvm (8), 
+.BR lvresize (8),
+.BR vgreduce (8)

man/lvremove.8

@@ -8,17 +8,28 @@ lvremove \- remove a logical volume
 [\-t/\-\-test]
 [\-v/\-\-verbose] LogicalVolumePath [LogicalVolumePath...]
 .SH DESCRIPTION
-lvremove allows you to remove one or more inactive logical volumes.
+\fBlvremove\fP removes one or more logical volumes.
+Confirmation will be requested before deactivating any active logical
+volume prior to removal.  Logical volumes cannot be deactivated
+or removed while they are open (e.g. if they contain a mounted filesystem).
 .SH OPTIONS
-See \fBlvm\fP for common options.
+See \fBlvm\fP(8) for common options.
 .TP
 .I \-f, \-\-force
-Force remove without confirmation.
-.SH Example
-"lvremove -f /dev/vg00/lvol1" removes that inactive logical volume
-unconditionally.
+Remove active logical volumes without confirmation.
+.SH EXAMPLES
+Remove the active logical volume lvol1 in volume group vg00 
+without asking for confirmation:
+.sp
+\	\fBlvremove -f vg00/lvol1\fP
+.sp
+Remove all logical volumes in volume group vg00:
+.sp
+\	\fBlvremove vg00\fP
 .SH SEE ALSO
-.BR lvm (8), 
 .BR lvcreate (8), 
 .BR lvdisplay (8), 
-.BR lvscan (8)
+.BR lvm (8), 
+.BR lvs (8),
+.BR lvscan (8),
+.BR vgremove (8)

man/lvresize.8

@@ -3,6 +3,7 @@
 lvresize \- resize a logical volume
 .SH SYNOPSIS
 .B lvresize
+[\-\-alloc AllocationPolicy]
 [\-A/\-\-autobackup y/n] [\-d/\-\-debug] [\-h/\-?/\-\-help]
 [\-i/\-\-stripes Stripes [\-I/\-\-stripesize StripeSize]]
 {\-l/\-\-extents [+]LogicalExtentsNumber |
@@ -27,7 +28,7 @@ With the + or - sign the value is added to or subtracted from the actual size
 of the logical volume and without it, the value is taken as an absolute one.
 .TP
 .I \-L, \-\-size [+/-]LogicalVolumeSize[kKmMgGtT]
-Change or set the logical volume size in units in units of megabytes.
+Change or set the logical volume size in units of megabytes.
 A size suffix of M for megabytes, G for gigabytes or T for terabytes is
 optional.  With the + or - sign the value is added to or subtracted from
 the actual size of the logical volume and without it, the value is taken as an