Support new target message ioctl.

sourced from http://poochiereds.net/svn/lvm2/

BUGS

@@ -1,2 +0,0 @@
-Snapshots under 2.4.18 can deadlock due to a bug in the VM system.
-2.4.19-pre8 is fine.

INSTALL

@@ -6,8 +6,8 @@ LVM2 installation
    Ensure the device-mapper has been installed on the machine.
 
    The device-mapper should be in the kernel (look for 'device-mapper'
-   messages in the kernel logs) and /usr/include/libdevmapper.h should 
-   be present.
+   messages in the kernel logs) and /usr/include/libdevmapper.h 
+   and libdevmapper.so should be present.
 
    The device-mapper is available from:
      ftp://ftp.sistina.com/pub/LVM2/device-mapper/
@@ -17,9 +17,15 @@ LVM2 installation
 
    Run the 'configure' script from the top directory.
 
-   If you do not have GNU readline (http://www.gnu.org/directory/readline.html)
-   installed use
-     ./configure --disable-readline
+   If you wish to use the built-in LVM2 shell and have GNU readline 
+   installed (http://www.gnu.org/directory/readline.html) use:
+     ./configure --enable-readline
+
+   If you don't want to include the LVM1 backwards-compatibility code use:
+     ./configure --with-lvm1=none 
+
+   To separate the LVM1 support into a shared library loaded by lvm.conf use:
+     ./configure --with-lvm1=shared
 
 
 3) Build and install LVM2.
@@ -31,6 +37,9 @@ LVM2 installation
 
    The tools will work fine without a configuration file being
    present, but you ought to review the example file in doc/example.conf.
-   For example, specifying the devices that LVM2 is to use should
+   For example, specifying the devices that LVM2 is to use can
    make the tools run more efficiently - and avoid scanning /dev/cdrom!
 
+Please also refer to the WHATS_NEW file and the manual pages for the 
+individual commands.
+

INTRO

@@ -1,18 +0,0 @@
-An introduction to LVM2
-=======================
-
-Background
-
-
-Compatibility with LVM1
-
-
-New features
-
-
-Missing features
-
-
-Future enhancements
-
-

Makefile.in

@@ -1,34 +1,48 @@
 #
-# Copyright (C) 2001 Sistina Software
+# Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
 #
-# This LVM library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Library General Public
-# License as published by the Free Software Foundation; either
-# version 2 of the License, or (at your option) any later version.
+# This file is part of the LVM2.
 #
-# This LVM library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Library General Public License for more details.
+# 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 Library General Public
-# License along with this LVM library; if not, write to the Free
-# Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-# MA 02111-1307, USA
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 
-SUBDIRS = include man lib tools
+SUBDIRS = doc include man 
+
+ifeq ("@INTL@", "yes")
+  SUBDIRS += po
+endif
+
+SUBDIRS += lib tools
 
 ifeq ($(MAKECMDGOALS),distclean)
-  SUBDIRS += test/mm test/device test/format1 test/regex test/filters
+  SUBDIRS += lib/format1 \
+	     lib/format_pool \
+	     lib/mirror \
+	     lib/snapshot \
+	     po \
+	     test/mm test/device test/format1 test/regex test/filters
 endif
 
 include make.tmpl
 
 lib: include
-tools: include lib
+tools: lib
+po: lib tools
 
+ifeq ("@INTL@", "yes")
+lib.pofile: include.pofile
+tools.pofile: lib.pofile
+po.pofile: lib.pofile tools.pofile
+pofile: po.pofile
+endif
 

README

@@ -1,13 +1,11 @@
-This directory contains a beta release of LMV2, the new version of 
-the userland LVM tools designed for the new device-mapper for 
-the Linux kernel.
+This directory contains LVM2, the new version of the userland LVM
+tools designed for the new device-mapper for the Linux kernel.
 
 The device-mapper needs to be installed before compiling these LVM2 tools.
 
-For more information about LVM2 read the INTRO file.
+For more information about LVM2 read the WHATS_NEW file.
 Installation instructions are in INSTALL.
 
-This is beta-quality software, released for testing purposes only.
 There is no warranty - see COPYING and COPYING.LIB.
 
 Tarballs are available from:
@@ -15,11 +13,11 @@ Tarballs are available from:
   ftp://ftp.sistina.com/pub/LVM2/device-mapper/
 
 To access the CVS tree use:
-  cvs -d :pserver:cvs@tech.sistina.com:/data/cvs login
-  CVS password: cvs1
-  cvs -d :pserver:cvs@tech.sistina.com:/data/cvs checkout LVM2
+  cvs -d :pserver:cvs@sources.redhat.com:/cvs/lvm2 login
+  CVS password: cvs
+  cvs -d :pserver:cvs@sources.redhat.com:/cvs/lvm2 co LVM2
 
 Mailing list for discussion/bug reports etc.
-  lvm-devel@sistina.com
-  Subscribe from http://lists.sistina.com/mailman/listinfo/lvm-devel
+  linux-lvm@redhat.com
+  Subscribe from https://www.redhat.com/mailman/listinfo/linux-lvm
 

TODO

@@ -1,28 +0,0 @@
-before 2.0
------------
-
-vgexport
-vgimport
-snapshots
-pvmove
-device-mapper support for 2.5 kernel series
-review FIXMEs
-extra validation & full consistency checks in format1 with LVM1
-partial activation (aka VG quorum)
-error message review
-locking during metadata changes
-format2 with atomic transactions
-bidirectional format1/format2 migration tool
-persistent minors
-statistics target and tool support
-review tool exit codes for LVM1 compatibility
-
-before 2.1
-----------
-
-e2fsadm
-lvmsadc
-lvmsar
-pvdata
-vgsplit
-vgmknodes

VERSION

@@ -1 +1 @@
-1.95.10-cvs (2002-05-31)
+2.00.16-cvs (2004-05-24)

WHATS_NEW

@@ -0,0 +1,220 @@
+Version 2.00.17 -
+=============================
+  Add read-only GFS pool support.
+  Add lvm2create_initrd script from http://poochiereds.net/svn/lvm2/
+  Fix rounding of large diplayed sizes.
+  Suppress decimal point when using units of sectors/bytes.
+  Additional kernel target checks before pvmove & snapshot creation.
+  Add i2o_block.
+
+Version 2.00.16 - 24 May 2004
+=============================
+  Set area_count within alloc_lv_segment.
+  Remove error labels from lvresize.
+  Fix a pvs error path.
+  xxchange -ae for exclusive activation.
+  Don't return non-zero status if there aren't any volume groups.
+  Add --alloc argument to tools.
+  Rename allocation policies to contiguous, normal, anywhere, inherit.
+  nextfree becomes normal; anywhere isn't implemented yet.
+  LV inherits allocation policy from VG. Defaults: LV - inherit; VG - normal
+  Additional status character added to vgs to indicate allocation policy.
+  Add reset_fn to external_locking.
+  Ensure presence of virtual targets before attempting activating.
+  Attempt to fix resizing of snapshot origins.
+  Restructure lvresize, bringing it closer to lvcreate.
+  A quick sanity check on vg_disk struct when read in.  More checks needed.
+  Only include visible LVs in active/open counts.
+  Add virtual segment types, zero and error.  A large sparse device can be
+constructed as a writeable snapshot of a large zero segment.
+  Add --type to lvcreate/resize.
+  Push lv_create & alloc policy up to tool level.
+  Fix pvdisplay return code.
+  Detect invalid LV names in arg lists.
+  Reporting uses line-at-a-time output.
+  lvm2 format sets unlimited_vols format flag.
+  Internal-only metadata flag support.
+  Basic checking for presence of device-mapper targets.
+  Separate out polldaemon.
+  Revise internal locking semantics.
+  Move find_pv_by_name to library.
+  Rename move->copy.
+  Add devices to segments report.
+  Begin separating out segment code. There's a lot of change here.
+  Compress any (obsolete) long LVM1 pvids encountered.
+  Support for tagged config files.
+  Don't abort operations if selinux present but disabled.
+  Fix typo in configure which left HAVE_LIBDL unset.
+
+Version 2.00.15 - 19 Apr 2004
+=============================
+  configure --with-owner= --with-group= to avoid -o and -g args to 'install'
+
+Version 2.00.14 - 16 Apr 2004
+=============================
+  Use 64-bit file functions by default.
+
+Version 2.00.13 - 16 Apr 2004
+=============================
+  Set devices/md_component_detection = 1 to ignore devices containing md
+  superblocks. [Luca Berra]
+  Ignore error setting selinux file context if fs doesn't support it.
+
+Version 2.00.12 - 14 Apr 2004
+=============================
+  Install a default lvm.conf into /etc/lvm if there isn't one already.
+  Allow different installation dir for lvm.static (configure --staticdir=)
+  Fix inverted selinux error check.
+  Recognise power2 in /proc/devices.
+  Fix counting in lvs_in_vg_opened. [It ignored devices open more than once.]
+
+Version 2.00.11 - 8 Apr 2004
+============================
+  Set fallback_to_lvm1 in lvm.conf (or configure --enable-lvm1_fallback)
+  to run lvm1 binaries if running a 2.4 kernel without device-mapper.
+
+Version 2.00.10 - 7 Apr 2004
+============================
+  More fixes for static build.
+  Add basic selinux support.
+  Fix sysfs detection.
+
+Version 2.00.09 - 31 Mar 2004
+=============================
+  Update copyright notices for Red Hat.
+  Fix vgmknodes to remove dud /dev/mapper entries. (libdevmapper update reqd).
+  Add LVM1-style colon output to vgdisplay.
+  lvchange --refresh to reload active LVs.
+  Add string display to memory leak dump.
+  Add locking flags & memlock option.
+  Add list_versions to library.
+  Ignore open hidden LVs when checking if deactivation is OK.
+  Suppress move percentage when device inactive.
+  Add lv_info_by_lvid.
+  Various tidy-ups to the build process.
+  Rebaseline internal verbose level.
+  Add --nolocking option for read operations if locking is failing.
+  Add option to compile into a library.
+  When compiled without libdevmapper, only print warning message once.
+  Fix lvreduce PV extent calculations.
+  Fix DESTDIR to work with configure path overrides.
+  Always use / as config file separator & rename internal config file variables.
+  Add support for tagging PV/VG/LVs and hosts.
+  Fix rare bug in recognition of long cmdline argument forms.
+  Add basic internationalisation infrastructure.
+  Don't recurse symlinked dirs such as /dev/fd on 2.6 kernels.
+  Update autoconf files.
+  Add sysfs block device filtering for 2.6 kernels.
+  Update refs for move to sources.redhat.com.
+
+Friday 14th November 2003
+=========================
+Some bug fixes & minor enhancements, including:
+  Backwards compatibility with LVM1 metadata improved.
+  Missing man pages written.
+  Tool error codes made more consistent.
+  vgmknodes written.
+  O_DIRECT can be turned off if it doesn't work in your kernel.
+  dumpconfig to display the active configuration file
+
+You need to update libdevmapper before using 'vgmknodes' or 'vgscan --mknodes'.
+If your root filesystem is on an LV, you should run one of those two
+commands to fix up the special files in /dev in your real root filesystem 
+after finishing with your initrd.  Also, remember you can use
+'vgchange --ignorelockingfailure' on your initrd if the tool fails because
+it can't write a lock file to a read-only filesystem.
+
+Wednesday 30th April 2003
+=========================
+A pvmove implementation is now available for the new metadata format.
+
+When running a command that allocates space (e.g. lvcreate), you can now
+restrict not only which disk(s) may be used but also the Physical Extents 
+on those disks.  e.g. lvcreate -L 10 vg1 /dev/hda6:1000-2000:3000-4000
+
+
+Monday 18th November 2002
+========================
+
+The new format of LVM metadata is ready for you to test!
+  We expect it to be more efficient and more robust than the original format.
+  It's more compact and supports transactional changes and replication.
+  Should things go wrong on a system, it's human-readable (and editable).
+
+Please report any problems you find to the mailing list, 
+linux-lvm@sistina.com.  The software has NOT yet been thoroughly
+tested and so quite possibly there'll still be some bugs in it.
+Be aware of the disclaimer in the COPYING file.
+
+While testing, we recommend turning logging on in the configuration file 
+to provide us with diagnostic information:
+  log {
+        file="/tmp/lvm2.log"
+	level=7
+	activation=1
+  }
+
+You should schedule regular backups of your configuration file and
+metadata backups and archives (normally kept under /etc/lvm).
+
+Please read docs/example.conf and "man lvm.conf" to find out more about 
+the configuration file.
+
+To convert an existing volume group called vg1 to the new format using
+the default settings, use "vgconvert -M2 vg1".  See "man vgconvert".
+
+-M (or --metadatatype in its long form) is a new flag to indicate which
+format of metadata the command should use for anything it creates.
+Currently, the valid types are "lvm1" and "lvm2" and they can be
+abbreviated to "1" and "2" respectively.  The default value for this
+flag can be changed in the global section in the config file.
+
+Backwards-compatible support for the original LVM1 metadata format is
+maintained, but it can be moved into a shared library or removed
+completely with configure's --with-lvm1 option.
+
+Under LVM2, the basic unit of metadata is the volume group.  Different
+volume groups can use different formats of metadata - vg1 could use
+the original LVM1 format while vg2 used the new format - but you can't
+mix formats within a volume group.  So to add a PV to an LVM2-format
+volume group you must run "pvcreate -M2" on it, followed by "vgextend".
+
+With LVM2-format metadata, lvextend will let you specify striping
+parameters.  So an LV could consist of two or more "segments" - the
+first segment could have 3 stripes while the second segment has just 2.
+
+LVM2 maintains a backup of the current metadata for each volume group
+in /etc/lvm/backup, and puts copies of previous versions in
+/etc/lvm/archive.  "vgcfgbackup" and "vgcfgrestore" can be used to
+create and restore from these files.  If you fully understand what 
+you're doing, metadata can be changed by editing a copy of a current
+backup file and using vgcfgrestore to reload it.
+
+Please read the pvcreate man page for more information on the new
+format for metadata.
+
+All tools that can change things have a --test flag which can be used
+to check the effect  of a set of cmdline args without really making the
+changes.
+
+
+What's not finished?
+====================
+The internal cache.  If you turn on debugging output you'll see lots of
+repeated messages, many of which will eventually get optimised out.
+
+--test sometimes causes a command to fail (e.g. vgconvert --test) even 
+though the real command would work: again, fixing this is waiting for 
+the work on the cache.
+
+Several of the tools do not yet contain the logic to handle full
+recovery: combinations of pvcreate and vgcfgrestore may sometimes be
+needed to restore metadata if a tool gets interrupted or crashes or
+finds something unexpected.  This applies particularly to tools that
+work on more than one volume group at once (e.g. vgsplit).
+
+Display output.  Some metadata information cannot yet be displayed.
+
+Recovery tools to salvage "lost" metadata directly from the disks:
+but we hope the new format will mean such tools are hardly ever needed!
+

WHATS_NEW_DM

@@ -0,0 +1,63 @@
+Version 1.00.18
+=============================
+  Add target message-passing ioctl.
+
+Version 1.00.17 - 17 Apr 2004
+=============================
+  configure --with-owner= --with-group= to avoid -o and -g args to 'install'
+  Fix library selinux linking.
+
+Version 1.00.16 - 16 Apr 2004
+=============================
+  Ignore error setting selinux file context if fs doesn't support it.
+
+Version 1.00.15 - 7 Apr 2004
+============================
+  Fix status overflow check in kernel patches.
+
+Version 1.00.14 - 6 Apr 2004
+============================
+  Fix static selinux build.
+
+Version 1.00.13 - 6 Apr 2004
+============================
+  Add some basic selinux support.
+
+Version 1.00.12 - 6 Apr 2004
+============================
+  Fix dmsetup.static install.
+
+Version 1.00.11 - 5 Apr 2004
+============================
+  configure --enable-static_link does static build in addition to dynamic.
+  Moved Makefile library targets definition into template.
+
+Version 1.00.10 - 2 Apr 2004
+============================
+  Fix DESTDIR handling.
+  Static build installs to dmsetup.static.
+  Basic support for internationalisation.
+  Minor Makefile tidy-ups/fixes.
+
+Version 1.00.09 - 31 Mar 2004
+=============================
+  Update copyright notices to Red Hat.
+  Move full mknodes functionality from dmsetup into libdevmapper.
+  Avoid sscanf %as for uClibc compatibility.
+  Cope if DM_LIST_VERSIONS is not defined.
+  Add DM_LIST_VERSIONS functionality to kernel patches.
+  Generate new kernel patches for 2.4.26-rc1.
+
+Version 1.00.08 - 27 Feb 2004
+=============================
+  Added 'dmsetup targets'.
+  Added event_nr support to 'dmsetup wait'.
+  Updated dmsetup man page.
+  Allow logging function to be reset to use internal one.
+  Bring log macros in line with LVM2 ones.
+  Added 'make install_static_lib' which installs libdevmapper.a.
+  Made configure/makefiles closer to LVM2 versions.
+  Fixed DESTDIR for make install/install_static_lib.
+  Updated README/INSTALL to reflect move to sources.redhat.com.
+  Updated autoconf files to 2003-06-17.
+

autoconf/config.sub

@@ -1,6 +1,10 @@
 #! /bin/sh
-# Configuration validation subroutine script, version 1.1.
-#   Copyright (C) 1991, 92-97, 1998, 1999 Free Software Foundation, Inc.
+# Configuration validation subroutine script.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+
+timestamp='2003-06-17'
+
 # This file is (in principle) common to ALL GNU software.
 # The presence of a machine in this file suggests that SOME GNU software
 # can handle that machine.  It does not imply ALL GNU software can.
@@ -25,6 +29,9 @@
 # configuration script generated by Autoconf, you may include it under
 # the same distribution terms that you use for the rest of that program.
 
+# Please send patches to <config-patches@gnu.org>.  Submit a context
+# diff and a properly formatted ChangeLog entry.
+#
 # Configuration subroutine to validate and canonicalize a configuration type.
 # Supply the specified configuration type as an argument.
 # If it is invalid, we print an error message on stderr and exit with code 1.
@@ -45,30 +52,73 @@
 #	CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
 # It is wrong to echo any other type of specification.
 
-if [ x$1 = x ]
-then
-	echo Configuration name missing. 1>&2
-	echo "Usage: $0 CPU-MFR-OPSYS" 1>&2
-	echo "or     $0 ALIAS" 1>&2
-	echo where ALIAS is a recognized configuration type. 1>&2
-	exit 1
-fi
+me=`echo "$0" | sed -e 's,.*/,,'`
 
-# First pass through any local machine types.
-case $1 in
-	*local*)
-		echo $1
-		exit 0
-		;;
-	*)
-	;;
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+       $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit 0 ;;
+    --version | -v )
+       echo "$version" ; exit 0 ;;
+    --help | --h* | -h )
+       echo "$usage"; exit 0 ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help"
+       exit 1 ;;
+
+    *local*)
+       # First pass through any local machine types.
+       echo $1
+       exit 0;;
+
+    * )
+       break ;;
+  esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+    exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+    exit 1;;
 esac
 
 # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
 # Here we must recognize all the valid KERNEL-OS combinations.
 maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
 case $maybe_os in
-  linux-gnu*)
+  nto-qnx* | linux-gnu* | freebsd*-gnu* | netbsd*-gnu* | storm-chaos* | os2-emx* | rtmk-nova*)
     os=-$maybe_os
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
     ;;
@@ -94,7 +144,7 @@ case $os in
 	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
 	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
 	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple)
+	-apple | -axis)
 		os=
 		basic_machine=$1
 		;;
@@ -105,9 +155,17 @@ case $os in
 	-scout)
 		;;
 	-wrs)
-		os=vxworks
+		os=-vxworks
 		basic_machine=$1
 		;;
+	-chorusos*)
+		os=-chorusos
+		basic_machine=$1
+		;;
+ 	-chorusrdb)
+ 		os=-chorusrdb
+		basic_machine=$1
+ 		;;
 	-hiux*)
 		os=-hiuxwe2
 		;;
@@ -156,33 +214,72 @@ case $os in
 	-psos*)
 		os=-psos
 		;;
+	-mint | -mint[0-9]*)
+		basic_machine=m68k-atari
+		os=-mint
+		;;
 esac
 
 # Decode aliases for certain CPU-COMPANY combinations.
 case $basic_machine in
 	# Recognize the basic CPU types without company name.
 	# Some are omitted here because they have special meanings below.
-	tahoe | i860 | ia64 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \
-		| arme[lb] | pyramid | mn10200 | mn10300 | tron | a29k \
-		| 580 | i960 | h8300 \
-		| hppa | hppa1.0 | hppa1.1 | hppa2.0 | hppa2.0w | hppa2.0n \
-		| alpha | alphaev[4-7] | alphaev56 | alphapca5[67] \
-		| we32k | ns16k | clipper | i370 | sh | powerpc | powerpcle \
-		| 1750a | dsp16xx | pdp11 | mips16 | mips64 | mipsel | mips64el \
-		| mips64orion | mips64orionel | mipstx39 | mipstx39el \
-		| mips64vr4300 | mips64vr4300el | mips64vr4100 | mips64vr4100el \
-		| mips64vr5000 | miprs64vr5000el | mcore \
-		| sparc | sparclet | sparclite | sparc64 | sparcv9 | v850 | c4x \
-		| thumb | d10v)
+	1750a | 580 \
+	| a29k \
+	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
+	| c4x | clipper \
+	| d10v | d30v | dlx | dsp16xx \
+	| fr30 | frv \
+	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+	| i370 | i860 | i960 | ia64 \
+	| ip2k \
+	| m32r | m68000 | m68k | m88k | mcore \
+	| mips | mipsbe | mipseb | mipsel | mipsle \
+	| mips16 \
+	| mips64 | mips64el \
+	| mips64vr | mips64vrel \
+	| mips64orion | mips64orionel \
+	| mips64vr4100 | mips64vr4100el \
+	| mips64vr4300 | mips64vr4300el \
+	| mips64vr5000 | mips64vr5000el \
+	| mipsisa32 | mipsisa32el \
+	| mipsisa32r2 | mipsisa32r2el \
+	| mipsisa64 | mipsisa64el \
+	| mipsisa64sb1 | mipsisa64sb1el \
+	| mipsisa64sr71k | mipsisa64sr71kel \
+	| mipstx39 | mipstx39el \
+	| mn10200 | mn10300 \
+	| msp430 \
+	| ns16k | ns32k \
+	| openrisc | or32 \
+	| pdp10 | pdp11 | pj | pjl \
+	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+	| pyramid \
+	| sh | sh[1234] | sh[23]e | sh[34]eb | shbe | shle | sh[1234]le | sh3ele \
+	| sh64 | sh64le \
+	| sparc | sparc64 | sparc86x | sparclet | sparclite | sparcv9 | sparcv9b \
+	| strongarm \
+	| tahoe | thumb | tic4x | tic80 | tron \
+	| v850 | v850e \
+	| we32k \
+	| x86 | xscale | xstormy16 | xtensa \
+	| z8k)
 		basic_machine=$basic_machine-unknown
 		;;
-	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | z8k | v70 | h8500 | w65)
+	m6811 | m68hc11 | m6812 | m68hc12)
+		# Motorola 68HC11/12.
+		basic_machine=$basic_machine-unknown
+		os=-none
+		;;
+	m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
 		;;
 
 	# We use `pc' rather than `unknown'
 	# because (1) that's what they normally are, and
 	# (2) the word "unknown" tends to confuse beginning users.
-	i[34567]86)
+	i*86 | x86_64)
 	  basic_machine=$basic_machine-pc
 	  ;;
 	# Object if more than one company name word.
@@ -191,24 +288,60 @@ case $basic_machine in
 		exit 1
 		;;
 	# Recognize the basic CPU types with company name.
-	# FIXME: clean up the formatting here.
-	vax-* | tahoe-* | i[34567]86-* | i860-* | ia64-* | m32r-* | m68k-* | m68000-* \
-	      | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \
-	      | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
-	      | power-* | none-* | 580-* | cray2-* | h8300-* | h8500-* | i960-* \
-	      | xmp-* | ymp-* \
-	      | hppa-* | hppa1.0-* | hppa1.1-* | hppa2.0-* | hppa2.0w-* | hppa2.0n-* \
-	      | alpha-* | alphaev[4-7]-* | alphaev56-* | alphapca5[67]-* \
-	      | we32k-* | cydra-* | ns16k-* | pn-* | np1-* | xps100-* \
-	      | clipper-* | orion-* \
-	      | sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
-	      | sparc64-* | sparcv9-* | sparc86x-* | mips16-* | mips64-* | mipsel-* \
-	      | mips64el-* | mips64orion-* | mips64orionel-* \
-	      | mips64vr4100-* | mips64vr4100el-* | mips64vr4300-* | mips64vr4300el-* \
-	      | mipstx39-* | mipstx39el-* | mcore-* \
-	      | f301-* | armv*-* | t3e-* \
-	      | m88110-* | m680[01234]0-* | m683?2-* | m68360-* | z8k-* | d10v-* \
-	      | thumb-* | v850-* | d30v-* | tic30-* | c30-* )
+	580-* \
+	| a29k-* \
+	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
+	| avr-* \
+	| bs2000-* \
+	| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+	| clipper-* | cydra-* \
+	| d10v-* | d30v-* | dlx-* \
+	| elxsi-* \
+	| f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \
+	| h8300-* | h8500-* \
+	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+	| i*86-* | i860-* | i960-* | ia64-* \
+	| ip2k-* \
+	| m32r-* \
+	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+	| m88110-* | m88k-* | mcore-* \
+	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+	| mips16-* \
+	| mips64-* | mips64el-* \
+	| mips64vr-* | mips64vrel-* \
+	| mips64orion-* | mips64orionel-* \
+	| mips64vr4100-* | mips64vr4100el-* \
+	| mips64vr4300-* | mips64vr4300el-* \
+	| mips64vr5000-* | mips64vr5000el-* \
+	| mipsisa32-* | mipsisa32el-* \
+	| mipsisa32r2-* | mipsisa32r2el-* \
+	| mipsisa64-* | mipsisa64el-* \
+	| mipsisa64sb1-* | mipsisa64sb1el-* \
+	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
+	| mipstx39-* | mipstx39el-* \
+	| msp430-* \
+	| none-* | np1-* | nv1-* | ns16k-* | ns32k-* \
+	| orion-* \
+	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+	| pyramid-* \
+	| romp-* | rs6000-* \
+	| sh-* | sh[1234]-* | sh[23]e-* | sh[34]eb-* | shbe-* \
+	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+	| sparc-* | sparc64-* | sparc86x-* | sparclet-* | sparclite-* \
+	| sparcv9-* | sparcv9b-* | strongarm-* | sv1-* | sx?-* \
+	| tahoe-* | thumb-* \
+	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+	| tron-* \
+	| v850-* | v850e-* | vax-* \
+	| we32k-* \
+	| x86-* | x86_64-* | xps100-* | xscale-* | xstormy16-* \
+	| xtensa-* \
+	| ymp-* \
+	| z8k-*)
 		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
@@ -240,19 +373,22 @@ case $basic_machine in
 		basic_machine=a29k-none
 		os=-bsd
 		;;
+	amd64)
+		basic_machine=x86_64-pc
+		;;
 	amdahl)
 		basic_machine=580-amdahl
 		os=-sysv
 		;;
 	amiga | amiga-*)
-		basic_machine=m68k-cbm
+		basic_machine=m68k-unknown
 		;;
 	amigaos | amigados)
-		basic_machine=m68k-cbm
+		basic_machine=m68k-unknown
 		os=-amigaos
 		;;
 	amigaunix | amix)
-		basic_machine=m68k-cbm
+		basic_machine=m68k-unknown
 		os=-sysv4
 		;;
 	apollo68)
@@ -271,6 +407,10 @@ case $basic_machine in
 		basic_machine=ns32k-sequent
 		os=-dynix
 		;;
+	c90)
+		basic_machine=c90-cray
+		os=-unicos
+		;;
 	convex-c1)
 		basic_machine=c1-convex
 		os=-bsd
@@ -291,27 +431,30 @@ case $basic_machine in
 		basic_machine=c38-convex
 		os=-bsd
 		;;
-	cray | ymp)
-		basic_machine=ymp-cray
-		os=-unicos
-		;;
-	cray2)
-		basic_machine=cray2-cray
-		os=-unicos
-		;;
-	[ctj]90-cray)
-		basic_machine=c90-cray
+	cray | j90)
+		basic_machine=j90-cray
 		os=-unicos
 		;;
 	crds | unos)
 		basic_machine=m68k-crds
 		;;
+	cris | cris-* | etrax*)
+		basic_machine=cris-axis
+		;;
 	da30 | da30-*)
 		basic_machine=m68k-da30
 		;;
 	decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
 		basic_machine=mips-dec
 		;;
+	decsystem10* | dec10*)
+		basic_machine=pdp10-dec
+		os=-tops10
+		;;
+	decsystem20* | dec20*)
+		basic_machine=pdp10-dec
+		os=-tops20
+		;;
 	delta | 3300 | motorola-3300 | motorola-delta \
 	      | 3300-motorola | delta-motorola)
 		basic_machine=m68k-motorola
@@ -353,6 +496,10 @@ case $basic_machine in
 		basic_machine=tron-gmicro
 		os=-sysv
 		;;
+	go32)
+		basic_machine=i386-pc
+		os=-go32
+		;;
 	h3050r* | hiux*)
 		basic_machine=hppa1.1-hitachi
 		os=-hiuxwe2
@@ -426,22 +573,21 @@ case $basic_machine in
 		;;
 	i370-ibm* | ibm*)
 		basic_machine=i370-ibm
-		os=-mvs
 		;;
 # I'm not sure what "Sysv32" means.  Should this be sysv3.2?
-	i[34567]86v32)
+	i*86v32)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv32
 		;;
-	i[34567]86v4*)
+	i*86v4*)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv4
 		;;
-	i[34567]86v)
+	i*86v)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv
 		;;
-	i[34567]86sol2)
+	i*86sol2)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-solaris2
 		;;
@@ -453,14 +599,6 @@ case $basic_machine in
 		basic_machine=i386-unknown
 		os=-vsta
 		;;
-	i386-go32 | go32)
-		basic_machine=i386-unknown
-		os=-go32
-		;;
-	i386-mingw32 | mingw32)
-		basic_machine=i386-unknown
-		os=-mingw32
-		;;
 	iris | iris4d)
 		basic_machine=mips-sgi
 		case $os in
@@ -486,35 +624,43 @@ case $basic_machine in
 		basic_machine=ns32k-utek
 		os=-sysv
 		;;
+	mingw32)
+		basic_machine=i386-pc
+		os=-mingw32
+		;;
 	miniframe)
 		basic_machine=m68000-convergent
 		;;
-	*mint | *MiNT)
+	*mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
 		basic_machine=m68k-atari
 		os=-mint
 		;;
-	mipsel*-linux*)
-		basic_machine=mipsel-unknown
-		os=-linux-gnu
-		;;
-	mips*-linux*)
-		basic_machine=mips-unknown
-		os=-linux-gnu
-		;;
 	mips3*-*)
 		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
 		;;
 	mips3*)
 		basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
 		;;
+	mmix*)
+		basic_machine=mmix-knuth
+		os=-mmixware
+		;;
 	monitor)
 		basic_machine=m68k-rom68k
 		os=-coff
 		;;
+	morphos)
+		basic_machine=powerpc-unknown
+		os=-morphos
+		;;
 	msdos)
-		basic_machine=i386-unknown
+		basic_machine=i386-pc
 		os=-msdos
 		;;
+	mvs)
+		basic_machine=i370-ibm
+		os=-mvs
+		;;
 	ncr3000)
 		basic_machine=i486-ncr
 		os=-sysv4
@@ -524,7 +670,7 @@ case $basic_machine in
 		os=-netbsd
 		;;
 	netwinder)
-		basic_machine=armv4l-corel
+		basic_machine=armv4l-rebel
 		os=-linux
 		;;
 	news | news700 | news800 | news900)
@@ -572,13 +718,28 @@ case $basic_machine in
 		basic_machine=i960-intel
 		os=-mon960
 		;;
+	nonstopux)
+		basic_machine=mips-compaq
+		os=-nonstopux
+		;;
 	np1)
 		basic_machine=np1-gould
 		;;
+	nv1)
+		basic_machine=nv1-cray
+		os=-unicosmp
+		;;
+	nsr-tandem)
+		basic_machine=nsr-tandem
+		;;
 	op50n-* | op60c-*)
 		basic_machine=hppa1.1-oki
 		os=-proelf
 		;;
+	or32 | or32-*)
+		basic_machine=or32-unknown
+		os=-coff
+		;;
 	OSE68000 | ose68000)
 		basic_machine=m68000-ericsson
 		os=-ose
@@ -601,45 +762,65 @@ case $basic_machine in
 	pbb)
 		basic_machine=m68k-tti
 		;;
-        pc532 | pc532-*)
+	pc532 | pc532-*)
 		basic_machine=ns32k-pc532
 		;;
-	pentium | p5 | k5 | k6 | nexen)
+	pentium | p5 | k5 | k6 | nexgen | viac3)
 		basic_machine=i586-pc
 		;;
-	pentiumpro | p6 | 6x86)
+	pentiumpro | p6 | 6x86 | athlon | athlon_*)
 		basic_machine=i686-pc
 		;;
-	pentiumii | pentium2)
+	pentiumii | pentium2 | pentiumiii | pentium3)
+		basic_machine=i686-pc
+		;;
+	pentium4)
 		basic_machine=i786-pc
 		;;
-	pentium-* | p5-* | k5-* | k6-* | nexen-*)
+	pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
 		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
-	pentiumpro-* | p6-* | 6x86-*)
+	pentiumpro-* | p6-* | 6x86-* | athlon-*)
 		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
-	pentiumii-* | pentium2-*)
+	pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	pentium4-*)
 		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	pn)
 		basic_machine=pn-gould
 		;;
-	power)	basic_machine=rs6000-ibm
+	power)	basic_machine=power-ibm
 		;;
 	ppc)	basic_machine=powerpc-unknown
-	        ;;
+		;;
 	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	ppcle | powerpclittle | ppc-le | powerpc-little)
 		basic_machine=powerpcle-unknown
-	        ;;
+		;;
 	ppcle-* | powerpclittle-*)
 		basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
+	ppc64)	basic_machine=powerpc64-unknown
+		;;
+	ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
+	ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+		basic_machine=powerpc64le-unknown
+		;;
+	ppc64le-* | powerpc64little-*)
+		basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+		;;
 	ps2)
 		basic_machine=i386-ibm
 		;;
+	pw32)
+		basic_machine=i586-unknown
+		os=-pw32
+		;;
 	rom68k)
 		basic_machine=m68k-rom68k
 		os=-coff
@@ -650,10 +831,26 @@ case $basic_machine in
 	rtpc | rtpc-*)
 		basic_machine=romp-ibm
 		;;
+	s390 | s390-*)
+		basic_machine=s390-ibm
+		;;
+	s390x | s390x-*)
+		basic_machine=s390x-ibm
+		;;
 	sa29200)
 		basic_machine=a29k-amd
 		os=-udi
 		;;
+	sb1)
+		basic_machine=mipsisa64sb1-unknown
+		;;
+	sb1el)
+		basic_machine=mipsisa64sb1el-unknown
+		;;
+	sei)
+		basic_machine=mips-sei
+		os=-seiux
+		;;
 	sequent)
 		basic_machine=i386-sequent
 		;;
@@ -661,7 +858,10 @@ case $basic_machine in
 		basic_machine=sh-hitachi
 		os=-hms
 		;;
-	sparclite-wrs)
+	sh64)
+		basic_machine=sh64-unknown
+		;;
+	sparclite-wrs | simso-wrs)
 		basic_machine=sparclite-wrs
 		os=-vxworks
 		;;
@@ -719,20 +919,44 @@ case $basic_machine in
 	sun386 | sun386i | roadrunner)
 		basic_machine=i386-sun
 		;;
+	sv1)
+		basic_machine=sv1-cray
+		os=-unicos
+		;;
 	symmetry)
 		basic_machine=i386-sequent
 		os=-dynix
 		;;
 	t3e)
-		basic_machine=t3e-cray
+		basic_machine=alphaev5-cray
 		os=-unicos
 		;;
+	t90)
+		basic_machine=t90-cray
+		os=-unicos
+		;;
+	tic54x | c54x*)
+		basic_machine=tic54x-unknown
+		os=-coff
+		;;
+	tic55x | c55x*)
+		basic_machine=tic55x-unknown
+		os=-coff
+		;;
+	tic6x | c6x*)
+		basic_machine=tic6x-unknown
+		os=-coff
+		;;
 	tx39)
 		basic_machine=mipstx39-unknown
 		;;
 	tx39el)
 		basic_machine=mipstx39el-unknown
 		;;
+	toad1)
+		basic_machine=pdp10-xkl
+		os=-tops20
+		;;
 	tower | tower-32)
 		basic_machine=m68k-ncr
 		;;
@@ -757,8 +981,8 @@ case $basic_machine in
 		os=-vms
 		;;
 	vpp*|vx|vx-*)
-               basic_machine=f301-fujitsu
-               ;;
+		basic_machine=f301-fujitsu
+		;;
 	vxworks960)
 		basic_machine=i960-wrs
 		os=-vxworks
@@ -779,13 +1003,13 @@ case $basic_machine in
 		basic_machine=hppa1.1-winbond
 		os=-proelf
 		;;
-	xmp)
-		basic_machine=xmp-cray
-		os=-unicos
-		;;
-        xps | xps100)
+	xps | xps100)
 		basic_machine=xps100-honeywell
 		;;
+	ymp)
+		basic_machine=ymp-cray
+		os=-unicos
+		;;
 	z8k-*-coff)
 		basic_machine=z8k-unknown
 		os=-sim
@@ -806,13 +1030,6 @@ case $basic_machine in
 	op60c)
 		basic_machine=hppa1.1-oki
 		;;
-	mips)
-		if [ x$os = x-linux-gnu ]; then
-			basic_machine=mips-unknown
-		else
-			basic_machine=mips-mips
-		fi
-		;;
 	romp)
 		basic_machine=romp-ibm
 		;;
@@ -822,16 +1039,26 @@ case $basic_machine in
 	vax)
 		basic_machine=vax-dec
 		;;
+	pdp10)
+		# there are many clones, so DEC is not a safe bet
+		basic_machine=pdp10-unknown
+		;;
 	pdp11)
 		basic_machine=pdp11-dec
 		;;
 	we32k)
 		basic_machine=we32k-att
 		;;
-	sparc | sparcv9)
+	sh3 | sh4 | sh[34]eb | sh[1234]le | sh[23]ele)
+		basic_machine=sh-unknown
+		;;
+	sh64)
+		basic_machine=sh64-unknown
+		;;
+	sparc | sparcv9 | sparcv9b)
 		basic_machine=sparc-sun
 		;;
-        cydra)
+	cydra)
 		basic_machine=cydra-cydrome
 		;;
 	orion)
@@ -846,9 +1073,8 @@ case $basic_machine in
 	pmac | pmac-mpw)
 		basic_machine=powerpc-apple
 		;;
-	c4x*)
-		basic_machine=c4x-none
-		os=-coff
+	*-unknown)
+		# Make sure to match an already-canonicalized machine name.
 		;;
 	*)
 		echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
@@ -906,14 +1132,34 @@ case $os in
 	      | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
 	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
 	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+	      | -chorusos* | -chorusrdb* \
 	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
 	      | -mingw32* | -linux-gnu* | -uxpv* | -beos* | -mpeix* | -udk* \
-	      | -interix* | -uwin* | -rhapsody* | -openstep* | -oskit*)
+	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei*)
 	# Remember, each alternative MUST END IN *, to match a version number.
 		;;
+	-qnx*)
+		case $basic_machine in
+		    x86-* | i*86-*)
+			;;
+		    *)
+			os=-nto$os
+			;;
+		esac
+		;;
+	-nto-qnx*)
+		;;
+	-nto*)
+		os=`echo $os | sed -e 's|nto|nto-qnx|'`
+		;;
 	-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
 	      | -windows* | -osx | -abug | -netware* | -os9* | -beos* \
-	      | -macos* | -mpw* | -magic* | -mon960* | -lnews*)
+	      | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
 		;;
 	-mac*)
 		os=`echo $os | sed -e 's|mac|macos|'`
@@ -927,6 +1173,12 @@ case $os in
 	-sunos6*)
 		os=`echo $os | sed -e 's|sunos6|solaris3|'`
 		;;
+	-opened*)
+		os=-openedition
+		;;
+	-wince*)
+		os=-wince
+		;;
 	-osfrose*)
 		os=-osfrose
 		;;
@@ -942,14 +1194,23 @@ case $os in
 	-acis*)
 		os=-aos
 		;;
+	-atheos*)
+		os=-atheos
+		;;
 	-386bsd)
 		os=-bsd
 		;;
 	-ctix* | -uts*)
 		os=-sysv
 		;;
+	-nova*)
+		os=-rtmk-nova
+		;;
 	-ns2 )
-	        os=-nextstep2
+		os=-nextstep2
+		;;
+	-nsk*)
+		os=-nsk
 		;;
 	# Preserve the version number of sinix5.
 	-sinix5.*)
@@ -985,8 +1246,14 @@ case $os in
 	-xenix)
 		os=-xenix
 		;;
-        -*mint | -*MiNT)
-	        os=-mint
+	-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+		os=-mint
+		;;
+	-aros*)
+		os=-aros
+		;;
+	-kaos*)
+		os=-kaos
 		;;
 	-none)
 		;;
@@ -1013,13 +1280,20 @@ case $basic_machine in
 	*-acorn)
 		os=-riscix1.2
 		;;
-	arm*-corel)
+	arm*-rebel)
 		os=-linux
 		;;
 	arm*-semi)
 		os=-aout
 		;;
-        pdp11-*)
+    c4x-* | tic4x-*)
+        os=-coff
+        ;;
+	# This must come before the *-dec entry.
+	pdp10-*)
+		os=-tops20
+		;;
+	pdp11-*)
 		os=-none
 		;;
 	*-dec | vax-*)
@@ -1046,6 +1320,9 @@ case $basic_machine in
 	mips*-*)
 		os=-elf
 		;;
+	or32-*)
+		os=-coff
+		;;
 	*-tti)	# must be before sparc entry or we get the wrong os.
 		os=-sysv3
 		;;
@@ -1109,25 +1386,25 @@ case $basic_machine in
 	*-next)
 		os=-nextstep3
 		;;
-        *-gould)
+	*-gould)
 		os=-sysv
 		;;
-        *-highlevel)
+	*-highlevel)
 		os=-bsd
 		;;
 	*-encore)
 		os=-bsd
 		;;
-        *-sgi)
+	*-sgi)
 		os=-irix
 		;;
-        *-siemens)
+	*-siemens)
 		os=-sysv4
 		;;
 	*-masscomp)
 		os=-rtu
 		;;
-	f301-fujitsu)
+	f30[01]-fujitsu | f700-fujitsu)
 		os=-uxpv
 		;;
 	*-rom68k)
@@ -1187,13 +1464,13 @@ case $basic_machine in
 			-genix*)
 				vendor=ns
 				;;
-			-mvs*)
+			-mvs* | -opened*)
 				vendor=ibm
 				;;
 			-ptx*)
 				vendor=sequent
 				;;
-			-vxsim* | -vxworks*)
+			-vxsim* | -vxworks* | -windiss*)
 				vendor=wrs
 				;;
 			-aux*)
@@ -1205,12 +1482,23 @@ case $basic_machine in
 			-mpw* | -macos*)
 				vendor=apple
 				;;
-			-*mint | -*MiNT)
+			-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
 				vendor=atari
 				;;
+			-vos*)
+				vendor=stratus
+				;;
 		esac
 		basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
 		;;
 esac
 
 echo $basic_machine$os
+exit 0
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:

autoconf/install-sh

@@ -1,19 +1,38 @@
 #!/bin/sh
-#
 # install - install a program, script, or datafile
-# This comes from X11R5 (mit/util/scripts/install.sh).
+
+scriptversion=2003-06-13.21
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
 #
-# Copyright 1991 by the Massachusetts Institute of Technology
+# Copyright (C) 1994 X Consortium
 #
-# Permission to use, copy, modify, distribute, and sell this software and its
-# documentation for any purpose is hereby granted without fee, provided that
-# the above copyright notice appear in all copies and that both that
-# copyright notice and this permission notice appear in supporting
-# documentation, and that the name of M.I.T. not be used in advertising or
-# publicity pertaining to distribution of the software without specific,
-# written prior permission.  M.I.T. makes no representations about the
-# suitability of this software for any purpose.  It is provided "as is"
-# without express or implied warranty.
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
 #
 # Calling this script install-sh is preferred over install.sh, to prevent
 # `make' implicit rules from creating a file called install from it
@@ -23,13 +42,11 @@
 # from scratch.  It can only install one file at a time, a restriction
 # shared with many OS's install programs.
 
-
 # set DOITPROG to echo to test this script
 
 # Don't use :- since 4.3BSD and earlier shells don't like it.
 doit="${DOITPROG-}"
 
-
 # put in absolute paths if you don't have them in your path; or use env. vars.
 
 mvprog="${MVPROG-mv}"
@@ -41,211 +58,229 @@ stripprog="${STRIPPROG-strip}"
 rmprog="${RMPROG-rm}"
 mkdirprog="${MKDIRPROG-mkdir}"
 
-transformbasename=""
-transform_arg=""
+transformbasename=
+transform_arg=
 instcmd="$mvprog"
 chmodcmd="$chmodprog 0755"
-chowncmd=""
-chgrpcmd=""
-stripcmd=""
+chowncmd=
+chgrpcmd=
+stripcmd=
 rmcmd="$rmprog -f"
 mvcmd="$mvprog"
-src=""
-dst=""
-dir_arg=""
+src=
+dst=
+dir_arg=
 
-while [ x"$1" != x ]; do
-    case $1 in
-	-c) instcmd="$cpprog"
-	    shift
-	    continue;;
+usage="Usage: $0 [OPTION]... SRCFILE DSTFILE
+   or: $0 -d DIR1 DIR2...
 
-	-d) dir_arg=true
-	    shift
-	    continue;;
+In the first form, install SRCFILE to DSTFILE, removing SRCFILE by default.
+In the second, create the directory path DIR.
 
-	-m) chmodcmd="$chmodprog $2"
-	    shift
-	    shift
-	    continue;;
+Options:
+-b=TRANSFORMBASENAME
+-c         copy source (using $cpprog) instead of moving (using $mvprog).
+-d         create directories instead of installing files.
+-g GROUP   $chgrp installed files to GROUP.
+-m MODE    $chmod installed files to MODE.
+-o USER    $chown installed files to USER.
+-s         strip installed files (using $stripprog).
+-t=TRANSFORM
+--help     display this help and exit.
+--version  display version info and exit.
 
-	-o) chowncmd="$chownprog $2"
-	    shift
-	    shift
-	    continue;;
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG
+"
 
-	-g) chgrpcmd="$chgrpprog $2"
-	    shift
-	    shift
-	    continue;;
+while test -n "$1"; do
+  case $1 in
+    -b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+        shift
+        continue;;
 
-	-s) stripcmd="$stripprog"
-	    shift
-	    continue;;
+    -c) instcmd=$cpprog
+        shift
+        continue;;
 
-	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
-	    shift
-	    continue;;
+    -d) dir_arg=true
+        shift
+        continue;;
 
-	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
-	    shift
-	    continue;;
+    -g) chgrpcmd="$chgrpprog $2"
+        shift
+        shift
+        continue;;
 
-	*)  if [ x"$src" = x ]
-	    then
-		src=$1
-	    else
-		# this colon is to work around a 386BSD /bin/sh bug
-		:
-		dst=$1
-	    fi
-	    shift
-	    continue;;
-    esac
+    --help) echo "$usage"; exit 0;;
+
+    -m) chmodcmd="$chmodprog $2"
+        shift
+        shift
+        continue;;
+
+    -o) chowncmd="$chownprog $2"
+        shift
+        shift
+        continue;;
+
+    -s) stripcmd=$stripprog
+        shift
+        continue;;
+
+    -t=*) transformarg=`echo $1 | sed 's/-t=//'`
+        shift
+        continue;;
+
+    --version) echo "$0 $scriptversion"; exit 0;;
+
+    *)  if test -z "$src"; then
+          src=$1
+        else
+          # this colon is to work around a 386BSD /bin/sh bug
+          :
+          dst=$1
+        fi
+        shift
+        continue;;
+  esac
 done
 
-if [ x"$src" = x ]
-then
-	echo "install:	no input file specified"
-	exit 1
-else
-	true
+if test -z "$src"; then
+  echo "$0: no input file specified." >&2
+  exit 1
 fi
 
-if [ x"$dir_arg" != x ]; then
-	dst=$src
-	src=""
-	
-	if [ -d $dst ]; then
-		instcmd=:
-		chmodcmd=""
-	else
-		instcmd=mkdir
-	fi
+if test -n "$dir_arg"; then
+  dst=$src
+  src=
+
+  if test -d "$dst"; then
+    instcmd=:
+    chmodcmd=
+  else
+    instcmd=$mkdirprog
+  fi
 else
+  # Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+  # might cause directories to be created, which would be especially bad
+  # if $src (and thus $dsttmp) contains '*'.
+  if test ! -f "$src" && test ! -d "$src"; then
+    echo "$0: $src does not exist." >&2
+    exit 1
+  fi
 
-# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
-# might cause directories to be created, which would be especially bad 
-# if $src (and thus $dsttmp) contains '*'.
+  if test -z "$dst"; then
+    echo "$0: no destination specified." >&2
+    exit 1
+  fi
 
-	if [ -f $src -o -d $src ]
-	then
-		true
-	else
-		echo "install:  $src does not exist"
-		exit 1
-	fi
-	
-	if [ x"$dst" = x ]
-	then
-		echo "install:	no destination specified"
-		exit 1
-	else
-		true
-	fi
-
-# If destination is a directory, append the input filename; if your system
-# does not like double slashes in filenames, you may need to add some logic
-
-	if [ -d $dst ]
-	then
-		dst="$dst"/`basename $src`
-	else
-		true
-	fi
+  # If destination is a directory, append the input filename; won't work
+  # if double slashes aren't ignored.
+  if test -d "$dst"; then
+    dst=$dst/`basename "$src"`
+  fi
 fi
 
 ## this sed command emulates the dirname command
-dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+dstdir=`echo "$dst" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
 
 # Make sure that the destination directory exists.
-#  this part is taken from Noah Friedman's mkinstalldirs script
+# (this part is taken from Noah Friedman's mkinstalldirs script.)
 
 # Skip lots of stat calls in the usual case.
-if [ ! -d "$dstdir" ]; then
-defaultIFS='	
-'
-IFS="${IFS-${defaultIFS}}"
+if test ! -d "$dstdir"; then
+  defaultIFS='
+	'
+  IFS="${IFS-$defaultIFS}"
 
-oIFS="${IFS}"
-# Some sh's can't handle IFS=/ for some reason.
-IFS='%'
-set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
-IFS="${oIFS}"
+  oIFS=$IFS
+  # Some sh's can't handle IFS=/ for some reason.
+  IFS='%'
+  set - `echo "$dstdir" | sed -e 's@/@%@g' -e 's@^%@/@'`
+  IFS=$oIFS
 
-pathcomp=''
+  pathcomp=
 
-while [ $# -ne 0 ] ; do
-	pathcomp="${pathcomp}${1}"
-	shift
-
-	if [ ! -d "${pathcomp}" ] ;
-        then
-		$mkdirprog "${pathcomp}"
-	else
-		true
-	fi
-
-	pathcomp="${pathcomp}/"
-done
+  while test $# -ne 0 ; do
+    pathcomp=$pathcomp$1
+    shift
+    test -d "$pathcomp" || $mkdirprog "$pathcomp"
+    pathcomp=$pathcomp/
+  done
 fi
 
-if [ x"$dir_arg" != x ]
-then
-	$doit $instcmd $dst &&
+if test -n "$dir_arg"; then
+  $doit $instcmd "$dst" \
+    && { test -z "$chowncmd" || $doit $chowncmd "$dst"; } \
+    && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } \
+    && { test -z "$stripcmd" || $doit $stripcmd "$dst"; } \
+    && { test -z "$chmodcmd" || $doit $chmodcmd "$dst"; }
 
-	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
-	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
-	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
-	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
 else
+  # If we're going to rename the final executable, determine the name now.
+  if test -z "$transformarg"; then
+    dstfile=`basename "$dst"`
+  else
+    dstfile=`basename "$dst" $transformbasename \
+             | sed $transformarg`$transformbasename
+  fi
 
-# If we're going to rename the final executable, determine the name now.
+  # don't allow the sed command to completely eliminate the filename.
+  test -z "$dstfile" && dstfile=`basename "$dst"`
 
-	if [ x"$transformarg" = x ] 
-	then
-		dstfile=`basename $dst`
-	else
-		dstfile=`basename $dst $transformbasename | 
-			sed $transformarg`$transformbasename
-	fi
+  # Make a couple of temp file names in the proper directory.
+  dsttmp=$dstdir/_inst.$$_
+  rmtmp=$dstdir/_rm.$$_
 
-# don't allow the sed command to completely eliminate the filename
+  # Trap to clean up those temp files at exit.
+  trap 'status=$?; rm -f "$dsttmp" "$rmtmp" && exit $status' 0
+  trap '(exit $?); exit' 1 2 13 15
 
-	if [ x"$dstfile" = x ] 
-	then
-		dstfile=`basename $dst`
-	else
-		true
-	fi
+  # Move or copy the file name to the temp name
+  $doit $instcmd "$src" "$dsttmp" &&
 
-# Make a temp file name in the proper directory.
+  # and set any options; do chmod last to preserve setuid bits.
+  #
+  # If any of these fail, we abort the whole thing.  If we want to
+  # ignore errors from any of these, just make sure not to ignore
+  # errors from the above "$doit $instcmd $src $dsttmp" command.
+  #
+  { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } \
+    && { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } \
+    && { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } \
+    && { test -z "$chmodcmd" || $doit $chmodcmd "$dsttmp"; } &&
 
-	dsttmp=$dstdir/#inst.$$#
-
-# Move or copy the file name to the temp name
-
-	$doit $instcmd $src $dsttmp &&
-
-	trap "rm -f ${dsttmp}" 0 &&
-
-# and set any options; do chmod last to preserve setuid bits
-
-# If any of these fail, we abort the whole thing.  If we want to
-# ignore errors from any of these, just make sure not to ignore
-# errors from the above "$doit $instcmd $src $dsttmp" command.
-
-	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
-	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
-	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
-	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
-
-# Now rename the file to the real destination.
-
-	$doit $rmcmd -f $dstdir/$dstfile &&
-	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+  # Now remove or move aside any old file at destination location.  We
+  # try this two ways since rm can't unlink itself on some systems and
+  # the destination file might be busy for other reasons.  In this case,
+  # the final cleanup might fail but the new file should still install
+  # successfully.
+  {
+    if test -f "$dstdir/$dstfile"; then
+      $doit $rmcmd -f "$dstdir/$dstfile" 2>/dev/null \
+      || $doit $mvcmd -f "$dstdir/$dstfile" "$rmtmp" 2>/dev/null \
+      || {
+	  echo "$0: cannot unlink or rename $dstdir/$dstfile" >&2
+	  (exit 1); exit
+      }
+    else
+      :
+    fi
+  } &&
 
+  # Now rename the file to the real destination.
+  $doit $mvcmd "$dsttmp" "$dstdir/$dstfile"
 fi &&
 
+# The final little trick to "correctly" pass the exit status to the exit trap.
+{
+  (exit 0); exit
+}
 
-exit 0
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-end: "$"
+# End:

configure.in

@@ -1,4 +1,3 @@
-################################################################################
 ##
 ##    Copyright 1999-2000 Sistina Software, Inc.
 ##
@@ -46,30 +45,186 @@ AC_TYPE_SIZE_T
 AC_STRUCT_ST_RDEV
 AC_HEADER_TIME
 
+dnl Get system type
+AC_CANONICAL_SYSTEM
+
+case "$host_os" in
+	linux*)
+		CFLAGS= 
+		CLDFLAGS="-Wl,--version-script,.export.sym"
+		CLDWHOLEARCHIVE="-Wl,-whole-archive"
+		CLDNOWHOLEARCHIVE="-Wl,-no-whole-archive"
+		LD_DEPS=".export.sym"
+		LD_FLAGS="-Wl,--export-dynamic"
+		SOFLAG="-shared"
+		DEVMAPPER=yes
+		ODIRECT=yes ;;
+	darwin*)
+		CFLAGS="-no-cpp-precomp -fno-common"
+		CLDFLAGS=
+		CLDWHOLEARCHIVE="-all_load"
+		CLDNOWHOLEARCHIVE=
+		LD_DEPS=
+		LD_FLAGS=
+		SOFLAG="-dynamiclib"
+		DEVMAPPER=no
+		ODIRECT=no ;;
+esac
+
 dnl -- prefix is /usr by default, the exec_prefix default is setup later
 AC_PREFIX_DEFAULT(/usr)
 
+OWNER="root"
+GROUP="root"
+
 dnl -- setup the ownership of the files
 AC_ARG_WITH(user,
   [  --with-user=USER        Set the owner of installed files ],
-  [ OWNER="$withval" ],
-  [ OWNER="root" ])
+  [ OWNER="$withval" ])
+
+if test x$OWNER != x; then
+	OWNER="-o $OWNER"
+fi
 
 dnl -- setup the group ownership of the files
 AC_ARG_WITH(group,
   [  --with-group=GROUP      Set the group owner of installed files ],
-  [ GROUP="$withval" ],
-  [ GROUP="root" ])
+  [ GROUP="$withval" ])
 
-AC_ARG_ENABLE(jobs, [  --enable-jobs=NUM       Number of jobs to run simultaneously], JOBS=-j$enableval, JOBS=)
+if test x$GROUP != x; then
+	GROUP="-g $GROUP"
+fi
 
-dnl Enables staticly linked tools
-AC_ARG_ENABLE(static_link, [  --enable-static_link    Use this to link the tools to the liblvm library
+dnl -- LVM1 tool fallback option
+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)
+
+if test x$LVM1_FALLBACK = xyes; then
+	CFLAGS="$CFLAGS -DLVM1_FALLBACK"
+fi
+
+dnl -- format1 inclusion type
+AC_ARG_WITH(lvm1,
+  [  --with-lvm1=TYPE        LVM1 metadata support: internal/shared/none
+                          [TYPE=internal] ],
+  [ LVM1="$withval" ],
+  [ LVM1="internal" ])
+
+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
+	CFLAGS="$CFLAGS -DLVM1_INTERNAL"
+fi
+
+dnl -- format_pool inclusion type
+AC_ARG_WITH(pool,
+  [  --with-pool=TYPE        GFS pool read-only support: internal/shared/none
+                          [TYPE=internal] ],
+  [ POOL="$withval" ],
+  [ POOL="internal" ])
+
+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
+	CFLAGS="$CFLAGS -DPOOL_INTERNAL"
+fi
+
+
+AC_ARG_ENABLE(jobs, [  --enable-jobs=NUM       Number of jobs to run simultaneously], JOBS=-j$enableval, JOBS=-j2)
+
+dnl -- snapshots inclusion type
+AC_ARG_WITH(snapshots,
+  [  --with-snapshots=TYPE   Snapshot support: internal/shared/none
+                          [TYPE=internal] ],
+  [ SNAPSHOTS="$withval" ],
+  [ SNAPSHOTS="internal" ])
+
+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
+	CFLAGS="$CFLAGS -DSNAPSHOT_INTERNAL"
+fi
+
+dnl -- mirrors inclusion type
+AC_ARG_WITH(mirrors,
+  [  --with-mirrors=TYPE     Mirror support: internal/shared/none
+                          [TYPE=internal] ],
+  [ MIRRORS="$withval" ],
+  [ MIRRORS="internal" ])
+
+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
+	CFLAGS="$CFLAGS -DMIRRORED_INTERNAL"
+fi
+
+dnl Enables staticly-linked tools
+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)
 
-dnl Disable readline
-AC_ARG_ENABLE(readline, [  --disable-readline      Disable readline support],  \
-READLINE=$enableval, READLINE=yes)
+dnl Enable readline
+AC_ARG_ENABLE(readline, [  --enable-readline       Enable readline support],  \
+READLINE=$enableval, READLINE=no)
+
+if test x$READLINE = xyes; then
+	CFLAGS="$CFLAGS -DREADLINE_SUPPORT"
+fi
+
+echo $ac_n "checking whether to enable debugging""... $ac_c" 1>&6
+dnl Enable Debugging
+AC_ARG_ENABLE(debug,    [  --enable-debug          Enable debugging],  \
+DEBUG=yes, DEBUG=no)
+echo "$ac_t""$DEBUG" 1>&6
+
+echo $ac_n "checking whether to enable device-mapper""... $ac_c" 1>&6
+dnl Disable devmapper
+AC_ARG_ENABLE(devmapper, [  --disable-devmapper     Disable device-mapper interaction],  \
+DEVMAPPER=no)
+echo "$ac_t""$DEVMAPPER" 1>&6
+
+if test x$DEVMAPPER = xyes; then
+	CFLAGS="$CFLAGS -DDEVMAPPER_SUPPORT"
+fi
+
+echo $ac_n "checking whether to enable O_DIRECT""... $ac_c" 1>&6
+dnl Disable O_DIRECT
+AC_ARG_ENABLE(o_direct, [  --disable-o_direct      Disable O_DIRECT],  \
+ODIRECT=no)
+echo "$ac_t""$ODIRECT" 1>&6
+
+if test x$ODIRECT = xyes; then
+	CFLAGS="$CFLAGS -DO_DIRECT_SUPPORT"
+fi
+
+echo $ac_n "checking whether to compile liblvm2cmd.so""... $ac_c" 1>&6
+dnl Enable cmdlib
+AC_ARG_ENABLE(cmdlib, [  --enable-cmdlib         Build shared command library],  \
+CMDLIB=yes, CMDLIB=no)
+echo "$ac_t""$CMDLIB" 1>&6
+
+if test x$CMDLIB = xyes; then
+	CFLAGS="$CFLAGS -DCMDLIB"
+fi
 
 dnl Mess with default exec_prefix
 if [[ "x$exec_prefix" = xNONE -a "x$prefix" = xNONE ]];
@@ -99,6 +254,37 @@ Note: (n)curses also seems to work as a substitute for termcap.  This was
 	)
 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
+	CFLAGS="$CFLAGS -DHAVE_LIBDL"
+	LIBS="-ldl $LIBS"
+else
+	HAVE_LIBDL=no
+fi
+
+dnl Check for shared/static conflicts
+if [[ \( "x$LVM1" = xshared -o "x$POOL" = xshared -o \
+      "x$SNAPSHOTS" = xshared -o "x$MIRRORS" = xshared \
+      \) -a "x$STATIC_LINK" = xyes ]];
+ then  AC_MSG_ERROR(
+Features cannot be 'shared' when building statically
+)
+ exit
+fi
+
+dnl Check for is_selinux_enabled
+AC_CHECK_LIB(selinux, is_selinux_enabled, HAVE_SELINUX=yes, HAVE_SELINUX=no)
+
+if test x$HAVE_SELINUX = xyes; then
+	CFLAGS="$CFLAGS -DHAVE_SELINUX"
+	LIBS="-lselinux $LIBS"
+fi
+
+dnl Check for getopt
+AC_CHECK_HEADERS(getopt.h, CFLAGS="$CFLAGS -DHAVE_GETOPTLONG")
+
 dnl Check for readline (Shamelessly copied from parted 1.4.17)
 if test x$READLINE = xyes; then
 	AC_CHECK_LIB(readline, readline, ,
@@ -112,10 +298,43 @@ package as well (which may be called readline-devel or something similar).
 )
 		exit
 	)
-	AC_CHECK_FUNC(rl_completion_matches, HAVE_RL_COMPLETION_MATCHES=yes,
-		HAVE_RL_COMPLETION_MATCHES=no)
+	AC_CHECK_FUNC(rl_completion_matches, CFLAGS="$CFLAGS -DHAVE_RL_COMPLETION_MATCHES")
+		
 fi
 
+echo $ac_n "checking whether to enable internationalisation""... $ac_c" 1>&6
+dnl Internationalisation stuff
+AC_ARG_ENABLE(nls, [  --enable-nls            Enable Native Language Support],\
+		INTL=yes, INTL=no)
+echo "$ac_t""$INTL" 1>&6
+
+if test x$INTL = xyes; then
+	INTL_PACKAGE="lvm2"
+	AC_PATH_PROG(MSGFMT, msgfmt)
+	if [[ "x$MSGFMT" == x ]];
+		then  AC_MSG_ERROR(
+		msgfmt not found in path $PATH
+		)
+		exit  
+	fi;
+
+	AC_ARG_WITH(localedir,
+  		    [  --with-localedir=DIR    Translation files in DIR [PREFIX/share/locale]],
+  		    [ LOCALEDIR="$withval" ],
+  		    [ LOCALEDIR='${prefix}/share/locale' ])
+fi
+
+AC_ARG_WITH(confdir,
+	    [  --with-confdir=DIR      Configuration files in DIR [/etc]],
+  	    [ CONFDIR="$withval" ],
+ 	    [ CONFDIR='/etc' ])
+
+AC_ARG_WITH(staticdir,
+	    [  --with-staticdir=DIR    Static binary in DIR [EXEC_PREFIX/sbin]],
+  	    [ STATICDIR="$withval" ],
+ 	    [ STATICDIR='${exec_prefix}/sbin' ])
+
+
 if test "-f VERSION"; then
   LVM_VERSION="\"`cat VERSION`\""
 else
@@ -124,20 +343,48 @@ fi
 
 AC_SUBST(JOBS)
 AC_SUBST(STATIC_LINK)
-AC_SUBST(READLINE)
-AC_SUBST(HAVE_RL_COMPLETION_MATCHES)
+AC_SUBST(LVM1)
+AC_SUBST(POOL)
+AC_SUBST(SNAPSHOTS)
+AC_SUBST(MIRRORS)
 AC_SUBST(OWNER)
 AC_SUBST(GROUP)
+AC_SUBST(CFLAGS)
+AC_SUBST(CLDFLAGS)
+AC_SUBST(CLDWHOLEARCHIVE)
+AC_SUBST(CLDNOWHOLEARCHIVE)
+AC_SUBST(LD_DEPS)
+AC_SUBST(LD_FLAGS)
+AC_SUBST(SOFLAG)
 AC_SUBST(LIBS)
 AC_SUBST(LVM_VERSION)
+AC_SUBST(LVM1_FALLBACK)
+AC_SUBST(DEBUG)
+AC_SUBST(DEVMAPPER)
+AC_SUBST(HAVE_LIBDL)
+AC_SUBST(HAVE_SELINUX)
+AC_SUBST(CMDLIB)
+AC_SUBST(MSGFMT)
+AC_SUBST(LOCALEDIR)
+AC_SUBST(CONFDIR)
+AC_SUBST(STATICDIR)
+AC_SUBST(INTL_PACKAGE)
+AC_SUBST(INTL)
+
 dnl First and last lines should not contain files to generate in order to 
 dnl keep utility scripts running properly
 AC_OUTPUT( 								\
 Makefile								\
 make.tmpl                                                               \
+doc/Makefile								\
 include/Makefile						 	\
 lib/Makefile							 	\
+lib/format1/Makefile						 	\
+lib/format_pool/Makefile						\
+lib/mirror/Makefile							\
+lib/snapshot/Makefile							\
 man/Makefile							 	\
+po/Makefile								\
 tools/Makefile							 	\
 tools/version.h								\
 test/mm/Makefile							\
@@ -146,3 +393,10 @@ test/format1/Makefile							\
 test/regex/Makefile                                                     \
 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
+fi

debian/README.Debian

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

debian/changelog

@@ -1,3 +1,26 @@
+lvm2 (1.95.15-1) unstable; urgency=low
+  
+  * New upstream release.
+  * Remove undocumented manpage symlinks.
+  * Update description to be more informative.  (Closes: #173499)
+  * Add kernel-patch-device-mapper suggestion.
+  * Update standards version.
+
+ -- Andres Salomon <dilinger@mp3revolution.net>  Sun, 16 Feb 2002 04:21:26 -0400
+
+lvm2 (1.95.11-1) unstable; urgency=low
+
+  * New upstream release.  (Closes: #171436)
+  * Removed TODO and INTRO from debian/docs; added WHATS_NEW.
+  * Remove vgcfgrestore.8 undocumented symlink.
+  * Added a README.Debian, mentioning the device-mapper kernel module
+    requirement that lvm2 has.  (Closes: #171674, #163020)
+  * Get rid of debian/conffiles (debhelper's smart enough to figure that out).
+  * debian/copyright fix to appease lintian.
+  * Fix typo in tools/commands.h that caused /usr/sbin/; to be created.
+
+ -- Andres Salomon <dilinger@mp3revolution.net>  Mon,  9 Dec 2002 02:51:02 -0400
+
 lvm2 (1.95.10-2) unstable; urgency=low
 
   * Fix software raid problems by ensuring lvm init script runs after

debian/conffiles

@@ -1,2 +0,0 @@
-/etc/lvm/lvm.conf
-/etc/init.d/lvm2

debian/control

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

debian/copyright

@@ -3,7 +3,7 @@ Wed, 20 Feb 2002 03:17:25 -0500.
 
 It was downloaded from http://www.sistina.com/products_lvm.htm
 
-Upstream Author(s): LVM Development Team
+Upstream Author: LVM Development Team
 
 Copyright (c) 2001-2002 LVM Development Team
 

debian/docs

@@ -1,6 +1,5 @@
 BUGS
-INTRO
 README
-TODO
 VERSION
+WHATS_NEW
 doc/*

debian/rules

@@ -102,7 +102,6 @@ binary-arch: build install
 	dh_installcron
 	dh_installman
 	dh_installinfo 
-	dh_undocumented
 	dh_installchangelogs
 	dh_strip
 	dh_link

debian/undocumented

@@ -1,14 +0,0 @@
-e2fsadm.8
-lvmdiskscan.8
-lvmsadc.8
-lvmsar.8
-lvresize.8
-pvdata.8
-pvmove.8
-pvresize.8
-version.8
-vgcfgrestore.8
-vgexport.8
-vgimport.8
-vgmknodes.8
-vgsplit.8

doc/Makefile.in

@@ -0,0 +1,29 @@
+#
+# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+#
+# This file is part of the LVM2.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU General Public License v.2.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+
+CONFSRC=example.conf
+CONFDEST=lvm.conf
+
+include ../make.tmpl
+
+install:
+	@if [ ! -e $(confdir)/$(CONFDEST) ]; then \
+		echo "Installing $(CONFSRC) as $(confdir)/$(CONFDEST)"; \
+		@INSTALL@ -D $(OWNER) $(GROUP) -m 644 $(CONFSRC) \
+			$(confdir)/$(CONFDEST); \
+	fi
+

doc/example.conf

@@ -1,76 +1,102 @@
-# This is an example configuration file for the LVM2 system.  It
-# contains the default settings that would be used if there was no
+# This is an example configuration file for the LVM2 system.
+# It contains the default settings that would be used if there was no
 # /etc/lvm/lvm.conf file.
-# Refer to 'man lvm.conf' for further information.
+#
+# Refer to 'man lvm.conf' for further information including the file layout.
+#
+# To put this file in a different directory and override /etc/lvm set
+# the environment variable LVM_SYSTEM_DIR before running the tools.
 
 
-# This section allows the user to configure which block devices should
+# This section allows you to configure which block devices should
 # be used by the LVM system.
 devices {
 
-    # where do you want your volume groups to appear ?
+    # Where do you want your volume groups to appear ?
     dir = "/dev"
 
     # An array of directories that contain the device nodes you wish
     # to use with LVM2.
-    scan = "/dev"
-
-    # A very important option, that allows you to tune the LVM2 system
-    # to just look at a restricted set of devices that you're
-    # interested in.
+    scan = [ "/dev" ]
 
+    # A filter that tells LVM2 to only use a restricted set of devices.
     # The filter consists of an array of regular expressions.  These
     # expressions can be delimited by a character of your choice, and
     # prefixed with either an 'a' (for accept) or 'r' (for reject).
+    # The first expression found to match a device name determines if
+    # the device will be accepted or rejected (ignored).  Devices that
+    # don't match any patterns are accepted.
 
-    # Remember to run vgscan after you change this parameter.
+    # Remember to run vgscan after you change this parameter to ensure 
+    # that the cache file gets regenerated (see below).
 
     # By default we accept every block device:
-    filter = "a/.*/"
+    filter = [ "a/.*/" ]
+
+    # Exclude the cdrom drive
+    # filter = [ "r|/dev/cdrom|" ]
 
     # When testing I like to work with just loopback devices:
-    # filter = ["a/loop/", "r/.*/"]
+    # filter = [ "a/loop/", "r/.*/" ]
 
     # Or maybe all loops and ide drives except hdc:
-    # filter =["a|loop|", "r|/dev/hdc|", "a|/dev/ide|", "r|.*|"]
+    # filter =[ "a|loop|", "r|/dev/hdc|", "a|/dev/ide|", "r|.*|" ]
 
     # Use anchors if you want to be really specific
-    # filter = ["a|^/dev/hda8$|", "r/.*/"]
+    # filter = [ "a|^/dev/hda8$|", "r/.*/" ]
 
-    # The results of all the filtering are cached on disk to avoid
+    # The results of the filtering are cached on disk to avoid
     # rescanning dud devices (which can take a very long time).  By
-    # default this cache file is hidden in the /etc/lvm directory, it
-    # is human readable to aid filter debugging.
+    # default this cache file is hidden in the /etc/lvm directory.
+    # It is safe to delete this file: the tools regenerate it.
     cache = "/etc/lvm/.cache"
 
     # You can turn off writing this cache file by setting this to 0.
     write_cache_state = 1
+
+    # Advanced settings.
+
+    # List of pairs of additional acceptable block device types found 
+    # in /proc/devices with maximum (non-zero) number of partitions.
+    # types = [ "fd", 16 ]
+
+    # If sysfs is mounted (2.6 kernels) restrict device scanning to 
+    # the block devices it believes are valid.
+    # 1 enables; 0 disables.
+    sysfs_scan = 1	
+
+    # By default, LVM2 will ignore devices used as components of
+    # software RAID (md) devices by looking for md superblocks.
+    # 1 enables; 0 disables.
+    md_component_detection = 1
 }
 
-# A section that allows the user to configure the nature of the
+# This section that allows you to configure the nature of the
 # information that LVM2 reports.
 log {
 
-    # Where should the log of error and debug messages go ?  By
-    # default there is no log.
-    #file = "/var/log/lvm2.log"
-
-    # Should we overwrite the last log.  By default we append.
-    overwrite = 0
-
-    # There are 9 log levels, with 9 being the most verbose.
-    level = 3
-    
-    # Controls the messages sent to stdout or stderr while running 
-    # LVM2.  There are three levels of verbosity, 3 being the most 
-    # verbose.
+    # Controls the messages sent to stdout or stderr.
+    # There are three levels of verbosity, 3 being the most verbose.
     verbose = 0
 
     # Should we send log messages through syslog?
     # 1 is yes; 0 is no.
     syslog = 1
 
-    # Choose format of output messages
+    # Should we log error and debug messages to a file?
+    # By default there is no log file.
+    #file = "/var/log/lvm2.log"
+
+    # Should we overwrite the log file each time the program is run?
+    # By default we append.
+    overwrite = 0
+
+    # What level of log messages should we send to the log file and/or syslog?
+    # There are 6 syslog-like log levels currently in use - 2 to 7 inclusive.
+    # 7 is the most verbose (LOG_DEBUG).
+    level = 0
+    
+    # Format of output messages
     # Whether or not (1 or 0) to indent messages according to their severity
     indent = 1
 
@@ -78,13 +104,18 @@ log {
     command_names = 0
 
     # A prefix to use before the message text (but after the command name,
-    # if selected)
+    # if selected).  Default is two spaces, so you can see/grep the severity
+    # of each message.
     prefix = "  "
 
-    # To make the messages look similar to the original LVM use:
+    # To make the messages look similar to the original LVM tools use:
     #   indent = 0
     #   command_names = 1
     #   prefix = " -- "
+
+    # Set this if you want log messages during activation.
+    # Don't use this in low memory situations (can deadlock).
+    # activation = 0
 }
 
 # Configuration of metadata backups and archiving.  In LVM2 when we
@@ -95,19 +126,20 @@ backup {
 
     # Should we maintain a backup of the current metadata configuration ?
     # Use 1 for Yes; 0 for No.
-    # Think very hard before turning this off.
+    # Think very hard before turning this off!
     backup = 1
 
     # Where shall we keep it ?
+    # Remember to back up this directory regularly!
     backup_dir = "/etc/lvm/backup"
 
-
     # Should we maintain an archive of old metadata configurations.
     # Use 1 for Yes; 0 for No.
     # On by default.  Think very hard before turning this off.
     archive = 1
 
     # Where should archived files go ?
+    # Remember to back up this directory regularly!
     archive_dir = "/etc/lvm/archive"
     
     # What is the minimum number of archive files you wish to keep ?
@@ -117,20 +149,15 @@ backup {
     retain_days = 30
 }
 
-# Settings for the running LVM2 in shell mode.
+# Settings for the running LVM2 in shell (readline) mode.
 shell {
 
     # Number of lines of history to store in ~/.lvm_history
     history_size = 100
 }
 
-# Metadata settings
-metadata {
-    # List of directories holding copies of text format metadata
-    dirs = [ "/etc/lvm/metadata" ]
-}
 
-# Miscellaneous global settings
+# Miscellaneous global LVM2 settings
 global {
     
     # The file creation mask for any files and directories created.
@@ -145,10 +172,112 @@ global {
     # command.  Defaults to off.
     test = 0
 
-    # Default metadata format commands use - "lvm1" (default) or "text"
-    format = "lvm1"
+    # Whether or not to communicate with the kernel device-mapper.
+    # Set to 0 if you want to use the tools to manipulate LVM metadata 
+    # without activating any logical volumes.
+    # If the device-mapper kernel driver is not present in your kernel
+    # setting this to 0 should suppress the error messages.
+    activation = 1
+
+    # If we can't communicate with device-mapper, should we try running 
+    # the LVM1 tools?
+    # This option only applies to 2.4 kernels and is provided to help you
+    # switch between device-mapper kernels and LVM1 kernels.
+    # The LVM1 tools need to be installed with .lvm1 suffices
+    # e.g. vgscan.lvm1 and they will stop working after you start using
+    # the new lvm2 on-disk metadata format.
+    # The default value is set when the tools are built.
+    # fallback_to_lvm1 = 0
+
+    # The default metadata format that commands should use - "lvm1" or "lvm2".
+    # The command line override is -M1 or -M2.
+    # Defaults to "lvm1" if compiled in, else "lvm2".
+    # format = "lvm1"
 
     # Location of proc filesystem
     proc = "/proc"
+
+    # Type of locking to use. Defaults to file-based locking (1).
+    # Turn locking off by setting to 0 (dangerous: risks metadata corruption
+    # if LVM2 commands get run concurrently).
+    locking_type = 1
+
+    # Local non-LV directory that holds file-based locks while commands are
+    # in progress.  A directory like /tmp that may get wiped on reboot is OK.
+    locking_dir = "/var/lock/lvm"
+
+    # Other entries can go here to allow you to load shared libraries
+    # e.g. if support for LVM1 metadata was compiled as a shared library use
+    #   format_libraries = "liblvm2format1.so" 
+    # Full pathnames can be given.
+
+    # Search this directory first for shared libraries.
+    #   library_dir = "/lib"
 }
 
+activation {
+    # Device used in place of missing stripes if activating incomplete volume.
+    # For now, you need to set this up yourself first (e.g. with 'dmsetup')
+    # For example, you could make it return I/O errors using the 'error' 
+    # target or make it return zeros.
+    missing_stripe_filler = "/dev/ioerror"
+
+    # Size (in KB) of each copy operation when mirroring
+    mirror_region_size = 512
+
+    # How much stack (in KB) to reserve for use while devices suspended
+    reserved_stack = 256
+
+    # How much memory (in KB) to reserve for use while devices suspended
+    reserved_memory = 8192
+
+    # Nice value used while devices suspended
+    process_priority = -18
+
+    # If volume_list is defined, each LV is only activated if there is a
+    # match against the list.
+    #   "vgname" and "vgname/lvname" are matched exactly.
+    #   "@tag" matches any tag set in the LV or VG.
+    #   "@*" matches if any tag defined on the host is also set in the LV or VG
+    #
+    # volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
+}
+
+
+####################
+# Advanced section #
+####################
+
+# Metadata settings
+#
+# metadata {
+    # Default number of copies of metadata to hold on each PV.  0, 1 or 2.
+    # It's best to leave this at 2.
+    # You might want to override it from the command line with 0 or 1 
+    # when running pvcreate on new PVs which are to be added to large VGs.
+
+    # pvmetadatacopies = 2
+
+    # Approximate default size of on-disk metadata areas in sectors.
+    # You should increase this if you have large volume groups or
+    # you want to retain a large on-disk history of your metadata changes.
+
+    # pvmetadatasize = 255
+
+    # List of directories holding live copies of text format metadata.
+    # These directories must not be on logical volumes!
+    # It's possible to use LVM2 with a couple of directories here,
+    # preferably on different (non-LV) filesystems, and with no other 
+    # on-disk metadata (pvmetadatacopies = 0). Or this can be in
+    # addition to on-disk metadata areas.
+    # The feature was originally added to simplify testing and is not
+    # supported under low memory situations - the machine could lock up.
+    #
+    # Never edit any files in these directories by hand unless you
+    # you are absolutely sure you know what you are doing! Use
+    # the supplied toolset to make changes (e.g. vgcfgrestore).
+
+    # dirs = [ "/etc/lvm/metadata", "/mnt/disk2/lvm/metadata2" ]
+#}
+
+

doc/example_cmdlib.c

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lvm2cmd.h"
+
+/* All output gets passed to this function line-by-line */
+void test_log_fn(int level, const char *file, int line, const char *format)
+{
+	/* Extract and process output here rather than printing it */
+
+	if (level != 4)
+		return;
+
+	printf("%s\n", format);
+	return;
+}
+
+int main(int argc, char **argv)
+{
+	void *handle;
+	int r;
+
+	lvm2_log_fn(test_log_fn);
+
+	handle = lvm2_init();
+
+	lvm2_log_level(handle, 1);
+	r = lvm2_run(handle, "vgs --noheadings vg1");
+
+	/* More commands here */
+
+	lvm2_exit(handle);
+
+	return r;
+}
+

include/.symlinks

@@ -1,4 +1,6 @@
 ../lib/activate/activate.h
+../lib/activate/targets.h
+../lib/cache/lvmcache.h
 ../lib/commands/errors.h
 ../lib/commands/toolcontext.h
 ../lib/config/config.h
@@ -8,26 +10,39 @@
 ../lib/datastruct/hash.h
 ../lib/datastruct/list.h
 ../lib/datastruct/lvm-types.h
+../lib/datastruct/str_list.h
 ../lib/device/dev-cache.h
 ../lib/device/device.h
 ../lib/display/display.h
 ../lib/filters/filter-composite.h
+../lib/filters/filter-md.h
 ../lib/filters/filter-persistent.h
 ../lib/filters/filter-regex.h
+../lib/filters/filter-sysfs.h
 ../lib/filters/filter.h
 ../lib/format1/format1.h
-../lib/format1/lvm1_label.h
+../lib/format_pool/format_pool.h
 ../lib/format_text/format-text.h
+../lib/format_text/text_export.h
+../lib/format_text/text_import.h
 ../lib/label/label.h
-../lib/label/uuid-map.h
 ../lib/locking/locking.h
 ../lib/log/log.h
+../lib/metadata/lv_alloc.h
 ../lib/metadata/metadata.h
+../lib/metadata/segtypes.h
 ../lib/mm/dbg_malloc.h
+../lib/mm/memlock.h
 ../lib/mm/pool.h
 ../lib/mm/xlate.h
+../lib/misc/crc.h
+../lib/misc/intl.h
+../lib/misc/lib.h
 ../lib/misc/lvm-file.h
 ../lib/misc/lvm-string.h
+../lib/misc/selinux.h
+../lib/misc/sharedlib.h
 ../lib/regex/matcher.h
+../lib/report/report.h
 ../lib/uuid/uuid.h
-../lib/vgcache/vgcache.h
+../po/pogen.h

include/Makefile.in

@@ -1,20 +1,16 @@
 #
-# Copyright (C) 2001 Sistina Software
+# Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
 #
-# This LVM library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Library General Public
-# License as published by the Free Software Foundation; either
-# version 2 of the License, or (at your option) any later version.
+# This file is part of the LVM2.
 #
-# This LVM library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Library General Public License for more details.
+# 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 Library General Public
-# License along with this LVM library; if not, write to the Free
-# Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-# MA 02111-1307, USA
+# 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
 
 SHELL = /bin/sh
 
@@ -35,9 +31,11 @@ distclean:
 	find . -maxdepth 1 -type l -exec $(RM) \{\} \;
 	$(RM) Makefile .include_symlinks .symlinks_created
 
+pofile: all
+
 clean:
 
 install:
 
-.PHONY: clean distclean all install
+.PHONY: clean distclean all install pofile
 

lib/Makefile.in

@@ -1,44 +1,66 @@
 #
-# Copyright (C) 2001 Sistina Software (UK) Limited
+# Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
 #
-# This file is released under the GPL.
+# This file is part of the LVM2.
 #
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU General Public License v.2.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 srcdir = @srcdir@
 top_srcdir = @top_srcdir@
 VPATH = @srcdir@
 
-SOURCES=\
+ifeq ("@LVM1@", "shared")
+  SUBDIRS = format1
+endif
+
+ifeq ("@POOL@", "shared")
+  SUBDIRS += format_pool
+endif
+
+ifeq ("@SNAPSHOTS@", "shared")
+  SUBDIRS += snapshot
+endif
+
+ifeq ("@MIRRORS@", "shared")
+  SUBDIRS += mirror
+endif
+
+SOURCES =\
 	activate/activate.c \
-	activate/dev_manager.c \
-	activate/fs.c \
+	cache/lvmcache.c \
+	commands/toolcontext.c \
 	config/config.c \
 	datastruct/bitset.c \
 	datastruct/btree.c \
 	datastruct/hash.c \
+	datastruct/str_list.c \
 	device/dev-cache.c \
 	device/dev-io.c \
 	device/device.c \
 	display/display.c \
+	error/errseg.c \
 	filters/filter-composite.c \
 	filters/filter-persistent.c \
 	filters/filter-regex.c \
+	filters/filter-sysfs.c \
+	filters/filter-md.c \
 	filters/filter.c \
-	format1/disk-rep.c \
-	format1/format1.c \
-	format1/import-export.c \
-	format1/import-extents.c \
-	format1/layout.c \
-	format1/lvm1_label.c \
-	format1/vg_number.c \
 	format_text/archive.c \
 	format_text/export.c \
 	format_text/flags.c \
 	format_text/format-text.c \
 	format_text/import.c \
+	format_text/import_vsn1.c \
+	format_text/tags.c \
+	format_text/text_label.c \
 	label/label.c \
-	label/uuid-map.c \
-	locking/external_locking.c \
 	locking/file_locking.c \
 	locking/locking.c \
 	locking/no_locking.c \
@@ -46,23 +68,73 @@ SOURCES=\
 	metadata/lv_manip.c \
 	metadata/merge.c \
 	metadata/metadata.c \
+	metadata/mirror.c \
 	metadata/pv_map.c \
+	metadata/segtypes.c \
 	metadata/snapshot_manip.c \
+	misc/crc.c \
 	misc/lvm-file.c \
-	mm/dbg_malloc.c \
+	misc/lvm-string.c \
+	mm/memlock.c \
 	mm/pool.c \
 	regex/matcher.c \
 	regex/parse_rx.c \
 	regex/ttree.c \
+	report/report.c \
+	striped/striped.c \
 	uuid/uuid.c \
-	vgcache/vgcache.c
+	zero/zero.c
 
-TARGETS=liblvm.a
+ifeq ("@LVM1@", "internal")
+  SOURCES +=\
+	format1/disk-rep.c \
+	format1/format1.c \
+	format1/import-export.c \
+	format1/import-extents.c \
+	format1/layout.c \
+	format1/lvm1-label.c \
+	format1/vg_number.c
+endif
+
+ifeq ("@POOL@", "internal")
+  SOURCES +=\
+	format_pool/disk_rep.c \
+	format_pool/format_pool.c \
+	format_pool/import_export.c \
+	format_pool/pool_label.c
+endif
+
+ifeq ("@SNAPSHOTS@", "internal")
+  SOURCES += snapshot/snapshot.c
+endif
+
+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 \
+	activate/fs.c
+endif
+
+ifeq ("@HAVE_LIBDL@", "yes")
+  SOURCES +=\
+	locking/external_locking.c \
+	misc/sharedlib.c
+endif
+
+ifeq ("@HAVE_SELINUX@", "yes")
+  SOURCES += misc/selinux.c
+endif
+
+LIB_STATIC = liblvm.a
+
+$(SUBDIRS): $(LIB_STATIC)
 
 include ../make.tmpl
 
-liblvm.a: $(OBJECTS)
-	$(RM) $@
-	$(AR) r $@ $(OBJECTS)
-	$(RANLIB) $@
-

lib/activate/activate.c

@@ -1,30 +1,261 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "metadata.h"
 #include "activate.h"
+#include "memlock.h"
 #include "display.h"
-#include "log.h"
 #include "fs.h"
+#include "lvm-file.h"
 #include "lvm-string.h"
 #include "pool.h"
 #include "toolcontext.h"
 #include "dev_manager.h"
-
-/* FIXME Temporary */
-#include "vgcache.h"
+#include "str_list.h"
+#include "config.h"
 
 #include <limits.h>
-#include <linux/kdev_t.h>
 #include <fcntl.h>
+#include <unistd.h>
 
 #define _skip(fmt, args...) log_very_verbose("Skipping: " fmt , ## args)
 
+int lvm1_present(struct cmd_context *cmd)
+{
+	char path[PATH_MAX];
+
+	if (lvm_snprintf(path, sizeof(path), "%s/lvm/global", cmd->proc_dir)
+	    < 0) {
+		log_error("LVM1 proc global snprintf failed");
+		return 0;
+	}
+
+	if (path_exists(path))
+		return 1;
+	else
+		return 0;
+}
+
+#ifndef DEVMAPPER_SUPPORT
+void set_activation(int act)
+{
+	static int warned = 0;
+
+	if (warned || !act)
+		return;
+
+	log_error("Compiled without libdevmapper support. "
+		  "Can't enable activation.");
+
+	warned = 1;
+}
+int activation(void)
+{
+	return 0;
+}
 int library_version(char *version, size_t size)
 {
+	return 0;
+}
+int driver_version(char *version, size_t size)
+{
+	return 0;
+}
+int target_present(const char *target_name)
+{
+	return 0;
+}
+int lv_info(const struct logical_volume *lv, struct lvinfo *info)
+{
+	return 0;
+}
+int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
+		    struct lvinfo *info)
+{
+	return 0;
+}
+int lv_snapshot_percent(struct logical_volume *lv, float *percent)
+{
+	return 0;
+}
+int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
+		      uint32_t *event_nr)
+{
+	return 0;
+}
+int lvs_in_vg_activated(struct volume_group *vg)
+{
+	return 0;
+}
+int lvs_in_vg_opened(struct volume_group *vg)
+{
+	return 0;
+}
+int lv_suspend(struct cmd_context *cmd, const char *lvid_s)
+{
+	return 1;
+}
+int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s)
+{
+	return 1;
+}
+int lv_resume(struct cmd_context *cmd, const char *lvid_s)
+{
+	return 1;
+}
+int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s)
+{
+	return 1;
+}
+int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
+{
+	return 1;
+}
+int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
+			 int *activate_lv)
+{
+	return 1;
+}
+int lv_activate(struct cmd_context *cmd, const char *lvid_s)
+{
+	return 1;
+}
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s)
+{
+	return 1;
+}
+
+int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
+{
+	return 1;
+}
+
+void activation_exit(void)
+{
+	return;
+}
+
+#else				/* DEVMAPPER_SUPPORT */
+
+static int _activation = 1;
+
+void set_activation(int act)
+{
+	if (act == _activation)
+		return;
+
+	_activation = act;
+	if (_activation)
+		log_verbose("Activation enabled. Device-mapper kernel "
+			    "driver will be used.");
+	else
+		log_verbose("Activation disabled. No device-mapper "
+			    "interaction will be attempted.");
+}
+
+int activation(void)
+{
+	return _activation;
+}
+
+static int _passes_activation_filter(struct cmd_context *cmd,
+				     struct logical_volume *lv)
+{
+	const struct config_node *cn;
+	struct config_value *cv;
+	char *str;
+	char path[PATH_MAX];
+
+	if (!(cn = find_config_node(cmd->cft->root, "activation/volume_list"))) {
+		/* If no host tags defined, activate */
+		if (list_empty(&cmd->tags))
+			return 1;
+
+		/* If any host tag matches any LV or VG tag, activate */
+		if (str_list_match_list(&cmd->tags, &lv->tags) ||
+		    str_list_match_list(&cmd->tags, &lv->vg->tags))
+			return 1;
+
+		/* Don't activate */
+		return 0;
+	}
+
+	for (cv = cn->v; cv; cv = cv->next) {
+		if (cv->type != CFG_STRING) {
+			log_error("Ignoring invalid string in config file "
+				  "activation/volume_list");
+			continue;
+		}
+		str = cv->v.str;
+		if (!*str) {
+			log_error("Ignoring empty string in config file "
+				  "activation/volume_list");
+			continue;
+		}
+
+		/* Tag? */
+		if (*str == '@') {
+			str++;
+			if (!*str) {
+				log_error("Ignoring empty tag in config file "
+					  "activation/volume_list");
+				continue;
+			}
+			/* If any host tag matches any LV or VG tag, activate */
+			if (!strcmp(str, "*")) {
+				if (str_list_match_list(&cmd->tags, &lv->tags)
+				    || str_list_match_list(&cmd->tags,
+							   &lv->vg->tags))
+					    return 1;
+				else
+					continue;
+			}
+			/* If supplied tag matches LV or VG tag, activate */
+			if (str_list_match_item(&lv->tags, str) ||
+			    str_list_match_item(&lv->vg->tags, str))
+				return 1;
+			else
+				continue;
+		}
+		if (!index(str, '/')) {
+			/* vgname supplied */
+			if (!strcmp(str, lv->vg->name))
+				return 1;
+			else
+				continue;
+		}
+		/* vgname/lvname */
+		if (lvm_snprintf(path, sizeof(path), "%s/%s", lv->vg->name,
+				 lv->name) < 0) {
+			log_error("lvm_snprintf error from %s/%s", lv->vg->name,
+				  lv->name);
+			continue;
+		}
+		if (!strcmp(path, str))
+			return 1;
+	}
+
+	return 0;
+}
+
+int library_version(char *version, size_t size)
+{
+	if (!activation())
+		return 0;
+
 	if (!dm_get_library_version(version, size))
 		return 0;
 	return 1;
@@ -35,6 +266,9 @@ int driver_version(char *version, size_t size)
 	int r = 0;
 	struct dm_task *dmt;
 
+	if (!activation())
+		return 0;
+
 	log_very_verbose("Getting driver version");
 	if (!(dmt = dm_task_create(DM_DEVICE_VERSION))) {
 		stack;
@@ -55,26 +289,94 @@ int driver_version(char *version, size_t size)
 	return r;
 }
 
-/*
- * Returns 1 if info structure populated, else 0 on failure.
- */
-int lv_info(struct logical_volume *lv, struct dm_info *info)
+int target_present(const char *target_name)
 {
-	int r;
-	struct dev_manager *dm;
+	int r = 0;
+	struct dm_task *dmt;
+	struct dm_versions *target, *last_target;
 
-	if (!(dm = dev_manager_create(lv->vg->name))) {
+	if (!activation())
+		return 0;
+
+	log_very_verbose("Getting target version for %s", target_name);
+	if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS))) {
 		stack;
 		return 0;
 	}
 
-	if (!(r = dev_manager_info(dm, lv, info)))
+	if (!dm_task_run(dmt)) {
+		log_debug("Failed to get %s target version", target_name);
+		/* Assume this was because LIST_VERSIONS isn't supported */
+		return 1;
+	}
+
+	target = dm_task_get_versions(dmt);
+
+	do {
+		last_target = target;
+
+		if (!strcmp(target_name, target->name)) {
+			r = 1;
+			goto out;
+		}
+
+		target = (void *) target + target->next;
+	} while (last_target != target);
+
+      out:
+	dm_task_destroy(dmt);
+
+	return r;
+}
+
+/*
+ * Returns 1 if info structure populated, else 0 on failure.
+ */
+static int _lv_info(const struct logical_volume *lv, int mknodes,
+		    struct lvinfo *info)
+{
+	int r;
+	struct dev_manager *dm;
+	struct dm_info dminfo;
+
+	if (!activation())
+		return 0;
+
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
 		stack;
+		return 0;
+	}
+
+	if (!(r = dev_manager_info(dm, lv, mknodes, &dminfo)))
+		stack;
+
+	info->exists = dminfo.exists;
+	info->suspended = dminfo.suspended;
+	info->open_count = dminfo.open_count;
+	info->major = dminfo.major;
+	info->minor = dminfo.minor;
+	info->read_only = dminfo.read_only;
 
 	dev_manager_destroy(dm);
 	return r;
 }
 
+int lv_info(const struct logical_volume *lv, struct lvinfo *info)
+{
+	return _lv_info(lv, 0, info);
+}
+
+int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
+		    struct lvinfo *info)
+{
+	struct logical_volume *lv;
+
+	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+		return 0;
+
+	return _lv_info(lv, 0, info);
+}
+
 /*
  * Returns 1 if percent set, else 0 on failure.
  */
@@ -83,7 +385,10 @@ int lv_snapshot_percent(struct logical_volume *lv, float *percent)
 	int r;
 	struct dev_manager *dm;
 
-	if (!(dm = dev_manager_create(lv->vg->name))) {
+	if (!activation())
+		return 0;
+
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
 		stack;
 		return 0;
 	}
@@ -96,9 +401,41 @@ int lv_snapshot_percent(struct logical_volume *lv, float *percent)
 	return r;
 }
 
+/* FIXME Merge with snapshot_percent */
+int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
+		      uint32_t *event_nr)
+{
+	int r;
+	struct dev_manager *dm;
+	struct lvinfo info;
+
+	if (!activation())
+		return 0;
+
+	if (!lv_info(lv, &info)) {
+		stack;
+		return 0;
+	}
+
+	if (!info.exists)
+		return 0;
+
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
+		stack;
+		return 0;
+	}
+
+	if (!(r = dev_manager_mirror_percent(dm, lv, wait, percent, event_nr)))
+		stack;
+
+	dev_manager_destroy(dm);
+
+	return r;
+}
+
 static int _lv_active(struct logical_volume *lv)
 {
-	struct dm_info info;
+	struct lvinfo info;
 
 	if (!lv_info(lv, &info)) {
 		stack;
@@ -110,7 +447,7 @@ static int _lv_active(struct logical_volume *lv)
 
 static int _lv_open_count(struct logical_volume *lv)
 {
-	struct dm_info info;
+	struct lvinfo info;
 
 	if (!lv_info(lv, &info)) {
 		stack;
@@ -121,12 +458,12 @@ static int _lv_open_count(struct logical_volume *lv)
 }
 
 /* FIXME Need to detect and handle an lv rename */
-static int _lv_activate(struct logical_volume *lv)
+static int _lv_activate_lv(struct logical_volume *lv)
 {
 	int r;
 	struct dev_manager *dm;
 
-	if (!(dm = dev_manager_create(lv->vg->name))) {
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
 		stack;
 		return 0;
 	}
@@ -143,7 +480,7 @@ static int _lv_deactivate(struct logical_volume *lv)
 	int r;
 	struct dev_manager *dm;
 
-	if (!(dm = dev_manager_create(lv->vg->name))) {
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
 		stack;
 		return 0;
 	}
@@ -155,12 +492,12 @@ static int _lv_deactivate(struct logical_volume *lv)
 	return r;
 }
 
-static int _lv_suspend(struct logical_volume *lv)
+static int _lv_suspend_lv(struct logical_volume *lv)
 {
 	int r;
 	struct dev_manager *dm;
 
-	if (!(dm = dev_manager_create(lv->vg->name))) {
+	if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name))) {
 		stack;
 		return 0;
 	}
@@ -173,7 +510,7 @@ static int _lv_suspend(struct logical_volume *lv)
 }
 
 /*
- * These two functions return the number of LVs in the state,
+ * These two functions return the number of visible LVs in the state,
  * or -1 on error.
  */
 int lvs_in_vg_activated(struct volume_group *vg)
@@ -182,9 +519,13 @@ int lvs_in_vg_activated(struct volume_group *vg)
 	struct logical_volume *lv;
 	int count = 0;
 
+	if (!activation())
+		return 0;
+
 	list_iterate(lvh, &vg->lvs) {
 		lv = list_item(lvh, struct lv_list)->lv;
-		count += (_lv_active(lv) == 1);
+		if (lv->status & VISIBLE_LV)
+			count += (_lv_active(lv) == 1);
 	}
 
 	return count;
@@ -196,127 +537,33 @@ int lvs_in_vg_opened(struct volume_group *vg)
 	struct logical_volume *lv;
 	int count = 0;
 
+	if (!activation())
+		return 0;
+
 	list_iterate(lvh, &vg->lvs) {
 		lv = list_item(lvh, struct lv_list)->lv;
-		count += (_lv_open_count(lv) == 1);
+		if (lv->status & VISIBLE_LV)
+			count += (_lv_open_count(lv) > 0);
 	}
 
 	return count;
 }
 
-static struct logical_volume *_lv_from_lvid(struct cmd_context *cmd,
-					    const char *lvid_s)
-{
-	struct lv_list *lvl;
-	struct volume_group *vg;
-	union lvid *lvid;
-
-	lvid = (union lvid *) lvid_s;
-
-	log_very_verbose("Finding volume group for uuid %s", lvid_s);
-	if (!(vg = vg_read_by_vgid(cmd, lvid->id[0].uuid))) {
-		log_error("Volume group for uuid not found: %s", lvid_s);
-		return NULL;
-	}
-
-	log_verbose("Found volume group \"%s\"", vg->name);
-	if (vg->status & EXPORTED_VG) {
-		log_error("Volume group \"%s\" is exported", vg->name);
-		return NULL;
-	}
-
-	if (!(lvl = find_lv_in_vg_by_lvid(vg, lvid))) {
-		log_very_verbose("Can't find logical volume id %s", lvid_s);
-		return NULL;
-	}
-
-	return lvl->lv;
-}
-
-/* These return success if the device is not active */
-int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s)
+static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
+		       int error_if_not_suspended)
 {
 	struct logical_volume *lv;
-	struct dm_info info;
+	struct lvinfo info;
 
-	if (!(lv = _lv_from_lvid(cmd, lvid_s)))
+	if (!activation())
+		return 1;
+
+	if (!(lv = lv_from_lvid(cmd, lvid_s)))
 		return 0;
 
 	if (test_mode()) {
 		_skip("Suspending '%s'.", lv->name);
-		return 0;
-	}
-
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
-
-	if (info.exists && !info.suspended)
-		return _lv_suspend(lv);
-
-	return 1;
-}
-
-int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s)
-{
-	struct logical_volume *lv;
-	struct dm_info info;
-
-	if (!(lv = _lv_from_lvid(cmd, lvid_s)))
-		return 0;
-
-	if (test_mode()) {
-		_skip("Resuming '%s'.", lv->name);
-		return 0;
-	}
-
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
-
-	if (info.exists && info.suspended)
-		return _lv_activate(lv);
-
-	return 1;
-}
-
-int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
-{
-	struct logical_volume *lv;
-	struct dm_info info;
-
-	if (!(lv = _lv_from_lvid(cmd, lvid_s)))
-		return 0;
-
-	if (test_mode()) {
-		_skip("Deactivating '%s'.", lv->name);
-		return 0;
-	}
-
-	if (!lv_info(lv, &info)) {
-		stack;
-		return 0;
-	}
-
-	if (info.exists)
-		return _lv_deactivate(lv);
-
-	return 1;
-}
-
-int lv_activate(struct cmd_context *cmd, const char *lvid_s)
-{
-	struct logical_volume *lv;
-	struct dm_info info;
-
-	if (!(lv = _lv_from_lvid(cmd, lvid_s)))
-		return 0;
-
-	if (test_mode()) {
-		_skip("Activating '%s'.", lv->name);
-		return 0;
+		return 1;
 	}
 
 	if (!lv_info(lv, &info)) {
@@ -325,7 +572,216 @@ int lv_activate(struct cmd_context *cmd, const char *lvid_s)
 	}
 
 	if (!info.exists || info.suspended)
-		return _lv_activate(lv);
+		return error_if_not_suspended ? 0 : 1;
+
+	memlock_inc();
+	if (!_lv_suspend_lv(lv)) {
+		memlock_dec();
+		fs_unlock();
+		return 0;
+	}
 
 	return 1;
 }
+
+/* Returns success if the device is not active */
+int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s)
+{
+	return _lv_suspend(cmd, lvid_s, 0);
+}
+
+int lv_suspend(struct cmd_context *cmd, const char *lvid_s)
+{
+	return _lv_suspend(cmd, lvid_s, 1);
+}
+
+static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
+		      int error_if_not_active)
+{
+	struct logical_volume *lv;
+	struct lvinfo info;
+
+	if (!activation())
+		return 1;
+
+	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+		return 0;
+
+	if (test_mode()) {
+		_skip("Resuming '%s'.", lv->name);
+		return 1;
+	}
+
+	if (!lv_info(lv, &info)) {
+		stack;
+		return 0;
+	}
+
+	if (!info.exists || !info.suspended)
+		return error_if_not_active ? 0 : 1;
+
+	if (!_lv_activate_lv(lv))
+		return 0;
+
+	memlock_dec();
+	fs_unlock();
+
+	return 1;
+}
+
+/* Returns success if the device is not active */
+int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s)
+{
+	return _lv_resume(cmd, lvid_s, 0);
+}
+
+int lv_resume(struct cmd_context *cmd, const char *lvid_s)
+{
+	return _lv_resume(cmd, lvid_s, 1);
+}
+
+int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
+{
+	struct logical_volume *lv;
+	struct lvinfo info;
+	int r;
+
+	if (!activation())
+		return 1;
+
+	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+		return 0;
+
+	if (test_mode()) {
+		_skip("Deactivating '%s'.", lv->name);
+		return 1;
+	}
+
+	if (!lv_info(lv, &info)) {
+		stack;
+		return 0;
+	}
+
+	if (!info.exists)
+		return 1;
+
+	if (info.open_count && (lv->status & VISIBLE_LV)) {
+		log_error("LV %s/%s in use: not removing", lv->vg->name,
+			  lv->name);
+		return 0;
+	}
+
+	memlock_inc();
+	r = _lv_deactivate(lv);
+	memlock_dec();
+	fs_unlock();
+
+	return r;
+}
+
+/* Test if LV passes filter */
+int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
+			 int *activate_lv)
+{
+	struct logical_volume *lv;
+
+	if (!activation())
+		goto activate;
+
+	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+		return 0;
+
+	if (!_passes_activation_filter(cmd, lv)) {
+		log_verbose("Not activating %s/%s due to config file settings",
+			    lv->vg->name, lv->name);
+		*activate_lv = 0;
+		return 1;
+	}
+
+      activate:
+	*activate_lv = 1;
+	return 1;
+}
+
+static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
+{
+	struct logical_volume *lv;
+	struct lvinfo info;
+	int r;
+
+	if (!activation())
+		return 1;
+
+	if (!(lv = lv_from_lvid(cmd, lvid_s)))
+		return 0;
+
+	if (filter && !_passes_activation_filter(cmd, lv)) {
+		log_verbose("Not activating %s/%s due to config file settings",
+			    lv->vg->name, lv->name);
+		return 0;
+	}
+
+	if (test_mode()) {
+		_skip("Activating '%s'.", lv->name);
+		return 1;
+	}
+
+	if (!lv_info(lv, &info)) {
+		stack;
+		return 0;
+	}
+
+	if (info.exists && !info.suspended)
+		return 1;
+
+	memlock_inc();
+	r = _lv_activate_lv(lv);
+	memlock_dec();
+	fs_unlock();
+
+	return r;
+}
+
+/* Activate LV */
+int lv_activate(struct cmd_context *cmd, const char *lvid_s)
+{
+	return _lv_activate(cmd, lvid_s, 0);
+}
+
+/* Activate LV only if it passes filter */
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s)
+{
+	return _lv_activate(cmd, lvid_s, 1);
+}
+
+int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
+{
+	struct lvinfo info;
+	int r = 1;
+
+	if (!lv) {
+		r = dev_manager_mknodes();
+		fs_unlock();
+		return r;
+	}
+
+	if (!_lv_info(lv, 1, &info)) {
+		stack;
+		return 0;
+	}
+
+	if (info.exists)
+		r = dev_manager_lv_mknodes(lv);
+	else
+		r = dev_manager_lv_rmnodes(lv);
+
+	fs_unlock();
+
+	return r;
+}
+
+void activation_exit(void)
+{
+	dev_manager_exit();
+}
+#endif

lib/activate/activate.h

@@ -1,39 +1,76 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef LVM_ACTIVATE_H
 #define LVM_ACTIVATE_H
 
-#include <libdevmapper.h>
+#include "metadata.h"
+
+#ifdef DEVMAPPER_SUPPORT
+#  include <libdevmapper.h>
+#endif
+
+struct lvinfo {
+	int exists;
+	int suspended;
+	unsigned int open_count;
+	int major;
+	int minor;
+	int read_only;
+};
+
+void set_activation(int activation);
+int activation(void);
 
 int driver_version(char *version, size_t size);
 int library_version(char *version, size_t size);
+int lvm1_present(struct cmd_context *cmd);
+
+int target_present(const char *target_name);
+
+void activation_exit(void);
+
+int lv_suspend(struct cmd_context *cmd, const char *lvid_s);
+int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s);
+int lv_resume(struct cmd_context *cmd, const char *lvid_s);
+int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s);
+int lv_activate(struct cmd_context *cmd, const char *lvid_s);
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s);
+int lv_deactivate(struct cmd_context *cmd, const char *lvid_s);
+
+int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv);
 
 /*
  * Returns 1 if info structure has been populated, else 0.
  */
-int lv_info(struct logical_volume *lv, struct dm_info *info);
+int lv_info(const struct logical_volume *lv, struct lvinfo *info);
+int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
+		    struct lvinfo *info);
+
+/*
+ * Returns 1 if activate_lv has been set: 1 = activate; 0 = don't.
+ */
+int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
+			 int *activate_lv);
+
 /*
  * Returns 1 if percent has been set, else 0.
  */
 int lv_snapshot_percent(struct logical_volume *lv, float *percent);
-
-/*
- * These should eventually use config file
- * to determine whether or not to activate
- */
-int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s);
-int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s);
-int lv_activate(struct cmd_context *cmd, const char *lvid_s);
-int lv_deactivate(struct cmd_context *cmd, const char *lvid_s);
-
-/*
- * FIXME:
- * I don't like the *lvs_in_vg* function names.
- */
+int lv_mirror_percent(struct logical_volume *lv, int wait, float *percent,
+		      uint32_t *event_nr);
 
 /*
  * Return number of LVs in the VG that are active.

lib/activate/dev_manager.h

@@ -1,23 +1,33 @@
 /*
- * Copyright (C) 2002 Sistina Software (UK) Limited.
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_DEV_MANAGER_H
 #define _LVM_DEV_MANAGER_H
 
-#include "metadata.h"
-
-#include <libdevmapper.h>
-
+struct logical_volume;
+struct cmd_context;
 struct dev_manager;
+struct dm_info;
 
 /*
  * Constructor and destructor.
  */
-struct dev_manager *dev_manager_create(const char *vg_name);
+struct dev_manager *dev_manager_create(struct cmd_context *cmd,
+				       const char *vg_name);
 void dev_manager_destroy(struct dev_manager *dm);
+void dev_manager_exit(void);
 
 /*
  * The device handler is responsible for creating all the layered
@@ -25,14 +35,21 @@ void dev_manager_destroy(struct dev_manager *dm);
  * (eg, an origin is created before its snapshot, but is not
  * unsuspended until the snapshot is also created.)
  */
-int dev_manager_info(struct dev_manager *dm, struct logical_volume *lv,
-		     struct dm_info *info);
+int dev_manager_info(struct dev_manager *dm, const struct logical_volume *lv,
+		     int mknodes, struct dm_info *info);
 int dev_manager_snapshot_percent(struct dev_manager *dm,
 				 struct logical_volume *lv, float *percent);
+int dev_manager_mirror_percent(struct dev_manager *dm,
+			       struct logical_volume *lv, int wait,
+			       float *percent, uint32_t *event_nr);
 int dev_manager_suspend(struct dev_manager *dm, struct logical_volume *lv);
 int dev_manager_activate(struct dev_manager *dm, struct logical_volume *lv);
 int dev_manager_deactivate(struct dev_manager *dm, struct logical_volume *lv);
 
+int dev_manager_lv_mknodes(const struct logical_volume *lv);
+int dev_manager_lv_rmnodes(const struct logical_volume *lv);
+int dev_manager_mknodes(void);
+
 /*
  * Put the desired changes into effect.
  */

lib/activate/fs.c

@@ -1,31 +1,42 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "fs.h"
-#include "log.h"
 #include "toolcontext.h"
 #include "lvm-string.h"
 #include "lvm-file.h"
+#include "memlock.h"
+
+#ifdef HAVE_SELINUX
+#  include "selinux.h"
+#endif
 
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <limits.h>
-#include <stdio.h>
-#include <string.h>
-
+#include <dirent.h>
 #include <libdevmapper.h>
 
-static int _mk_dir(struct volume_group *vg)
+static int _mk_dir(const char *dev_dir, const char *vg_name)
 {
 	char vg_path[PATH_MAX];
 
 	if (lvm_snprintf(vg_path, sizeof(vg_path), "%s%s",
-			 vg->cmd->dev_dir, vg->name) == -1) {
+			 dev_dir, vg_name) == -1) {
 		log_error("Couldn't construct name of volume "
 			  "group directory.");
 		return 0;
@@ -43,12 +54,12 @@ static int _mk_dir(struct volume_group *vg)
 	return 1;
 }
 
-static int _rm_dir(struct volume_group *vg)
+static int _rm_dir(const char *dev_dir, const char *vg_name)
 {
 	char vg_path[PATH_MAX];
 
 	if (lvm_snprintf(vg_path, sizeof(vg_path), "%s%s",
-			 vg->cmd->dev_dir, vg->name) == -1) {
+			 dev_dir, vg_name) == -1) {
 		log_error("Couldn't construct name of volume "
 			  "group directory.");
 		return 0;
@@ -62,32 +73,100 @@ static int _rm_dir(struct volume_group *vg)
 	return 1;
 }
 
-static int _mk_link(struct logical_volume *lv, const char *dev)
+static void _rm_blks(const char *dir)
 {
-	char lv_path[PATH_MAX], link_path[PATH_MAX];
+	const char *name;
+	char path[PATH_MAX];
+	struct dirent *dirent;
+	struct stat buf;
+	DIR *d;
+
+	if (!(d = opendir(dir))) {
+		log_sys_error("opendir", dir);
+		return;
+	}
+
+	while ((dirent = readdir(d))) {
+		name = dirent->d_name;
+
+		if (!strcmp(name, ".") || !strcmp(name, ".."))
+			continue;
+
+		if (lvm_snprintf(path, sizeof(path), "%s/%s", dir, name) == -1) {
+			log_error("Couldn't create path for %s", name);
+			continue;
+		}
+
+		if (!lstat(path, &buf)) {
+			if (!S_ISBLK(buf.st_mode))
+				continue;
+			log_very_verbose("Removing %s", path);
+			if (unlink(path) < 0)
+				log_sys_error("unlink", path);
+		}
+	}
+}
+
+static int _mk_link(const char *dev_dir, const char *vg_name,
+		    const char *lv_name, const char *dev)
+{
+	char lv_path[PATH_MAX], link_path[PATH_MAX], lvm1_group_path[PATH_MAX];
+	char vg_path[PATH_MAX];
 	struct stat buf;
 
-	if (lvm_snprintf(lv_path, sizeof(lv_path), "%s%s/%s",
-			 lv->vg->cmd->dev_dir, lv->vg->name, lv->name) == -1) {
+	if (lvm_snprintf(vg_path, sizeof(vg_path), "%s%s",
+			 dev_dir, vg_name) == -1) {
+		log_error("Couldn't create path for volume group dir %s",
+			  vg_name);
+		return 0;
+	}
+
+	if (lvm_snprintf(lv_path, sizeof(lv_path), "%s/%s", vg_path,
+			 lv_name) == -1) {
 		log_error("Couldn't create source pathname for "
-			  "logical volume link %s", lv->name);
+			  "logical volume link %s", lv_name);
 		return 0;
 	}
 
 	if (lvm_snprintf(link_path, sizeof(link_path), "%s/%s",
 			 dm_dir(), dev) == -1) {
 		log_error("Couldn't create destination pathname for "
-			  "logical volume link for %s", lv->name);
+			  "logical volume link for %s", lv_name);
 		return 0;
 	}
 
+	if (lvm_snprintf(lvm1_group_path, sizeof(lvm1_group_path), "%s/group",
+			 vg_path) == -1) {
+		log_error("Couldn't create pathname for LVM1 group file for %s",
+			  vg_name);
+		return 0;
+	}
+
+	/* To reach this point, the VG must have been locked.
+	 * As locking fails if the VG is active under LVM1, it's 
+	 * now safe to remove any LVM1 devices we find here
+	 * (as well as any existing LVM2 symlink). */
+	if (!lstat(lvm1_group_path, &buf)) {
+		if (!S_ISCHR(buf.st_mode)) {
+			log_error("Non-LVM1 character device found at %s",
+				  lvm1_group_path);
+		} else {
+			_rm_blks(vg_path);
+
+			log_very_verbose("Removing %s", lvm1_group_path);
+			if (unlink(lvm1_group_path) < 0)
+				log_sys_error("unlink", lvm1_group_path);
+		}
+	}
+
 	if (!lstat(lv_path, &buf)) {
-		if (!S_ISLNK(buf.st_mode)) {
+		if (!S_ISLNK(buf.st_mode) && !S_ISBLK(buf.st_mode)) {
 			log_error("Symbolic link %s not created: file exists",
 				  link_path);
 			return 0;
 		}
 
+		log_very_verbose("Removing %s", lv_path);
 		if (unlink(lv_path) < 0) {
 			log_sys_error("unlink", lv_path);
 			return 0;
@@ -100,26 +179,36 @@ static int _mk_link(struct logical_volume *lv, const char *dev)
 		return 0;
 	}
 
+#ifdef HAVE_SELINUX
+        if (!set_selinux_context(lv_path)) {
+                stack;
+                return 0;
+        }
+#endif
+
 	return 1;
 }
 
-static int _rm_link(struct logical_volume *lv, const char *lv_name)
+static int _rm_link(const char *dev_dir, const char *vg_name,
+		    const char *lv_name)
 {
 	struct stat buf;
 	char lv_path[PATH_MAX];
 
 	if (lvm_snprintf(lv_path, sizeof(lv_path), "%s%s/%s",
-			 lv->vg->cmd->dev_dir, lv->vg->name, lv_name) == -1) {
+			 dev_dir, vg_name, lv_name) == -1) {
 		log_error("Couldn't determine link pathname.");
 		return 0;
 	}
 
-	log_very_verbose("Removing link %s", lv_path);
 	if (lstat(lv_path, &buf) || !S_ISLNK(buf.st_mode)) {
-		log_error("%s not symbolic link - not removing", lv_path);
+		if (errno != ENOENT)
+			log_error("%s not symbolic link - not removing",
+				  lv_path);
 		return 0;
 	}
 
+	log_very_verbose("Removing link %s", lv_path);
 	if (unlink(lv_path) < 0) {
 		log_sys_error("unlink", lv_path);
 		return 0;
@@ -128,35 +217,143 @@ static int _rm_link(struct logical_volume *lv, const char *lv_name)
 	return 1;
 }
 
-int fs_add_lv(struct logical_volume *lv, const char *dev)
+typedef enum {
+	FS_ADD,
+	FS_DEL,
+	FS_RENAME
+} fs_op_t;
+
+static int _do_fs_op(fs_op_t type, const char *dev_dir, const char *vg_name,
+		     const char *lv_name, const char *dev,
+		     const char *old_lv_name)
 {
-	if (!_mk_dir(lv->vg) || !_mk_link(lv, dev)) {
-		stack;
-		return 0;
+	switch (type) {
+	case FS_ADD:
+		if (!_mk_dir(dev_dir, vg_name) ||
+		    !_mk_link(dev_dir, vg_name, lv_name, dev)) {
+			stack;
+			return 0;
+		}
+		break;
+	case FS_DEL:
+		if (!_rm_link(dev_dir, vg_name, lv_name) ||
+		    !_rm_dir(dev_dir, vg_name)) {
+			stack;
+			return 0;
+		}
+		break;
+		/* FIXME Use rename() */
+	case FS_RENAME:
+		if (old_lv_name && !_rm_link(dev_dir, vg_name, old_lv_name))
+			stack;
+
+		if (!_mk_link(dev_dir, vg_name, lv_name, dev))
+			stack;
 	}
 
 	return 1;
 }
 
-int fs_del_lv(struct logical_volume *lv)
+static LIST_INIT(_fs_ops);
+
+struct fs_op_parms {
+	struct list list;
+	fs_op_t type;
+	char *dev_dir;
+	char *vg_name;
+	char *lv_name;
+	char *dev;
+	char *old_lv_name;
+	char names[0];
+};
+
+static void _store_str(char **pos, char **ptr, const char *str)
 {
-	if (!_rm_link(lv, lv->name) || !_rm_dir(lv->vg)) {
-		stack;
+	strcpy(*pos, str);
+	*ptr = *pos;
+	*pos += strlen(*ptr) + 1;
+}
+
+static int _stack_fs_op(fs_op_t type, const char *dev_dir, const char *vg_name,
+			const char *lv_name, const char *dev,
+			const char *old_lv_name)
+{
+	struct fs_op_parms *fsp;
+	size_t len = strlen(dev_dir) + strlen(vg_name) + strlen(lv_name) +
+	    strlen(dev) + strlen(old_lv_name) + 5;
+	char *pos;
+
+	if (!(fsp = dbg_malloc(sizeof(*fsp) + len))) {
+		log_error("No space to stack fs operation");
 		return 0;
 	}
 
+	pos = fsp->names;
+	fsp->type = type;
+
+	_store_str(&pos, &fsp->dev_dir, dev_dir);
+	_store_str(&pos, &fsp->vg_name, vg_name);
+	_store_str(&pos, &fsp->lv_name, lv_name);
+	_store_str(&pos, &fsp->dev, dev);
+	_store_str(&pos, &fsp->old_lv_name, old_lv_name);
+
+	list_add(&_fs_ops, &fsp->list);
+
 	return 1;
 }
 
-/* FIXME Use rename() */
+static void _pop_fs_ops(void)
+{
+	struct list *fsph, *fspht;
+	struct fs_op_parms *fsp;
+
+	list_iterate_safe(fsph, fspht, &_fs_ops) {
+		fsp = list_item(fsph, struct fs_op_parms);
+		_do_fs_op(fsp->type, fsp->dev_dir, fsp->vg_name, fsp->lv_name,
+			  fsp->dev, fsp->old_lv_name);
+		list_del(&fsp->list);
+		dbg_free(fsp);
+	}
+}
+
+static int _fs_op(fs_op_t type, const char *dev_dir, const char *vg_name,
+		  const char *lv_name, const char *dev, const char *old_lv_name)
+{
+	if (memlock()) {
+		if (!_stack_fs_op(type, dev_dir, vg_name, lv_name, dev,
+				  old_lv_name)) {
+			stack;
+			return 0;
+		}
+		return 1;
+	}
+
+	return _do_fs_op(type, dev_dir, vg_name, lv_name, dev, old_lv_name);
+}
+
+int fs_add_lv(const struct logical_volume *lv, const char *dev)
+{
+	return _fs_op(FS_ADD, lv->vg->cmd->dev_dir, lv->vg->name, lv->name,
+		      dev, "");
+}
+
+int fs_del_lv(const struct logical_volume *lv)
+{
+	return _fs_op(FS_DEL, lv->vg->cmd->dev_dir, lv->vg->name, lv->name,
+		      "", "");
+}
+
 int fs_rename_lv(struct logical_volume *lv,
 		 const char *dev, const char *old_name)
 {
-	if (old_name && !_rm_link(lv, old_name))
-		stack;
-
-	if (!_mk_link(lv, dev))
-		stack;
-
-	return 1;
+	return _fs_op(FS_RENAME, lv->vg->cmd->dev_dir, lv->vg->name, lv->name,
+		      dev, old_name);
+}
+
+void fs_unlock(void)
+{
+	if (!memlock()) {
+		dm_lib_release();
+		_pop_fs_ops();
+	}
 }

lib/activate/fs.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_FS_H
@@ -14,10 +23,10 @@
  * up the volume group directory in /dev and the
  * symbolic links to the dm device.
  */
-int fs_add_lv(struct logical_volume *lv, const char *dev);
-int fs_del_lv(struct logical_volume *lv);
+int fs_add_lv(const struct logical_volume *lv, const char *dev);
+int fs_del_lv(const struct logical_volume *lv);
 int fs_rename_lv(struct logical_volume *lv,
 		 const char *dev, const char *old_name);
-
+void fs_unlock(void);
 
 #endif

lib/activate/targets.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_TARGETS_H
+#define _LVM_TARGETS_H
+
+struct dev_manager;
+struct lv_segment;
+
+int compose_areas_line(struct dev_manager *dm, struct lv_segment *seg,                                 char *params, size_t paramsize, int *pos,
+		                        int start_area, int areas);
+
+#endif

lib/cache/lvmcache.c

@@ -0,0 +1,581 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "lib.h"
+#include "lvmcache.h"
+#include "hash.h"
+#include "toolcontext.h"
+#include "dev-cache.h"
+#include "metadata.h"
+#include "filter.h"
+#include "memlock.h"
+#include "str_list.h"
+
+static struct hash_table *_pvid_hash = NULL;
+static struct hash_table *_vgid_hash = NULL;
+static struct hash_table *_vgname_hash = NULL;
+static struct hash_table *_lock_hash = NULL;
+static struct list _vginfos;
+static int _has_scanned = 0;
+static int _vgs_locked = 0;
+
+int lvmcache_init(void)
+{
+	list_init(&_vginfos);
+
+	if (!(_vgname_hash = hash_create(128)))
+		return 0;
+
+	if (!(_vgid_hash = hash_create(128)))
+		return 0;
+
+	if (!(_pvid_hash = hash_create(128)))
+		return 0;
+
+	if (!(_lock_hash = hash_create(128)))
+		return 0;
+
+	return 1;
+}
+
+void lvmcache_lock_vgname(const char *vgname, int read_only)
+{
+	if (!_lock_hash && !lvmcache_init()) {
+		log_error("Internal cache initialisation failed");
+		return;
+	}
+
+	if (!hash_insert(_lock_hash, vgname, (void *) 1))
+		log_error("Cache locking failure for %s", vgname);
+
+	_vgs_locked++;
+}
+
+static int _vgname_is_locked(const char *vgname) __attribute__ ((unused));
+static int _vgname_is_locked(const char *vgname)
+{
+	if (!_lock_hash)
+		return 0;
+
+	return hash_lookup(_lock_hash, vgname) ? 1 : 0;
+}
+
+void lvmcache_unlock_vgname(const char *vgname)
+{
+	/* FIXME: Clear all CACHE_LOCKED flags in this vg */
+	hash_remove(_lock_hash, vgname);
+
+	/* FIXME Do this per-VG */
+	if (!--_vgs_locked)
+		dev_close_all();
+}
+
+int vgs_locked(void)
+{
+	return _vgs_locked;
+}
+
+struct lvmcache_vginfo *vginfo_from_vgname(const char *vgname)
+{
+	struct lvmcache_vginfo *vginfo;
+
+	if (!_vgname_hash)
+		return NULL;
+
+	if (!(vginfo = hash_lookup(_vgname_hash, vgname)))
+		return NULL;
+
+	return vginfo;
+}
+
+const struct format_type *fmt_from_vgname(const char *vgname)
+{
+	struct lvmcache_vginfo *vginfo;
+
+	if (!(vginfo = vginfo_from_vgname(vgname)))
+		return NULL;
+
+	return vginfo->fmt;
+}
+
+struct lvmcache_vginfo *vginfo_from_vgid(const char *vgid)
+{
+	struct lvmcache_vginfo *vginfo;
+	char id[ID_LEN + 1];
+
+	if (!_vgid_hash || !vgid)
+		return NULL;
+
+	/* vgid not necessarily NULL-terminated */
+	strncpy(&id[0], vgid, ID_LEN);
+	id[ID_LEN] = '\0';
+
+	if (!(vginfo = hash_lookup(_vgid_hash, id)))
+		return NULL;
+
+	return vginfo;
+}
+
+struct lvmcache_info *info_from_pvid(const char *pvid)
+{
+	struct lvmcache_info *info;
+	char id[ID_LEN + 1];
+
+	if (!_pvid_hash || !pvid)
+		return NULL;
+
+	strncpy(&id[0], pvid, ID_LEN);
+	id[ID_LEN] = '\0';
+
+	if (!(info = hash_lookup(_pvid_hash, id)))
+		return NULL;
+
+	return info;
+}
+
+static void _rescan_entry(struct lvmcache_info *info)
+{
+	struct label *label;
+
+	if (info->status & CACHE_INVALID)
+		label_read(info->dev, &label);
+}
+
+static int _scan_invalid(void)
+{
+	hash_iter(_pvid_hash, (iterate_fn) _rescan_entry);
+
+	return 1;
+}
+
+int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)
+{
+	struct label *label;
+	struct dev_iter *iter;
+	struct device *dev;
+	struct list *fmth;
+	struct format_type *fmt;
+
+	static int _scanning_in_progress = 0;
+	int r = 0;
+
+	/* Avoid recursion when a PVID can't be found! */
+	if (_scanning_in_progress)
+		return 0;
+
+	_scanning_in_progress = 1;
+
+	if (!_vgname_hash && !lvmcache_init()) {
+		log_error("Internal cache initialisation failed");
+		goto out;
+	}
+
+	if (_has_scanned && !full_scan) {
+		r = _scan_invalid();
+		goto out;
+	}
+
+	if (!(iter = dev_iter_create(cmd->filter))) {
+		log_error("dev_iter creation failed");
+		goto out;
+	}
+
+	while ((dev = dev_iter_get(iter)))
+		label_read(dev, &label);
+
+	dev_iter_destroy(iter);
+
+	_has_scanned = 1;
+
+	/* Perform any format-specific scanning e.g. text files */
+	list_iterate(fmth, &cmd->formats) {
+		fmt = list_item(fmth, struct format_type);
+		if (fmt->ops->scan && !fmt->ops->scan(fmt))
+			goto out;
+	}
+
+	r = 1;
+
+      out:
+	_scanning_in_progress = 0;
+
+	return r;
+}
+
+struct list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan)
+{
+	struct list *vgnames;
+	struct lvmcache_vginfo *vgi;
+
+	lvmcache_label_scan(cmd, full_scan);
+
+	if (!(vgnames = str_list_create(cmd->mem))) {
+		log_error("vgnames list allocation failed");
+		return NULL;
+	}
+
+	list_iterate_items(vgi, &_vginfos) {
+		if (!str_list_add(cmd->mem, vgnames, 
+				  pool_strdup(cmd->mem, vgi->vgname))) {
+			log_error("strlist allocation failed");
+			return NULL;
+		}
+	}
+
+	return vgnames;
+}
+
+struct device *device_from_pvid(struct cmd_context *cmd, struct id *pvid)
+{
+	struct label *label;
+	struct lvmcache_info *info;
+
+	/* Already cached ? */
+	if ((info = info_from_pvid((char *) pvid))) {
+		if (label_read(info->dev, &label)) {
+			info = (struct lvmcache_info *) label->info;
+			if (id_equal(pvid, (struct id *) &info->dev->pvid))
+				return info->dev;
+		}
+	}
+
+	lvmcache_label_scan(cmd, 0);
+
+	/* Try again */
+	if ((info = info_from_pvid((char *) pvid))) {
+		if (label_read(info->dev, &label)) {
+			info = (struct lvmcache_info *) label->info;
+			if (id_equal(pvid, (struct id *) &info->dev->pvid))
+				return info->dev;
+		}
+	}
+
+	if (memlock())
+		return NULL;
+
+	lvmcache_label_scan(cmd, 1);
+
+	/* Try again */
+	if ((info = info_from_pvid((char *) pvid))) {
+		if (label_read(info->dev, &label)) {
+			info = (struct lvmcache_info *) label->info;
+			if (id_equal(pvid, (struct id *) &info->dev->pvid))
+				return info->dev;
+		}
+	}
+
+	return NULL;
+}
+
+static void _drop_vginfo(struct lvmcache_info *info)
+{
+	if (!list_empty(&info->list)) {
+		list_del(&info->list);
+		list_init(&info->list);
+	}
+
+	if (info->vginfo && list_empty(&info->vginfo->infos)) {
+		hash_remove(_vgname_hash, info->vginfo->vgname);
+		if (info->vginfo->vgname)
+			dbg_free(info->vginfo->vgname);
+		if (*info->vginfo->vgid)
+			hash_remove(_vgid_hash, info->vginfo->vgid);
+		list_del(&info->vginfo->list);
+		dbg_free(info->vginfo);
+	}
+
+	info->vginfo = NULL;
+}
+
+/* Unused
+void lvmcache_del(struct lvmcache_info *info)
+{
+	if (info->dev->pvid[0] && _pvid_hash)
+		hash_remove(_pvid_hash, info->dev->pvid);
+
+	_drop_vginfo(info);
+
+	info->label->labeller->ops->destroy_label(info->label->labeller,
+						info->label); 
+	dbg_free(info);
+
+	return;
+} */
+
+static int _lvmcache_update_pvid(struct lvmcache_info *info, const char *pvid)
+{
+	if (!strcmp(info->dev->pvid, pvid))
+		return 1;
+	if (*info->dev->pvid) {
+		hash_remove(_pvid_hash, info->dev->pvid);
+	}
+	strncpy(info->dev->pvid, pvid, sizeof(info->dev->pvid));
+	if (!hash_insert(_pvid_hash, pvid, info)) {
+		log_error("_lvmcache_update: pvid insertion failed: %s", pvid);
+		return 0;
+	}
+
+	return 1;
+}
+
+static int _lvmcache_update_vgid(struct lvmcache_info *info, const char *vgid)
+{
+	if (!vgid || !info->vginfo || !strncmp(info->vginfo->vgid, vgid,
+					       sizeof(info->vginfo->vgid)))
+		return 1;
+
+	if (info->vginfo && *info->vginfo->vgid)
+		hash_remove(_vgid_hash, info->vginfo->vgid);
+	if (!vgid)
+		return 1;
+
+	strncpy(info->vginfo->vgid, vgid, sizeof(info->vginfo->vgid));
+	info->vginfo->vgid[sizeof(info->vginfo->vgid) - 1] = '\0';
+	if (!hash_insert(_vgid_hash, info->vginfo->vgid, info->vginfo)) {
+		log_error("_lvmcache_update: vgid hash insertion failed: %s",
+			  info->vginfo->vgid);
+		return 0;
+	}
+
+	return 1;
+}
+
+int lvmcache_update_vgname(struct lvmcache_info *info, const char *vgname)
+{
+	struct lvmcache_vginfo *vginfo;
+
+	/* If vgname is NULL and we don't already have a vgname, 
+	 * assume ORPHAN - we want every entry to have a vginfo
+	 * attached for scanning reasons.
+	 */
+	if (!vgname && !info->vginfo)
+		vgname = ORPHAN;
+
+	if (!vgname || (info->vginfo && !strcmp(info->vginfo->vgname, vgname)))
+		return 1;
+
+	/* Remove existing vginfo entry */
+	_drop_vginfo(info);
+
+	/* Get existing vginfo or create new one */
+	if (!(vginfo = vginfo_from_vgname(vgname))) {
+		if (!(vginfo = dbg_malloc(sizeof(*vginfo)))) {
+			log_error("lvmcache_update_vgname: list alloc failed");
+			return 0;
+		}
+		memset(vginfo, 0, sizeof(*vginfo));
+		if (!(vginfo->vgname = dbg_strdup(vgname))) {
+			dbg_free(vginfo);
+			log_error("cache vgname alloc failed for %s", vgname);
+			return 0;
+		}
+		list_init(&vginfo->infos);
+		if (!hash_insert(_vgname_hash, vginfo->vgname, vginfo)) {
+			log_error("cache_update: vg hash insertion failed: %s",
+				  vginfo->vgname);
+			dbg_free(vginfo->vgname);
+			dbg_free(vginfo);
+			return 0;
+		}
+		/* Ensure orphans appear last on list_iterate */
+		if (!*vgname)
+			list_add(&_vginfos, &vginfo->list);
+		else
+			list_add_h(&_vginfos, &vginfo->list);
+	}
+
+	info->vginfo = vginfo;
+	list_add(&vginfo->infos, &info->list);
+
+	/* FIXME Check consistency of list! */
+	vginfo->fmt = info->fmt;
+
+	return 1;
+}
+
+int lvmcache_update_vg(struct volume_group *vg)
+{
+	struct list *pvh;
+	struct physical_volume *pv;
+	struct lvmcache_info *info;
+	char pvid_s[ID_LEN + 1];
+	int vgid_updated = 0;
+
+	pvid_s[sizeof(pvid_s) - 1] = '\0';
+
+	list_iterate(pvh, &vg->pvs) {
+		pv = list_item(pvh, struct pv_list)->pv;
+		strncpy(pvid_s, (char *) &pv->id, sizeof(pvid_s) - 1);
+		/* FIXME Could pv->dev->pvid ever be different? */
+		if ((info = info_from_pvid(pvid_s))) {
+			lvmcache_update_vgname(info, vg->name);
+			if (!vgid_updated) {
+				_lvmcache_update_vgid(info, (char *) &vg->id);
+				vgid_updated = 1;
+			}
+		}
+	}
+
+	return 1;
+}
+
+struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
+				   struct device *dev,
+				   const char *vgname, const char *vgid)
+{
+	struct label *label;
+	struct lvmcache_info *existing, *info;
+	char pvid_s[ID_LEN + 1];
+
+	if (!_vgname_hash && !lvmcache_init()) {
+		log_error("Internal cache initialisation failed");
+		return NULL;
+	}
+
+	strncpy(pvid_s, pvid, sizeof(pvid_s));
+	pvid_s[sizeof(pvid_s) - 1] = '\0';
+
+	if (!(existing = info_from_pvid(pvid_s)) &&
+	    !(existing = info_from_pvid(dev->pvid))) {
+		if (!(label = label_create(labeller))) {
+			stack;
+			return NULL;
+		}
+		if (!(info = dbg_malloc(sizeof(*info)))) {
+			log_error("lvmcache_info allocation failed");
+			label_destroy(label);
+			return NULL;
+		}
+		memset(info, 0, sizeof(*info));
+
+		label->info = info;
+		info->label = label;
+		list_init(&info->list);
+		info->dev = dev;
+	} else {
+		if (existing->dev != dev) {
+			/* Is the existing entry a duplicate pvid e.g. md ? */
+			if (MAJOR(existing->dev->dev) == md_major() &&
+			    MAJOR(dev->dev) != md_major()) {
+				log_very_verbose("Ignoring duplicate PV %s on "
+						 "%s - using md %s",
+						 pvid, dev_name(dev),
+						 dev_name(existing->dev));
+				return NULL;
+			} else if (MAJOR(existing->dev->dev) != md_major() &&
+				   MAJOR(dev->dev) == md_major())
+				log_very_verbose("Duplicate PV %s on %s - "
+						 "using md %s", pvid,
+						 dev_name(existing->dev),
+						 dev_name(dev));
+			else
+				log_error("Found duplicate PV %s: using %s not "
+					  "%s", pvid, dev_name(dev),
+					  dev_name(existing->dev));
+		}
+		info = existing;
+		/* Has labeller changed? */
+		if (info->label->labeller != labeller) {
+			label_destroy(info->label);
+			if (!(info->label = label_create(labeller))) {
+				/* FIXME leaves info without label! */
+				stack;
+				return NULL;
+			}
+			info->label->info = info;
+		}
+		label = info->label;
+	}
+
+	info->fmt = (const struct format_type *) labeller->private;
+	info->status |= CACHE_INVALID;
+
+	if (!_lvmcache_update_pvid(info, pvid_s)) {
+		if (!existing) {
+			dbg_free(info);
+			label_destroy(label);
+		}
+		return NULL;
+	}
+
+	if (!lvmcache_update_vgname(info, vgname)) {
+		if (!existing) {
+			hash_remove(_pvid_hash, pvid_s);
+			strcpy(info->dev->pvid, "");
+			dbg_free(info);
+			label_destroy(label);
+		}
+		return NULL;
+	}
+
+	if (!_lvmcache_update_vgid(info, vgid))
+		/* Non-critical */
+		stack;
+
+	return info;
+}
+
+static void _lvmcache_destroy_entry(struct lvmcache_info *info)
+{
+	if (!list_empty(&info->list))
+		list_del(&info->list);
+	strcpy(info->dev->pvid, "");
+	label_destroy(info->label);
+	dbg_free(info);
+}
+
+static void _lvmcache_destroy_vgnamelist(struct lvmcache_vginfo *vginfo)
+{
+	if (vginfo->vgname)
+		dbg_free(vginfo->vgname);
+	dbg_free(vginfo);
+}
+
+static void _lvmcache_destroy_lockname(int present)
+{
+	/* Nothing to do */
+}
+
+void lvmcache_destroy(void)
+{
+	_has_scanned = 0;
+
+	if (_vgid_hash) {
+		hash_destroy(_vgid_hash);
+		_vgid_hash = NULL;
+	}
+
+	if (_pvid_hash) {
+		hash_iter(_pvid_hash, (iterate_fn) _lvmcache_destroy_entry);
+		hash_destroy(_pvid_hash);
+		_pvid_hash = NULL;
+	}
+
+	if (_vgname_hash) {
+		hash_iter(_vgname_hash,
+			  (iterate_fn) _lvmcache_destroy_vgnamelist);
+		hash_destroy(_vgname_hash);
+		_vgname_hash = NULL;
+	}
+
+	if (_lock_hash) {
+		hash_iter(_lock_hash, (iterate_fn) _lvmcache_destroy_lockname);
+		hash_destroy(_lock_hash);
+		_lock_hash = NULL;
+	}
+
+	list_init(&_vginfos);
+}

lib/cache/lvmcache.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ifndef _LVM_CACHE_H
+#define _LVM_CACHE_H
+
+#include "dev-cache.h"
+#include "uuid.h"
+#include "label.h"
+
+#define ORPHAN ""
+
+#define CACHE_INVALID	0x00000001
+#define CACHE_LOCKED	0x00000002
+
+/* LVM specific per-volume info */
+/* Eventual replacement for struct physical_volume perhaps? */
+
+struct cmd_context;
+struct format_type;
+struct volume_group;
+
+struct lvmcache_vginfo {
+	struct list list;	/* Join these vginfos together */
+	struct list infos;	/* List head for lvmcache_infos */
+	char *vgname;		/* "" == orphan */
+	char vgid[ID_LEN + 1];
+	const struct format_type *fmt;
+};
+
+struct lvmcache_info {
+	struct list list;	/* Join VG members together */
+	struct list mdas;	/* list head for metadata areas */
+	struct list das;	/* list head for data areas */
+	struct lvmcache_vginfo *vginfo;	/* NULL == unknown */
+	struct label *label;
+	const struct format_type *fmt;
+	struct device *dev;
+	uint64_t device_size;	/* Bytes */
+	uint32_t status;
+};
+
+int lvmcache_init(void);
+void lvmcache_destroy(void);
+
+/* Set full_scan to 1 to reread every filtered device label */
+int lvmcache_label_scan(struct cmd_context *cmd, int full_scan);
+
+/* Add/delete a device */
+struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
+				   struct device *dev,
+				   const char *vgname, const char *vgid);
+void lvmcache_del(struct lvmcache_info *info);
+
+/* Update things */
+int lvmcache_update_vgname(struct lvmcache_info *info, const char *vgname);
+int lvmcache_update_vg(struct volume_group *vg);
+
+void lvmcache_lock_vgname(const char *vgname, int read_only);
+void lvmcache_unlock_vgname(const char *vgname);
+
+/* Queries */
+const struct format_type *fmt_from_vgname(const char *vgname);
+struct lvmcache_vginfo *vginfo_from_vgname(const char *vgname);
+struct lvmcache_vginfo *vginfo_from_vgid(const char *vgid);
+struct lvmcache_info *info_from_pvid(const char *pvid);
+struct device *device_from_pvid(struct cmd_context *cmd, struct id *pvid);
+int vgs_locked(void);
+
+/* Returns list of struct str_lists containing pool-allocated copy of vgnames */
+/* Set full_scan to 1 to reread every filtered device label */
+struct list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan);
+
+#endif

lib/commands/errors.h

@@ -1,16 +1,24 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_ERRORS_H
 #define _LVM_ERRORS_H
 
-#define EINVALID_CMD_LINE	1
-#define ENO_SUCH_CMD		3
-#define ECMD_PROCESSED		4
+#define ECMD_PROCESSED		1
+#define ENO_SUCH_CMD		2
+#define EINVALID_CMD_LINE	3
 #define ECMD_FAILED		5
 
 #endif
-

lib/commands/toolcontext.h

@@ -1,37 +1,92 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
  *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_TOOLCONTEXT_H
 #define _LVM_TOOLCONTEXT_H
 
 #include "dev-cache.h"
-#include "config.h"
 #include "pool.h"
-#include "metadata.h"
 
-/* command-instance-related variables needed by library */
-struct cmd_context {
-	/* format handler allocates all objects from here */
-	struct pool *mem;
+#include <stdio.h>
+#include <limits.h>
 
-	struct format_type *fmt;	/* Current format to use by default */
+/*
+ * Config options that can be changed while commands are processed
+ */
+struct config_info {
+	int debug;
+	int verbose;
+	int test;
+	int syslog;
+	int activation;
+	int suffix;
+	uint64_t unit_factor;
+	char unit_type;
+	const char *msg_prefix;
+	int cmd_name;		/* Show command name? */
 
-	/* FIXME Move into dynamic list */
-	struct format_type *fmt1;	/* Format1 */
-	struct format_type *fmtt;	/* Format_text */
+	int archive;		/* should we archive ? */
+	int backup;		/* should we backup ? */
 
-	char *cmd_line;
-	char *dev_dir;
-	struct dev_filter *filter;
-	struct config_file *cf;
+	struct format_type *fmt;
 
-	struct command *command;
-	struct uuid_map *um;
-	struct arg *args;
+	mode_t umask;
 };
 
+struct config_tree;
+
+/* FIXME Split into tool & library contexts */
+/* command-instance-related variables needed by library */
+struct cmd_context {
+	struct pool *libmem;	/* For permanent config data */
+	struct pool *mem;	/* Transient: Cleared between each command */
+
+	const struct format_type *fmt;	/* Current format to use by default */
+	struct format_type *fmt_backup;	/* Format to use for backups */
+
+	struct list formats;	/* Available formats */
+	struct list segtypes;	/* Available segment types */
+	const char *hostname;
+	const char *kernel_vsn;
+
+	char *cmd_line;
+	struct command *command;
+	struct arg *args;
+	char **argv;
+
+	struct dev_filter *filter;
+	int dump_filter;	/* Dump filter when exiting? */
+
+	struct list config_files;
+	int config_valid;
+	struct config_tree *cft;
+	struct config_info default_settings;
+	struct config_info current_settings;
+
+	/* List of defined tags */
+	struct list tags;
+	int hosttags;
+
+	char sys_dir[PATH_MAX];
+	char dev_dir[PATH_MAX];
+	char proc_dir[PATH_MAX];
+};
+
+struct cmd_context *create_toolcontext(struct arg *the_args);
+void destroy_toolcontext(struct cmd_context *cmd);
+int refresh_toolcontext(struct cmd_context *cmd);
+int config_files_changed(struct cmd_context *cmd);
+
 #endif

lib/config/config.c

@@ -1,21 +1,31 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include <sys/types.h>
+#include "lib.h"
+#include "config.h"
+#include "crc.h"
+#include "pool.h"
+#include "device.h"
+#include "str_list.h"
+#include "toolcontext.h"
+
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <ctype.h>
-#include <string.h>
-#include <errno.h>
-
-#include "config.h"
-#include "pool.h"
-#include "log.h"
 
 enum {
 	TOK_INT,
@@ -32,10 +42,10 @@ enum {
 };
 
 struct parser {
-	const char *fb, *fe;	/* file limits */
+	char *fb, *fe;		/* file limits */
 
 	int t;			/* token limits and type */
-	const char *tb, *te;
+	char *tb, *te;
 
 	int fd;			/* descriptor for file being parsed */
 	int line;		/* line number we are on */
@@ -44,11 +54,14 @@ struct parser {
 };
 
 struct cs {
-	struct config_file cf;
+	struct config_tree cft;
 	struct pool *mem;
+	time_t timestamp;
+	char *filename;
+	int exists;
 };
 
-static void _get_token(struct parser *p);
+static void _get_token(struct parser *p, int tok_prev);
 static void _eat_space(struct parser *p);
 static struct config_node *_file(struct parser *p);
 static struct config_node *_section(struct parser *p);
@@ -59,6 +72,8 @@ static struct config_value *_create_value(struct parser *p);
 static struct config_node *_create_node(struct parser *p);
 static char *_dup_tok(struct parser *p);
 
+static const int sep = '/';
+
 #define MAX_INDENT 32
 
 #define match(t) do {\
@@ -81,7 +96,7 @@ static int _tok_match(const char *str, const char *b, const char *e)
 /*
  * public interface
  */
-struct config_file *create_config_file(void)
+struct config_tree *create_config_tree(const char *filename)
 {
 	struct cs *c;
 	struct pool *mem = pool_create(10 * 1024);
@@ -91,28 +106,35 @@ struct config_file *create_config_file(void)
 		return 0;
 	}
 
-	if (!(c = pool_alloc(mem, sizeof(*c)))) {
+	if (!(c = pool_zalloc(mem, sizeof(*c)))) {
 		stack;
 		pool_destroy(mem);
 		return 0;
 	}
 
 	c->mem = mem;
-	c->cf.root = (struct config_node *) NULL;
-	return &c->cf;
+	c->cft.root = (struct config_node *) NULL;
+	c->timestamp = 0;
+	c->exists = 0;
+	if (filename)
+		c->filename = pool_strdup(c->mem, filename);
+	return &c->cft;
 }
 
-void destroy_config_file(struct config_file *cf)
+void destroy_config_tree(struct config_tree *cft)
 {
-	pool_destroy(((struct cs *) cf)->mem);
+	pool_destroy(((struct cs *) cft)->mem);
 }
 
-int read_config(struct config_file *cf, const char *file)
+int read_config_fd(struct config_tree *cft, struct device *dev,
+		   off_t offset, size_t size, off_t offset2, size_t size2,
+		   checksum_fn_t checksum_fn, uint32_t checksum)
 {
-	struct cs *c = (struct cs *) cf;
+	struct cs *c = (struct cs *) cft;
 	struct parser *p;
-	struct stat info;
-	int r = 1, fd;
+	int r = 0;
+	int use_mmap = 1;
+	off_t mmap_offset = 0;
 
 	if (!(p = pool_alloc(c->mem, sizeof(*p)))) {
 		stack;
@@ -120,50 +142,167 @@ int read_config(struct config_file *cf, const char *file)
 	}
 	p->mem = c->mem;
 
-	/* memory map the file */
-	if (stat(file, &info) || S_ISDIR(info.st_mode)) {
-		log_sys_error("stat", file);
-		return 0;
+	/* Only use mmap with regular files */
+	if (!(dev->flags & DEV_REGULAR) || size2)
+		use_mmap = 0;
+
+	if (use_mmap) {
+		mmap_offset = offset % getpagesize();
+		/* memory map the file */
+		p->fb = mmap((caddr_t) 0, size + mmap_offset, PROT_READ,
+			     MAP_PRIVATE, dev_fd(dev), offset - mmap_offset);
+		if (p->fb == (caddr_t) (-1)) {
+			log_sys_error("mmap", dev_name(dev));
+			goto out;
+		}
+		p->fb = p->fb + mmap_offset;
+	} else {
+		if (!(p->fb = dbg_malloc(size + size2))) {
+			stack;
+			return 0;
+		}
+		if (!dev_read(dev, (uint64_t) offset, size, p->fb)) {
+			log_error("Read from %s failed", dev_name(dev));
+			goto out;
+		}
+		if (size2) {
+			if (!dev_read(dev, (uint64_t) offset2, size2,
+				      p->fb + size)) {
+				log_error("Circular read from %s failed",
+					  dev_name(dev));
+				goto out;
+			}
+		}
 	}
 
-	if (info.st_size == 0) {
-		log_verbose("%s is empty", file);
-		return 1;
+	if (checksum_fn && checksum !=
+	    (checksum_fn(checksum_fn(INITIAL_CRC, p->fb, size),
+			 p->fb + size, size2))) {
+		log_error("%s: Checksum error", dev_name(dev));
+		goto out;
 	}
 
-	if ((fd = open(file, O_RDONLY)) < 0) {
-		log_sys_error("open", file);
-		return 0;
-	}
-
-	p->fb = mmap((caddr_t) 0, info.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
-	if (p->fb == (caddr_t) (-1)) {
-		log_sys_error("mmap", file);
-		close(fd);
-		return 0;
-	}
-	p->fe = p->fb + info.st_size;
+	p->fe = p->fb + size + size2;
 
 	/* parse */
 	p->tb = p->te = p->fb;
 	p->line = 1;
-	_get_token(p);
-	if (!(cf->root = _file(p))) {
+	_get_token(p, TOK_SECTION_E);
+	if (!(cft->root = _file(p))) {
 		stack;
-		r = 0;
+		goto out;
 	}
 
-	/* unmap the file */
-	if (munmap((char *) p->fb, info.st_size)) {
-		log_sys_error("munmap", file);
-		r = 0;
+	r = 1;
+
+      out:
+	if (!use_mmap)
+		dbg_free(p->fb);
+	else {
+		/* unmap the file */
+		if (munmap((char *) (p->fb - mmap_offset), size + mmap_offset)) {
+			log_sys_error("munmap", dev_name(dev));
+			r = 0;
+		}
 	}
 
-	close(fd);
 	return r;
 }
 
-static void _write_value(FILE * fp, struct config_value *v)
+int read_config_file(struct config_tree *cft)
+{
+	struct cs *c = (struct cs *) cft;
+	struct stat info;
+	struct device *dev;
+	int r = 1;
+
+	if (stat(c->filename, &info)) {
+		log_sys_error("stat", c->filename);
+		c->exists = 0;
+		return 0;
+	}
+
+	if (!S_ISREG(info.st_mode)) {
+		log_error("%s is not a regular file", c->filename);
+		c->exists = 0;
+		return 0;
+	}
+
+	c->exists = 1;
+
+	if (info.st_size == 0) {
+		log_verbose("%s is empty", c->filename);
+		return 1;
+	}
+
+	if (!(dev = dev_create_file(c->filename, NULL, NULL))) {
+		stack;
+		return 0;
+	}
+
+	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {
+		stack;
+		return 0;
+	}
+
+	r = read_config_fd(cft, dev, 0, (size_t) info.st_size, 0, 0,
+			   (checksum_fn_t) NULL, 0);
+
+	dev_close(dev);
+
+	c->timestamp = info.st_mtime;
+
+	return r;
+}
+
+time_t config_file_timestamp(struct config_tree *cft)
+{
+	struct cs *c = (struct cs *) cft;
+
+	return c->timestamp;
+}
+
+/*
+ * Return 1 if config files ought to be reloaded
+ */
+int config_file_changed(struct config_tree *cft)
+{
+	struct cs *c = (struct cs *) cft;
+	struct stat info;
+
+	if (!c->filename)
+		return 0;
+
+	if (stat(c->filename, &info) == -1) {
+		/* Ignore a deleted config file: still use original data */
+		if (errno == ENOENT) {
+			if (!c->exists)
+				return 0;
+			log_very_verbose("Config file %s has disappeared!",
+					 c->filename);
+			goto reload;
+		}
+		log_sys_error("stat", c->filename);
+		log_error("Failed to reload configuration files");
+		return 0;
+	}
+
+	if (!S_ISREG(info.st_mode)) {
+		log_error("Configuration file %s is not a regular file",
+			  c->filename);
+		goto reload;
+	}
+
+	/* Unchanged? */
+	if (c->timestamp == info.st_mtime)
+		return 0;
+
+      reload:
+	log_verbose("Detected config file change to %s", c->filename);
+	return 1;
+}
+
+static void _write_value(FILE *fp, struct config_value *v)
 {
 	switch (v->type) {
 	case CFG_STRING:
@@ -183,11 +322,12 @@ static void _write_value(FILE * fp, struct config_value *v)
 		break;
 
 	default:
-		log_err("Unknown value type");
+		log_error("_write_value: Unknown value type: %d", v->type);
+
 	}
 }
 
-static int _write_config(struct config_node *n, FILE * fp, int level)
+static int _write_config(struct config_node *n, FILE *fp, int level)
 {
 	char space[MAX_INDENT + 1];
 	int l = (level < MAX_INDENT) ? level : MAX_INDENT;
@@ -230,20 +370,28 @@ static int _write_config(struct config_node *n, FILE * fp, int level)
 	return 1;
 }
 
-int write_config(struct config_file *cf, const char *file)
+int write_config_file(struct config_tree *cft, const char *file)
 {
 	int r = 1;
-	FILE *fp = fopen(file, "w");
-	if (!fp) {
+	FILE *fp;
+
+	if (!file) {
+		fp = stdout;
+		file = "stdout";
+	} else if (!(fp = fopen(file, "w"))) {
 		log_sys_error("open", file);
 		return 0;
 	}
 
-	if (!_write_config(cf->root, fp, 0)) {
-		stack;
+	log_verbose("Dumping configuration to %s", file);
+	if (!_write_config(cft->root, fp, 0)) {
+		log_error("Failure while writing configuration");
 		r = 0;
 	}
-	fclose(fp);
+
+	if (fp != stdout)
+		fclose(fp);
+
 	return r;
 }
 
@@ -332,9 +480,8 @@ static struct config_value *_value(struct parser *p)
 				match(TOK_COMMA);
 		}
 		match(TOK_ARRAY_E);
-
 		/*
-		 * Special case an empty array.
+		 * Special case for an empty array.
 		 */
 		if (!h) {
 			if (!(h = _create_value(p)))
@@ -342,6 +489,7 @@ static struct config_value *_value(struct parser *p)
 
 			h->type = CFG_EMPTY_ARRAY;
 		}
+
 	} else
 		h = _type(p);
 
@@ -350,8 +498,9 @@ static struct config_value *_value(struct parser *p)
 
 static struct config_value *_type(struct parser *p)
 {
-	/* [0-9]+ | [0-9]*\.[0-9]* | ".*" */
+	/* [+-]{0,1}[0-9]+ | [0-9]*\.[0-9]* | ".*" */
 	struct config_value *v = _create_value(p);
+
 	if (!v)
 		return NULL;
 
@@ -392,22 +541,29 @@ static int _match_aux(struct parser *p, int t)
 	if (p->t != t)
 		return 0;
 
-	_get_token(p);
+	_get_token(p, t);
 	return 1;
 }
 
 /*
  * tokeniser
  */
-static void _get_token(struct parser *p)
+static void _get_token(struct parser *p, int tok_prev)
 {
+	int values_allowed = 0;
+
 	p->tb = p->te;
 	_eat_space(p);
-	if (p->tb == p->fe) {
+	if (p->tb == p->fe || !*p->tb) {
 		p->t = TOK_EOF;
 		return;
 	}
 
+	/* Should next token be interpreted as value instead of identifier? */
+	if (tok_prev == TOK_EQ || tok_prev == TOK_ARRAY_B ||
+	    tok_prev == TOK_COMMA)
+		values_allowed = 1;
+
 	p->t = TOK_INT;		/* fudge so the fall through for
 				   floats works */
 	switch (*p->te) {
@@ -444,13 +600,24 @@ static void _get_token(struct parser *p)
 	case '"':
 		p->t = TOK_STRING;
 		p->te++;
-		while ((p->te != p->fe) && (*p->te != '"')) {
-			if ((*p->te == '\\') && (p->te + 1 != p->fe))
+		while ((p->te != p->fe) && (*p->te) && (*p->te != '"')) {
+			if ((*p->te == '\\') && (p->te + 1 != p->fe) &&
+			    *(p->te + 1))
 				p->te++;
 			p->te++;
 		}
 
-		if (p->te != p->fe)
+		if ((p->te != p->fe) && (*p->te))
+			p->te++;
+		break;
+
+	case '\'':
+		p->t = TOK_STRING;
+		p->te++;
+		while ((p->te != p->fe) && (*p->te) && (*p->te != '\''))
+			p->te++;
+
+		if ((p->te != p->fe) && (*p->te))
 			p->te++;
 		break;
 
@@ -466,22 +633,27 @@ static void _get_token(struct parser *p)
 	case '7':
 	case '8':
 	case '9':
-		p->te++;
-		while (p->te != p->fe) {
-			if (*p->te == '.') {
-				if (p->t == TOK_FLOAT)
-					break;
-				p->t = TOK_FLOAT;
-			} else if (!isdigit((int) *p->te))
-				break;
+	case '+':
+	case '-':
+		if (values_allowed) {
 			p->te++;
+			while ((p->te != p->fe) && (*p->te)) {
+				if (*p->te == '.') {
+					if (p->t == TOK_FLOAT)
+						break;
+					p->t = TOK_FLOAT;
+				} else if (!isdigit((int) *p->te))
+					break;
+				p->te++;
+			}
+			break;
 		}
-		break;
 
 	default:
 		p->t = TOK_IDENTIFIER;
-		while ((p->te != p->fe) && !isspace(*p->te) &&
-		       (*p->te != '#') && (*p->te != '='))
+		while ((p->te != p->fe) && (*p->te) && !isspace(*p->te) &&
+		       (*p->te != '#') && (*p->te != '=') && (*p->te != '{') &&
+		       (*p->te != '}'))
 			p->te++;
 		break;
 	}
@@ -489,15 +661,15 @@ static void _get_token(struct parser *p)
 
 static void _eat_space(struct parser *p)
 {
-	while (p->tb != p->fe) {
+	while ((p->tb != p->fe) && (*p->tb)) {
 		if (*p->te == '#') {
-			while ((p->te != p->fe) && (*p->te != '\n'))
+			while ((p->te != p->fe) && (*p->te) && (*p->te != '\n'))
 				p->te++;
 			p->line++;
 		}
 
 		else if (isspace(*p->te)) {
-			while ((p->te != p->fe) && isspace(*p->te)) {
+			while ((p->te != p->fe) && (*p->te) && isspace(*p->te)) {
 				if (*p->te == '\n')
 					p->line++;
 				p->te++;
@@ -530,7 +702,7 @@ static struct config_node *_create_node(struct parser *p)
 
 static char *_dup_tok(struct parser *p)
 {
-	int len = p->te - p->tb;
+	size_t len = p->te - p->tb;
 	char *str = pool_alloc(p->mem, len + 1);
 	if (!str) {
 		stack;
@@ -544,8 +716,8 @@ static char *_dup_tok(struct parser *p)
 /*
  * utility functions
  */
-struct config_node *find_config_node(struct config_node *cn,
-				     const char *path, char sep)
+struct config_node *find_config_node(const struct config_node *cn,
+				     const char *path)
 {
 	const char *e;
 
@@ -573,13 +745,13 @@ struct config_node *find_config_node(struct config_node *cn,
 		path = e;
 	}
 
-	return cn;
+	return (struct config_node *) cn;
 }
 
-const char *find_config_str(struct config_node *cn,
-			    const char *path, char sep, const char *fail)
+const char *find_config_str(const struct config_node *cn,
+			    const char *path, const char *fail)
 {
-	struct config_node *n = find_config_node(cn, path, sep);
+	const struct config_node *n = find_config_node(cn, path);
 
 	if (n && n->v->type == CFG_STRING) {
 		if (*n->v->v.str)
@@ -593,10 +765,9 @@ const char *find_config_str(struct config_node *cn,
 	return fail;
 }
 
-int find_config_int(struct config_node *cn, const char *path,
-		    char sep, int fail)
+int find_config_int(const struct config_node *cn, const char *path, int fail)
 {
-	struct config_node *n = find_config_node(cn, path, sep);
+	const struct config_node *n = find_config_node(cn, path);
 
 	if (n && n->v->type == CFG_INT) {
 		log_very_verbose("Setting %s to %d", path, n->v->v.i);
@@ -608,10 +779,10 @@ int find_config_int(struct config_node *cn, const char *path,
 	return fail;
 }
 
-float find_config_float(struct config_node *cn, const char *path,
-			char sep, float fail)
+float find_config_float(const struct config_node *cn, const char *path,
+			float fail)
 {
-	struct config_node *n = find_config_node(cn, path, sep);
+	const struct config_node *n = find_config_node(cn, path);
 
 	if (n && n->v->type == CFG_FLOAT) {
 		log_very_verbose("Setting %s to %f", path, n->v->v.r);
@@ -651,10 +822,9 @@ static int _str_to_bool(const char *str, int fail)
 	return fail;
 }
 
-int find_config_bool(struct config_node *cn, const char *path,
-		     char sep, int fail)
+int find_config_bool(const struct config_node *cn, const char *path, int fail)
 {
-	struct config_node *n = find_config_node(cn, path, sep);
+	const struct config_node *n = find_config_node(cn, path);
 	struct config_value *v;
 
 	if (!n)
@@ -673,12 +843,12 @@ int find_config_bool(struct config_node *cn, const char *path,
 	return fail;
 }
 
-int get_config_uint32(struct config_node *cn, const char *path,
-		      char sep, uint32_t * result)
+int get_config_uint32(const struct config_node *cn, const char *path,
+		      uint32_t *result)
 {
-	struct config_node *n;
+	const struct config_node *n;
 
-	n = find_config_node(cn, path, sep);
+	n = find_config_node(cn, path);
 
 	if (!n || !n->v || n->v->type != CFG_INT)
 		return 0;
@@ -687,12 +857,12 @@ int get_config_uint32(struct config_node *cn, const char *path,
 	return 1;
 }
 
-int get_config_uint64(struct config_node *cn, const char *path,
-		      char sep, uint64_t * result)
+int get_config_uint64(const struct config_node *cn, const char *path,
+		      uint64_t *result)
 {
-	struct config_node *n;
+	const struct config_node *n;
 
-	n = find_config_node(cn, path, sep);
+	n = find_config_node(cn, path);
 
 	if (!n || !n->v || n->v->type != CFG_INT)
 		return 0;
@@ -702,12 +872,12 @@ int get_config_uint64(struct config_node *cn, const char *path,
 	return 1;
 }
 
-int get_config_str(struct config_node *cn, const char *path,
-		   char sep, char **result)
+int get_config_str(const struct config_node *cn, const char *path,
+		   char **result)
 {
-	struct config_node *n;
+	const struct config_node *n;
 
-	n = find_config_node(cn, path, sep);
+	n = find_config_node(cn, path);
 
 	if (!n || !n->v || n->v->type != CFG_STRING)
 		return 0;
@@ -716,3 +886,114 @@ int get_config_str(struct config_node *cn, const char *path,
 	return 1;
 }
 
+/* Insert cn2 after cn1 */
+static void _insert_config_node(struct config_node **cn1,
+				struct config_node *cn2)
+{
+	if (!*cn1) {
+		*cn1 = cn2;
+		cn2->sib = NULL;
+	} else {
+		cn2->sib = (*cn1)->sib;
+		(*cn1)->sib = cn2;
+	}
+}
+
+/*
+ * Merge section cn2 into section cn1 (which has the same name)
+ * overwriting any existing cn1 nodes with matching names.
+ */
+static void _merge_section(struct config_node *cn1, struct config_node *cn2)
+{
+	struct config_node *cn, *nextn, *oldn;
+	struct config_value *cv;
+
+	for (cn = cn2->child; cn; cn = nextn) {
+		nextn = cn->sib;
+
+		/* Skip "tags" */
+		if (!strcmp(cn->key, "tags"))
+			continue;
+
+		/* Subsection? */
+		if (!cn->v)
+			/* Ignore - we don't have any of these yet */
+			continue;
+		/* Not already present? */
+		if (!(oldn = find_config_node(cn1->child, cn->key))) {
+			_insert_config_node(&cn1->child, cn);
+			continue;
+		}
+		/* Merge certain value lists */
+		if ((!strcmp(cn1->key, "activation") &&
+		     !strcmp(cn->key, "volume_list")) ||
+		    (!strcmp(cn1->key, "devices") &&
+		     (!strcmp(cn->key, "filter") || !strcmp(cn->key, "types")))) {
+			cv = cn->v;
+			while (cv->next)
+				cv = cv->next;
+			cv->next = oldn->v;
+		}
+
+		/* Replace values */
+		oldn->v = cn->v;
+	}
+}
+
+static int _match_host_tags(struct list *tags, struct config_node *tn)
+{
+	struct config_value *tv;
+	const char *str;
+
+	for (tv = tn->v; tv; tv = tv->next) {
+		if (tv->type != CFG_STRING)
+			continue;
+		str = tv->v.str;
+		if (*str == '@')
+			str++;
+		if (!*str)
+			continue;
+		if (str_list_match_item(tags, str))
+			return 1;
+	}
+
+	return 0;
+}
+
+/* Destructively merge a new config tree into an existing one */
+int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
+		      struct config_tree *newdata)
+{
+	struct config_node *root = cft->root;
+	struct config_node *cn, *nextn, *oldn, *tn, *cn2;
+
+	for (cn = newdata->root; cn; cn = nextn) {
+		nextn = cn->sib;
+		/* Ignore tags section */
+		if (!strcmp(cn->key, "tags"))
+			continue;
+		/* If there's a tags node, skip if host tags don't match */
+		if ((tn = find_config_node(cn->child, "tags"))) {
+			if (!_match_host_tags(&cmd->tags, tn))
+				continue;
+		}
+		if (!(oldn = find_config_node(root, cn->key))) {
+			_insert_config_node(&cft->root, cn);
+			/* Remove any "tags" nodes */
+			for (cn2 = cn->child; cn2; cn2 = cn2->sib) {
+				if (!strcmp(cn2->key, "tags")) {
+					cn->child = cn2->sib;
+					continue;
+				}
+				if (cn2->sib && !strcmp(cn2->sib->key, "tags")) {
+					cn2->sib = cn2->sib->sib;
+					continue;
+				}
+			}
+			continue;
+		}
+		_merge_section(oldn, cn);
+	}
+
+	return 1;
+}

lib/config/config.h

@@ -1,76 +1,96 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_CONFIG_H
 #define _LVM_CONFIG_H
 
-#include <inttypes.h>
+struct device;
+struct cmd_context;
 
 enum {
-        CFG_STRING,
-        CFG_FLOAT,
-        CFG_INT,
+	CFG_STRING,
+	CFG_FLOAT,
+	CFG_INT,
 	CFG_EMPTY_ARRAY
 };
 
 struct config_value {
-        int type;
-        union {
-                int i;
-                float r;
-                char *str;
-        } v;
-        struct config_value *next; /* for arrays */
+	int type;
+	union {
+		int i;
+		float r;
+		char *str;
+	} v;
+	struct config_value *next;	/* for arrays */
 };
 
 struct config_node {
-        char *key;
-        struct config_node *sib, *child;
-        struct config_value *v;
+	char *key;
+	struct config_node *sib, *child;
+	struct config_value *v;
 };
 
-struct config_file {
-        struct config_node *root;
+struct config_tree {
+	struct config_node *root;
 };
 
-struct config_file *create_config_file(void);
-void destroy_config_file(struct config_file *cf);
+struct config_tree_list {
+	struct list list;
+	struct config_tree *cft;
+};
 
-int read_config(struct config_file *cf, const char *file);
-int write_config(struct config_file *cf, const char *file);
+struct config_tree *create_config_tree(const char *filename);
+void destroy_config_tree(struct config_tree *cft);
 
-struct config_node *find_config_node(struct config_node *cn,
-				     const char *path, char seperator);
+typedef uint32_t (*checksum_fn_t) (uint32_t initial, void *buf, uint32_t size);
 
-const char *find_config_str(struct config_node *cn,
-			    const char *path, char sep, const char *fail);
+int read_config_fd(struct config_tree *cft, struct device *dev,
+		   off_t offset, size_t size, off_t offset2, size_t size2,
+		   checksum_fn_t checksum_fn, uint32_t checksum);
 
-int find_config_int(struct config_node *cn, const char *path,
-		    char sep, int fail);
+int read_config_file(struct config_tree *cft);
+int write_config_file(struct config_tree *cft, const char *file);
+time_t config_file_timestamp(struct config_tree *cft);
+int config_file_changed(struct config_tree *cft);
+int merge_config_tree(struct cmd_context *cmd, struct config_tree *cft,
+		      struct config_tree *newdata);
 
-float find_config_float(struct config_node *cn, const char *path,
-			char sep, float fail);
+struct config_node *find_config_node(const struct config_node *cn,
+				     const char *path);
+
+const char *find_config_str(const struct config_node *cn, const char *path,
+			    const char *fail);
+
+int find_config_int(const struct config_node *cn, const char *path, int fail);
+
+float find_config_float(const struct config_node *cn, const char *path,
+			float fail);
 
 /*
  * Understands (0, ~0), (y, n), (yes, no), (on,
  * off), (true, false).
  */
-int find_config_bool(struct config_node *cn, const char *path,
-		    char sep, int fail);
+int find_config_bool(const struct config_node *cn, const char *path, int fail);
 
+int get_config_uint32(const struct config_node *cn, const char *path,
+		      uint32_t *result);
 
+int get_config_uint64(const struct config_node *cn, const char *path,
+		      uint64_t *result);
 
-int get_config_uint32(struct config_node *cn, const char *path,
-		      char sep, uint32_t *result);
-
-int get_config_uint64(struct config_node *cn, const char *path,
-		      char sep, uint64_t *result);
-
-int get_config_str(struct config_node *cn, const char *path,
-		   char sep, char **result);
+int get_config_str(const struct config_node *cn, const char *path,
+		   char **result);
 
 #endif
-

lib/config/defaults.h

@@ -1,15 +1,21 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_DEFAULTS_H
 #define _LVM_DEFAULTS_H
 
-
-#define DEFAULT_SYS_DIR "/etc/lvm"
-
 #define DEFAULT_ARCHIVE_ENABLED 1
 #define DEFAULT_BACKUP_ENABLED 1
 
@@ -19,22 +25,85 @@
 #define DEFAULT_ARCHIVE_DAYS 30
 #define DEFAULT_ARCHIVE_NUMBER 10
 
+#define DEFAULT_SYS_DIR "/etc/lvm"
 #define DEFAULT_DEV_DIR "/dev"
 #define DEFAULT_PROC_DIR "/proc"
+#define DEFAULT_SYSFS_SCAN 1
+#define DEFAULT_MD_COMPONENT_DETECTION 1
 
 #define DEFAULT_LOCK_DIR "/var/lock/lvm"
+#define DEFAULT_LOCKING_LIB "lvm2_locking.so"
 
 #define DEFAULT_UMASK 0077
 
-#define DEFAULT_FORMAT "lvm1"
-
-#define DEFAULT_MSG_PREFIX "  "
-
-#define DEFAULT_CMD_NAME 0
-
-#ifdef READLINE_SUPPORT
-  #define DEFAULT_MAX_HISTORY 100
+#ifdef LVM1_FALLBACK
+#  define DEFAULT_FALLBACK_TO_LVM1 1
+#else
+#  define DEFAULT_FALLBACK_TO_LVM1 0
 #endif
 
+#ifdef LVM1_SUPPORT
+#  define DEFAULT_FORMAT "lvm1"
+#else
+#  define DEFAULT_FORMAT "lvm2"
+#endif
 
-#endif /* _LVM_DEFAULTS_H */
+#define DEFAULT_STRIPESIZE 64	/* KB */
+#define DEFAULT_PVMETADATASIZE 255
+#define DEFAULT_PVMETADATACOPIES 1
+#define DEFAULT_LABELSECTOR UINT64_C(1)
+
+#define DEFAULT_MSG_PREFIX "  "
+#define DEFAULT_CMD_NAME 0
+#define DEFAULT_OVERWRITE 0
+
+#ifndef DEFAULT_LOG_FACILITY
+#  define DEFAULT_LOG_FACILITY LOG_USER
+#endif
+
+#define DEFAULT_SYSLOG 1
+#define DEFAULT_VERBOSE 0
+#define DEFAULT_LOGLEVEL 0
+#define DEFAULT_INDENT 1
+#define DEFAULT_UNITS "h"
+#define DEFAULT_SUFFIX 1
+#define DEFAULT_HOSTTAGS 0
+
+#ifdef DEVMAPPER_SUPPORT
+#  define DEFAULT_ACTIVATION 1
+#  define DEFAULT_RESERVED_MEMORY 8192
+#  define DEFAULT_RESERVED_STACK 256
+#  define DEFAULT_PROCESS_PRIORITY -18
+#else
+#  define DEFAULT_ACTIVATION 0
+#endif
+
+#define DEFAULT_STRIPE_FILLER "/dev/ioerror"
+#define DEFAULT_MIRROR_REGION_SIZE 512	/* KB */
+#define DEFAULT_INTERVAL 15
+
+#ifdef READLINE_SUPPORT
+#  define DEFAULT_MAX_HISTORY 100
+#endif
+
+#define DEFAULT_REP_ALIGNED 1
+#define DEFAULT_REP_BUFFERED 1
+#define DEFAULT_REP_HEADINGS 1
+#define DEFAULT_REP_SEPARATOR " "
+
+#define DEFAULT_LVS_COLS "lv_name,vg_name,lv_attr,lv_size,origin,snap_percent,move_pv,copy_percent"
+#define DEFAULT_VGS_COLS "vg_name,pv_count,lv_count,snap_count,vg_attr,vg_size,vg_free"
+#define DEFAULT_PVS_COLS "pv_name,vg_name,pv_fmt,pv_attr,pv_size,pv_free"
+#define DEFAULT_SEGS_COLS "lv_name,vg_name,lv_attr,stripes,segtype,seg_size"
+
+#define DEFAULT_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_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_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"
+#define DEFAULT_VGS_SORT "vg_name"
+#define DEFAULT_PVS_SORT "pv_name"
+#define DEFAULT_SEGS_SORT "vg_name,lv_name,seg_start"
+
+#endif				/* _LVM_DEFAULTS_H */

lib/datastruct/bitset.c

@@ -1,21 +1,28 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "bitset.h"
-#include "dbg_malloc.h"
-
-#include <stdlib.h>
 
 /* FIXME: calculate this. */
 #define INT_SHIFT 5
 
-bitset_t bitset_create(struct pool * mem, unsigned num_bits)
+bitset_t bitset_create(struct pool *mem, unsigned num_bits)
 {
-	int n = (num_bits / BITS_PER_INT) + 2;
-	int size = sizeof(int) * n;
+	unsigned n = (num_bits / BITS_PER_INT) + 2;
+	size_t size = sizeof(int) * n;
 	unsigned *bs = pool_zalloc(mem, size);
 
 	if (!bs)

lib/datastruct/bitset.h

@@ -1,28 +1,34 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_BITSET_H
 #define _LVM_BITSET_H
 
-#include "lvm-types.h"
 #include "pool.h"
 
 #include <limits.h>
-#include <string.h>
-
 
 typedef uint32_t *bitset_t;
 
 bitset_t bitset_create(struct pool *mem, unsigned num_bits);
+void bitset_destroy(bitset_t bs);
 
 void bit_union(bitset_t out, bitset_t in1, bitset_t in2);
 int bit_get_first(bitset_t bs);
 int bit_get_next(bitset_t bs, int last_bit);
 
-
 #define BITS_PER_INT (sizeof(int) * CHAR_BIT)
 
 #define bit(bs, i) \

lib/datastruct/btree.c

@@ -1,11 +1,20 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "btree.h"
-#include "log.h"
 
 struct node {
 	uint32_t key;
@@ -46,7 +55,7 @@ static uint32_t _shuffle(uint32_t k)
 #endif
 }
 
-struct node **_lookup(struct node **c, uint32_t key, struct node **p)
+static struct node **_lookup(struct node **c, uint32_t key, struct node **p)
 {
 	*p = NULL;
 	while (*c) {

lib/datastruct/btree.h

@@ -1,13 +1,21 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_BTREE_H
 #define _LVM_BTREE_H
 
-#include "lvm-types.h"
 #include "pool.h"
 
 struct btree;

lib/datastruct/hash.c

@@ -1,12 +1,20 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "dbg_malloc.h"
+#include "lib.h"
 #include "hash.h"
-#include "log.h"
 
 struct hash_node {
 	struct hash_node *next;
@@ -26,26 +34,26 @@ static unsigned char _nums[] = {
 	87, 197, 177, 107, 234, 169, 56, 68, 30, 7, 173, 73, 188, 40, 36, 65,
 	49, 213, 104, 190, 57, 211, 148, 223, 48, 115, 15, 2, 67, 186, 210, 28,
 	12, 181, 103, 70, 22, 58, 75, 78, 183, 167, 238, 157, 124, 147, 172,
-	    144,
+	144,
 	176, 161, 141, 86, 60, 66, 128, 83, 156, 241, 79, 46, 168, 198, 41, 254,
 	178, 85, 253, 237, 250, 154, 133, 88, 35, 206, 95, 116, 252, 192, 54,
-	    221,
+	221,
 	102, 218, 255, 240, 82, 106, 158, 201, 61, 3, 89, 9, 42, 155, 159, 93,
 	166, 80, 50, 34, 175, 195, 100, 99, 26, 150, 16, 145, 4, 33, 8, 189,
 	121, 64, 77, 72, 208, 245, 130, 122, 143, 55, 105, 134, 29, 164, 185,
-	    194,
+	194,
 	193, 239, 101, 242, 5, 171, 126, 11, 74, 59, 137, 228, 108, 191, 232,
-	    139,
+	139,
 	6, 24, 81, 20, 127, 17, 91, 92, 251, 151, 225, 207, 21, 98, 113, 112,
 	84, 226, 18, 214, 199, 187, 13, 32, 94, 220, 224, 212, 247, 204, 196,
-	    43,
+	43,
 	249, 236, 45, 244, 111, 182, 153, 136, 129, 90, 217, 202, 19, 165, 231,
-	    71,
+	71,
 	230, 142, 96, 227, 62, 179, 246, 114, 162, 53, 160, 215, 205, 180, 47,
-	    109,
+	109,
 	44, 38, 31, 149, 135, 0, 216, 52, 63, 23, 37, 69, 39, 117, 146, 184,
 	163, 200, 222, 235, 248, 243, 219, 10, 152, 131, 123, 229, 203, 76, 120,
-	    209
+	209
 };
 
 static struct hash_node *_create_node(const char *str)
@@ -62,7 +70,7 @@ static struct hash_node *_create_node(const char *str)
 
 static unsigned _hash(const char *str)
 {
-	unsigned long int h = 0, g;
+	unsigned long h = 0, g;
 	while (*str) {
 		h <<= 4;
 		h += _nums[(int) *str++];
@@ -126,7 +134,7 @@ void hash_destroy(struct hash_table *t)
 	dbg_free(t);
 }
 
-static inline struct hash_node **_find(struct hash_table *t, const char *key)
+static struct hash_node **_find(struct hash_table *t, const char *key)
 {
 	unsigned h = _hash(key) & (t->num_slots - 1);
 	struct hash_node **c;
@@ -209,7 +217,7 @@ void *hash_get_data(struct hash_table *t, struct hash_node *n)
 	return n->data;
 }
 
-static struct hash_node *_next_slot(struct hash_table *t, unsigned int s)
+static struct hash_node *_next_slot(struct hash_table *t, unsigned s)
 {
 	struct hash_node *c = NULL;
 	int i;
@@ -227,6 +235,6 @@ struct hash_node *hash_get_first(struct hash_table *t)
 
 struct hash_node *hash_get_next(struct hash_table *t, struct hash_node *n)
 {
-	unsigned int h = _hash(n->key) & (t->num_slots - 1);
+	unsigned h = _hash(n->key) & (t->num_slots - 1);
 	return n->next ? n->next : _next_slot(t, h + 1);
 }

lib/datastruct/hash.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_HASH_H
@@ -10,13 +19,14 @@
 struct hash_table;
 struct hash_node;
 
-typedef void (*iterate_fn)(void *data);
+typedef void (*iterate_fn) (void *data);
 
 struct hash_table *hash_create(unsigned size_hint);
 void hash_destroy(struct hash_table *t);
 void hash_wipe(struct hash_table *t);
 
 void *hash_lookup(struct hash_table *t, const char *key);
+void *hash_lookup_fixed(struct hash_table *t, const char *key, uint32_t len);
 int hash_insert(struct hash_table *t, const char *key, void *data);
 void hash_remove(struct hash_table *t, const char *key);
 
@@ -33,4 +43,3 @@ struct hash_node *hash_get_next(struct hash_table *t, struct hash_node *n);
 	     v = hash_get_next(h, v))
 
 #endif
-

lib/datastruct/list.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_LIST_H
@@ -13,11 +22,15 @@ struct list {
 	struct list *n, *p;
 };
 
-static inline void list_init(struct list *head) {
+#define LIST_INIT(name)	struct list name = { &(name), &(name) }
+
+static inline void list_init(struct list *head)
+{
 	head->n = head->p = head;
 }
 
-static inline void list_add(struct list *head, struct list *elem) {
+static inline void list_add(struct list *head, struct list *elem)
+{
 	assert(head->n);
 
 	elem->n = head;
@@ -27,7 +40,8 @@ static inline void list_add(struct list *head, struct list *elem) {
 	head->p = elem;
 }
 
-static inline void list_add_h(struct list *head, struct list *elem) {
+static inline void list_add_h(struct list *head, struct list *elem)
+{
 	assert(head->n);
 
 	elem->n = head->n;
@@ -37,36 +51,62 @@ static inline void list_add_h(struct list *head, struct list *elem) {
 	head->n = elem;
 }
 
-static inline void list_del(struct list *elem) {
+static inline void list_del(struct list *elem)
+{
 	elem->n->p = elem->p;
 	elem->p->n = elem->n;
 }
 
-static inline int list_empty(struct list *head) {
+static inline int list_empty(struct list *head)
+{
 	return head->n == head;
 }
 
-#define list_iterate(v, head) \
-	for (v = (head)->n; v != head; v = v->n)
+static inline int list_end(struct list *head, struct list *elem)
+{
+	return elem->n == head;
+}
 
-#define list_iterate_safe(v, t, head) \
-	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)
-
-static inline int list_size(struct list *head) {
-	int s = 0;
-	struct list *v;
-
-	list_iterate(v, head)
-		s++;
-
-	return s;
+static inline struct list *list_next(struct list *head, struct list *elem)
+{
+	return (list_end(head, elem) ? NULL : elem->n);
 }
 
 #define list_item(v, t) \
     ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->list))
 
-/* Given a known element in a known structure, locate the struct list */
-#define list_head(v, t, e) \
-    (((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->e))->list)
+#define list_struct_base(v, t, h) \
+    ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->h))
+
+/* Given a known element in a known structure, locate another */
+#define struct_field(v, t, e, f) \
+    (((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->e))->f)
+
+/* Given a known element in a known structure, locate the list head */
+#define list_head(v, t, e) struct_field(v, t, e, list)
+
+#define list_iterate(v, head) \
+	for (v = (head)->n; v != head; v = v->n)
+
+#define list_uniterate(v, head, start) \
+	for (v = (start)->p; v != head; v = v->p)
+
+#define list_iterate_safe(v, t, head) \
+	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)
+
+#define list_iterate_items(v, head) \
+	for (v = list_item((head)->n, typeof(*v)); &v->list != (head); \
+	     v = list_item(v->list.n, typeof(*v)))
+
+static inline unsigned int list_size(const struct list *head)
+{
+	unsigned int s = 0;
+	const struct list *v;
+
+	list_iterate(v, head)
+	    s++;
+
+	return s;
+}
 
 #endif

lib/datastruct/lvm-types.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_TYPES_H
@@ -12,9 +21,12 @@
 #include <sys/types.h>
 #include <inttypes.h>
 
+/* Define some portable printing types */
+#define PRIsize_t "Zu"
+
 struct str_list {
 	struct list list;
-	char *str;
+	const char *str;
 };
 
 #endif

lib/datastruct/str_list.c

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "str_list.h"
+
+struct list *str_list_create(struct pool *mem)
+{
+	struct list *sl;
+
+	if (!(sl = pool_alloc(mem, sizeof(struct list)))) {
+		stack;
+		return NULL;
+	}
+
+	list_init(sl);
+
+	return sl;
+}
+
+int str_list_add(struct pool *mem, struct list *sll, const char *str)
+{
+	struct str_list *sln;
+
+	if (!str) {
+		stack;
+		return 0;
+	}
+
+	/* Already in list? */
+	if (str_list_match_item(sll, str))
+		return 1;
+
+	if (!(sln = pool_alloc(mem, sizeof(*sln)))) {
+		stack;
+		return 0;
+	}
+
+	sln->str = str;
+	list_add(sll, &sln->list);
+
+	return 1;
+}
+
+int str_list_del(struct list *sll, const char *str)
+{
+	struct list *slh, *slht;
+
+	list_iterate_safe(slh, slht, sll) {
+		if (!strcmp(str, list_item(slh, struct str_list)->str))
+			 list_del(slh);
+	}
+
+	return 1;
+}
+
+int str_list_dup(struct pool *mem, struct list *sllnew, struct list *sllold)
+{
+	struct str_list *sl;
+
+	list_init(sllnew);
+
+	list_iterate_items(sl, sllold) {
+		if (!str_list_add(mem, sllnew, strdup(sl->str))) {
+			stack;
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * Is item on list?
+ */
+int str_list_match_item(struct list *sll, const char *str)
+{
+	struct str_list *sl;
+
+	list_iterate_items(sl, sll)
+	    if (!strcmp(str, sl->str))
+		return 1;
+
+	return 0;
+}
+
+/*
+ * Is at least one item on both lists?
+ */
+int str_list_match_list(struct list *sll, struct list *sll2)
+{
+	struct str_list *sl;
+
+	list_iterate_items(sl, sll)
+	    if (str_list_match_item(sll2, sl->str))
+		return 1;
+
+	return 0;
+}
+
+/*
+ * Do both lists contain the same set of items?
+ */
+int str_list_lists_equal(struct list *sll, struct list *sll2)
+{
+	struct str_list *sl;
+
+	if (list_size(sll) != list_size(sll2))
+		return 0;
+
+	list_iterate_items(sl, sll)
+	    if (!str_list_match_item(sll2, sl->str))
+		return 0;
+
+	return 1;
+}

lib/datastruct/str_list.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_STR_LIST_H
+#define _LVM_STR_LIST_H
+
+#include "pool.h"
+
+struct list *str_list_create(struct pool *mem);
+int str_list_add(struct pool *mem, struct list *sll, const char *str);
+int str_list_del(struct list *sll, const char *str);
+int str_list_match_item(struct list *sll, const char *str);
+int str_list_match_list(struct list *sll, struct list *sll2);
+int str_list_lists_equal(struct list *sll, struct list *sll2);
+int str_list_dup(struct pool *mem, struct list *sllnew, struct list *sllold);
+
+#endif

lib/device/dev-cache.c

@@ -1,30 +1,30 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "dev-cache.h"
-#include "log.h"
 #include "pool.h"
 #include "hash.h"
 #include "list.h"
 #include "lvm-types.h"
 #include "btree.h"
-#include "dbg_malloc.h"
+#include "filter.h"
 
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <unistd.h>
 #include <sys/param.h>
 #include <dirent.h>
-#include <linux/kdev_t.h>
-
-/*
- * FIXME: really need to seperate names from the devices since
- * multiple names can point to the same device.
- */
 
 struct dev_iter {
 	struct btree_iter *current;
@@ -51,36 +51,163 @@ static struct {
 
 static int _insert(const char *path, int rec);
 
-static struct device *_create_dev(dev_t d)
+struct device *dev_create_file(const char *filename, struct device *dev,
+			       struct str_list *alias)
+{
+	int allocate = !dev;
+
+	if (allocate && !(dev = dbg_malloc(sizeof(*dev)))) {
+		log_error("struct device allocation failed");
+		return NULL;
+	}
+	if (allocate && !(alias = dbg_malloc(sizeof(*alias)))) {
+		log_error("struct str_list allocation failed");
+		dbg_free(dev);
+		return NULL;
+	}
+	if (!(alias->str = dbg_strdup(filename))) {
+		log_error("filename strdup failed");
+		if (allocate) {
+			dbg_free(dev);
+			dbg_free(alias);
+		}
+		return NULL;
+	}
+	dev->flags = DEV_REGULAR;
+	if (allocate)
+		dev->flags |= DEV_ALLOCED;
+	list_init(&dev->aliases);
+	list_add(&dev->aliases, &alias->list);
+	dev->end = UINT64_C(0);
+	dev->dev = 0;
+	dev->fd = -1;
+	dev->open_count = 0;
+	memset(dev->pvid, 0, sizeof(dev->pvid));
+	list_init(&dev->open_list);
+
+	return dev;
+}
+
+static struct device *_dev_create(dev_t d)
 {
 	struct device *dev;
 
 	if (!(dev = _alloc(sizeof(*dev)))) {
-		stack;
+		log_error("struct device allocation failed");
 		return NULL;
 	}
-
+	dev->flags = 0;
 	list_init(&dev->aliases);
 	dev->dev = d;
 	dev->fd = -1;
+	dev->open_count = 0;
+	dev->end = UINT64_C(0);
+	memset(dev->pvid, 0, sizeof(dev->pvid));
+	list_init(&dev->open_list);
+
 	return dev;
 }
 
+/* Return 1 if we prefer path1 else return 0 */
+static int _compare_paths(const char *path0, const char *path1)
+{
+	int slash0 = 0, slash1 = 0;
+	const char *p;
+	char p0[PATH_MAX], p1[PATH_MAX];
+	char *s0, *s1;
+	struct stat stat0, stat1;
+
+	/* Return the path with fewer slashes */
+	for (p = path0; p++; p = (const char *) strchr(p, '/'))
+		slash0++;
+
+	for (p = path1; p++; p = (const char *) strchr(p, '/'))
+		slash1++;
+
+	if (slash0 < slash1)
+		return 0;
+	if (slash1 < slash0)
+		return 1;
+
+	strncpy(p0, path0, PATH_MAX);
+	strncpy(p1, path1, PATH_MAX);
+	s0 = &p0[0] + 1;
+	s1 = &p1[0] + 1;
+
+	/* We prefer symlinks - they exist for a reason!
+	 * So we prefer a shorter path before the first symlink in the name.
+	 * FIXME Configuration option to invert this? */
+	while (s0) {
+		s0 = strchr(s0, '/');
+		s1 = strchr(s1, '/');
+		if (s0) {
+			*s0 = '\0';
+			*s1 = '\0';
+		}
+		if (lstat(p0, &stat0)) {
+			log_sys_error("lstat", p0);
+			return 1;
+		}
+		if (lstat(p1, &stat1)) {
+			log_sys_error("lstat", p1);
+			return 0;
+		}
+		if (S_ISLNK(stat0.st_mode) && !S_ISLNK(stat1.st_mode))
+			return 0;
+		if (!S_ISLNK(stat0.st_mode) && S_ISLNK(stat1.st_mode))
+			return 1;
+		if (s0) {
+			*s0++ = '/';
+			*s1++ = '/';
+		}
+	}
+
+	/* ASCII comparison */
+	if (strcmp(path0, path1) < 0)
+		return 0;
+	else
+		return 1;
+}
+
 static int _add_alias(struct device *dev, const char *path)
 {
 	struct str_list *sl = _alloc(sizeof(*sl));
+	struct list *ah;
+	const char *oldpath;
+	int prefer_old = 1;
 
 	if (!sl) {
 		stack;
 		return 0;
 	}
 
+	/* Is name already there? */
+	list_iterate(ah, &dev->aliases) {
+		if (!strcmp(list_item(ah, struct str_list)->str, path)) {
+			stack;
+			return 1;
+		}
+	}
+
 	if (!(sl->str = pool_strdup(_cache.mem, path))) {
 		stack;
 		return 0;
 	}
 
-	list_add(&dev->aliases, &sl->list);
+	if (!list_empty(&dev->aliases)) {
+		oldpath = list_item(dev->aliases.n, struct str_list)->str;
+		prefer_old = _compare_paths(path, oldpath);
+		log_debug("%s: Aliased to %s in device cache%s",
+			  path, oldpath, prefer_old ? "" : " (preferred name)");
+
+	} else
+		log_debug("%s: Added to device cache", path);
+
+	if (prefer_old)
+		list_add(&dev->aliases, &sl->list);
+	else
+		list_add_h(&dev->aliases, &sl->list);
+
 	return 1;
 }
 
@@ -93,14 +220,15 @@ static int _insert_dev(const char *path, dev_t d)
 	struct device *dev;
 
 	/* is this device already registered ? */
-	if (!(dev = (struct device *) btree_lookup(_cache.devices, d))) {
+	if (!(dev = (struct device *) btree_lookup(_cache.devices,
+						   (uint32_t) d))) {
 		/* create new device */
-		if (!(dev = _create_dev(d))) {
+		if (!(dev = _dev_create(d))) {
 			stack;
 			return 0;
 		}
 
-		if (!(btree_insert(_cache.devices, d, dev))) {
+		if (!(btree_insert(_cache.devices, (uint32_t) d, dev))) {
 			log_err("Couldn't insert device into binary tree.");
 			_free(dev);
 			return 0;
@@ -122,7 +250,7 @@ static int _insert_dev(const char *path, dev_t d)
 
 static char *_join(const char *dir, const char *name)
 {
-	int len = strlen(dir) + strlen(name) + 2;
+	size_t len = strlen(dir) + strlen(name) + 2;
 	char *r = dbg_malloc(len);
 	if (r)
 		snprintf(r, len, "%s/%s", dir, name);
@@ -194,6 +322,17 @@ static int _insert(const char *path, int rec)
 	}
 
 	if (S_ISDIR(info.st_mode)) {	/* add a directory */
+		/* check it's not a symbolic link */
+		if (lstat(path, &info) < 0) {
+			log_sys_very_verbose("lstat", path);
+			return 0;
+		}
+
+		if (S_ISLNK(info.st_mode)) {
+			log_debug("%s: Symbolic link to directory", path);
+			return 0;
+		}
+
 		if (rec)
 			r = _insert_dir(path);
 
@@ -229,6 +368,21 @@ static void _full_scan(void)
 	_cache.has_scanned = 1;
 }
 
+int dev_cache_has_scanned(void)
+{
+	return _cache.has_scanned;
+}
+
+void dev_cache_scan(int do_scan)
+{
+	if (!do_scan)
+		_cache.has_scanned = 1;
+	else {
+		_cache.has_scanned = 0;
+		_full_scan();
+	}
+}
+
 int dev_cache_init(void)
 {
 	_cache.names = NULL;
@@ -259,7 +413,7 @@ int dev_cache_init(void)
 	return 0;
 }
 
-void _check_closed(struct device *dev)
+static void _check_closed(struct device *dev)
 {
 	if (dev->fd >= 0)
 		log_err("Device '%s' has been left open.", dev_name(dev));
@@ -272,11 +426,22 @@ static inline void _check_for_open_devices(void)
 
 void dev_cache_exit(void)
 {
-	_check_for_open_devices();
-
-	pool_destroy(_cache.mem);
 	if (_cache.names)
+		_check_for_open_devices();
+
+	if (_cache.mem) {
+		pool_destroy(_cache.mem);
+		_cache.mem = NULL;
+	}
+
+	if (_cache.names) {
 		hash_destroy(_cache.names);
+		_cache.names = NULL;
+	}
+
+	_cache.devices = NULL;
+	_cache.has_scanned = 0;
+	list_init(&_cache.dirs);
 }
 
 int dev_cache_add_dir(const char *path)
@@ -295,8 +460,10 @@ int dev_cache_add_dir(const char *path)
 		return 1;
 	}
 
-	if (!(dl = _alloc(sizeof(*dl) + strlen(path) + 1)))
+	if (!(dl = _alloc(sizeof(*dl) + strlen(path) + 1))) {
+		log_error("dir_list allocation failed");
 		return 0;
+	}
 
 	strcpy(dl->dir, path);
 	list_add(&_cache.dirs, &dl->list);
@@ -305,20 +472,31 @@ int dev_cache_add_dir(const char *path)
 
 /* Check cached device name is still valid before returning it */
 /* This should be a rare occurrence */
+/* set quiet if the cache is expected to be out-of-date */
 /* FIXME Make rest of code pass/cache struct device instead of dev_name */
-const char *dev_name_confirmed(struct device *dev)
+const char *dev_name_confirmed(struct device *dev, int quiet)
 {
 	struct stat buf;
-	char *name;
+	const char *name;
 	int r;
 
 	while ((r = stat(name = list_item(dev->aliases.n,
 					  struct str_list)->str, &buf)) ||
 	       (buf.st_rdev != dev->dev)) {
-		if (r < 0)
-			log_sys_error("stat", name);
-		log_error("Path %s no longer valid for device(%d,%d)",
-			  name, (int) MAJOR(dev->dev), (int) MINOR(dev->dev));
+		if (r < 0) {
+			if (quiet)
+				log_sys_debug("stat", name);
+			else
+				log_sys_error("stat", name);
+		}
+		if (quiet)
+			log_debug("Path %s no longer valid for device(%d,%d)",
+				  name, (int) MAJOR(dev->dev),
+				  (int) MINOR(dev->dev));
+		else
+			log_error("Path %s no longer valid for device(%d,%d)",
+				  name, (int) MAJOR(dev->dev),
+				  (int) MINOR(dev->dev));
 
 		/* Remove the incorrect hash entry */
 		hash_remove(_cache.names, name);
@@ -364,8 +542,10 @@ struct dev_iter *dev_iter_create(struct dev_filter *f)
 {
 	struct dev_iter *di = dbg_malloc(sizeof(*di));
 
-	if (!di)
+	if (!di) {
+		log_error("dev_iter allocation failed");
 		return NULL;
+	}
 
 	_full_scan();
 	di->current = btree_first(_cache.devices);

lib/device/dev-cache.h

@@ -1,13 +1,21 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_DEV_CACHE_H
 #define _LVM_DEV_CACHE_H
 
-#include <sys/types.h>
 #include "lvm-types.h"
 #include "device.h"
 
@@ -15,22 +23,24 @@
  * predicate for devices.
  */
 struct dev_filter {
-	int (*passes_filter)(struct dev_filter *f, struct device *dev);
-	void (*destroy)(struct dev_filter *f);
+	int (*passes_filter) (struct dev_filter * f, struct device * dev);
+	void (*destroy) (struct dev_filter * f);
 	void *private;
 };
 
-
 /*
  * The global device cache.
  */
 int dev_cache_init(void);
 void dev_cache_exit(void);
 
+/* Trigger(1) or avoid(0) a scan */
+void dev_cache_scan(int do_scan);
+int dev_cache_has_scanned(void);
+
 int dev_cache_add_dir(const char *path);
 struct device *dev_cache_get(const char *name, struct dev_filter *f);
 
-
 /*
  * Object for iterating through the cache.
  */

lib/device/dev-io.c

@@ -1,24 +1,220 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "device.h"
+#include "lib.h"
 #include "lvm-types.h"
-#include "log.h"
+#include "device.h"
+#include "metadata.h"
+#include "lvmcache.h"
+#include "memlock.h"
+#include "locking.h"
 
-#include <sys/types.h>
+#include <limits.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
-#include <linux/fs.h>		// UGH!!! for BLKSSZGET
 
-int dev_get_size(struct device *dev, uint64_t * size)
+#ifdef linux
+#  define u64 uint64_t		/* Missing without __KERNEL__ */
+#  undef WNOHANG		/* Avoid redefinition */
+#  undef WUNTRACED		/* Avoid redefinition */
+#  include <linux/fs.h>		/* For block ioctl definitions */
+#  define BLKSIZE_SHIFT SECTOR_SHIFT
+#  ifndef BLKGETSIZE64		/* fs.h out-of-date */
+#    define BLKGETSIZE64 _IOR(0x12, 114, size_t)
+#  endif /* BLKGETSIZE64 */
+#else
+#  include <sys/disk.h>
+#  define BLKBSZGET DKIOCGETBLOCKSIZE
+#  define BLKSSZGET DKIOCGETBLOCKSIZE
+#  define BLKGETSIZE64 DKIOCGETBLOCKCOUNT
+#  define BLKFLSBUF DKIOCSYNCHRONIZECACHE
+#  define BLKSIZE_SHIFT 0
+#endif
+
+#ifdef O_DIRECT_SUPPORT
+#  ifndef O_DIRECT
+#    error O_DIRECT support configured but O_DIRECT definition not found in headers
+#  endif
+#endif
+
+static LIST_INIT(_open_devices);
+
+/*-----------------------------------------------------------------
+ * The standard io loop that keeps submitting an io until it's
+ * all gone.
+ *---------------------------------------------------------------*/
+static int _io(struct device_area *where, void *buffer, int should_write)
+{
+	int fd = dev_fd(where->dev);
+	ssize_t n = 0;
+	size_t total = 0;
+
+	if (fd < 0) {
+		log_error("Attempt to read an unopened device (%s).",
+			  dev_name(where->dev));
+		return 0;
+	}
+
+	/*
+	 * Skip all writes in test mode.
+	 */
+	if (should_write && test_mode())
+		return 1;
+
+	if (where->size > SSIZE_MAX) {
+		log_error("Read size too large: %" PRIu64, where->size);
+		return 0;
+	}
+
+	if (lseek(fd, (off_t) where->start, SEEK_SET) < 0) {
+		log_sys_error("lseek", dev_name(where->dev));
+		return 0;
+	}
+
+	while (total < (size_t) where->size) {
+		do
+			n = should_write ?
+			    write(fd, buffer, (size_t) where->size - total) :
+			    read(fd, buffer, (size_t) where->size - total);
+		while ((n < 0) && ((errno == EINTR) || (errno == EAGAIN)));
+
+		if (n <= 0)
+			break;
+
+		total += n;
+		buffer += n;
+	}
+
+	return (total == (size_t) where->size);
+}
+
+/*-----------------------------------------------------------------
+ * LVM2 uses O_DIRECT when performing metadata io, which requires
+ * block size aligned accesses.  If any io is not aligned we have
+ * to perform the io via a bounce buffer, obviously this is quite
+ * inefficient.
+ *---------------------------------------------------------------*/
+
+/*
+ * Get the sector size from an _open_ device.
+ */
+static int _get_block_size(struct device *dev, unsigned int *size)
+{
+	int s;
+
+	if (ioctl(dev_fd(dev), BLKBSZGET, &s) < 0) {
+		log_sys_error("ioctl BLKBSZGET", dev_name(dev));
+		return 0;
+	}
+
+	*size = (unsigned int) s;
+	return 1;
+}
+
+/*
+ * Widens a region to be an aligned region.
+ */
+static void _widen_region(unsigned int block_size, struct device_area *region,
+			  struct device_area *result)
+{
+	uint64_t mask = block_size - 1, delta;
+	memcpy(result, region, sizeof(*result));
+
+	/* adjust the start */
+	delta = result->start & mask;
+	if (delta) {
+		result->start -= delta;
+		result->size += delta;
+	}
+
+	/* adjust the end */
+	delta = (result->start + result->size) & mask;
+	if (delta)
+		result->size += block_size - delta;
+}
+
+static int _aligned_io(struct device_area *where, void *buffer,
+		       int should_write)
+{
+	void *bounce;
+	unsigned int block_size = 0;
+	uintptr_t mask;
+	struct device_area widened;
+
+	if (!(where->dev->flags & DEV_REGULAR) &&
+	    !_get_block_size(where->dev, &block_size)) {
+		stack;
+		return 0;
+	}
+
+	if (!block_size)
+		block_size = getpagesize();
+
+	_widen_region(block_size, where, &widened);
+
+	/* Do we need to use a bounce buffer? */
+	mask = block_size - 1;
+	if (!memcmp(where, &widened, sizeof(widened)) &&
+	    !((uintptr_t) buffer & mask))
+		return _io(where, buffer, should_write);
+
+	/* Allocate a bounce buffer with an extra block */
+	if (!(bounce = alloca((size_t) widened.size + block_size))) {
+		log_error("Bounce buffer alloca failed");
+		return 0;
+	}
+
+	/*
+	 * Realign start of bounce buffer (using the extra sector)
+	 */
+	if (((uintptr_t) bounce) & mask)
+		bounce = (void *) ((((uintptr_t) bounce) + mask) & ~mask);
+
+	/* channel the io through the bounce buffer */
+	if (!_io(&widened, bounce, 0)) {
+		if (!should_write) {
+			stack;
+			return 0;
+		}
+		/* FIXME pre-extend the file */
+		memset(bounce, '\n', widened.size);
+	}
+
+	if (should_write) {
+		memcpy(bounce + (where->start - widened.start), buffer,
+		       (size_t) where->size);
+
+		/* ... then we write */
+		return _io(&widened, bounce, 1);
+	}
+
+	memcpy(buffer, bounce + (where->start - widened.start),
+	       (size_t) where->size);
+
+	return 1;
+}
+
+/*-----------------------------------------------------------------
+ * Public functions
+ *---------------------------------------------------------------*/
+
+int dev_get_size(struct device *dev, uint64_t *size)
 {
 	int fd;
-	long s;
 	const char *name = dev_name(dev);
 
 	log_very_verbose("Getting size of %s", name);
@@ -27,19 +223,18 @@ int dev_get_size(struct device *dev, uint64_t * size)
 		return 0;
 	}
 
-	/* FIXME: add 64 bit ioctl */
-	if (ioctl(fd, BLKGETSIZE, &s) < 0) {
-		log_sys_error("ioctl BLKGETSIZE", name);
+	if (ioctl(fd, BLKGETSIZE64, size) < 0) {
+		log_sys_error("ioctl BLKGETSIZE64", name);
 		close(fd);
 		return 0;
 	}
 
+	*size >>= BLKSIZE_SHIFT;	/* Convert to sectors */
 	close(fd);
-	*size = (uint64_t) s;
 	return 1;
 }
 
-int dev_get_sectsize(struct device *dev, uint32_t * size)
+int dev_get_sectsize(struct device *dev, uint32_t *size)
 {
 	int fd;
 	int s;
@@ -62,49 +257,116 @@ int dev_get_sectsize(struct device *dev, uint32_t * size)
 	return 1;
 }
 
-
-static void _flush(int fd)
+void dev_flush(struct device *dev)
 {
-	ioctl(fd, BLKFLSBUF, 0);
+	if (!(dev->flags & DEV_REGULAR) && ioctl(dev->fd, BLKFLSBUF, 0) >= 0)
+		return;
+
+	if (fsync(dev->fd) >= 0)
+		return;
+
+	sync();
 }
 
-int dev_open(struct device *dev, int flags)
+int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 {
 	struct stat buf;
-	const char *name = dev_name_confirmed(dev);
+	const char *name;
 
-	if (!name) {
+	if (dev->fd >= 0) {
+		dev->open_count++;
+		return 1;
+	}
+
+	if (memlock())
+		log_error("WARNING: dev_open(%s) called while suspended",
+			  dev_name(dev));
+
+	if (dev->flags & DEV_REGULAR)
+		name = dev_name(dev);
+	else if (!(name = dev_name_confirmed(dev, quiet))) {
 		stack;
 		return 0;
 	}
 
-	if (dev->fd >= 0) {
-		log_error("Device '%s' has already been opened", name);
-		return 0;
-	}
-
-	if ((stat(name, &buf) < 0) || (buf.st_rdev != dev->dev)) {
+	if (!(dev->flags & DEV_REGULAR) &&
+	    ((stat(name, &buf) < 0) || (buf.st_rdev != dev->dev))) {
 		log_error("%s: stat failed: Has device name changed?", name);
 		return 0;
 	}
 
-	if ((dev->fd = open(name, flags)) < 0) {
+#ifdef O_DIRECT_SUPPORT
+	if (direct)
+		flags |= O_DIRECT;
+#endif
+
+	if ((dev->fd = open(name, flags, 0777)) < 0) {
 		log_sys_error("open", name);
 		return 0;
 	}
 
-	if ((fstat(dev->fd, &buf) < 0) || (buf.st_rdev != dev->dev)) {
+	dev->open_count = 1;
+	dev->flags &= ~DEV_ACCESSED_W;
+
+	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;
 		return 0;
 	}
-	_flush(dev->fd);
-	dev->flags = 0;
+
+#ifndef O_DIRECT_SUPPORT
+	if (!(dev->flags & DEV_REGULAR))
+		dev_flush(dev);
+#endif
+
+	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));
 
 	return 1;
 }
 
-int dev_close(struct device *dev)
+int dev_open_quiet(struct device *dev)
+{
+	int flags;
+
+	flags = vg_write_lock_held() ? O_RDWR : O_RDONLY;
+
+	return dev_open_flags(dev, flags, 1, 1);
+}
+
+int dev_open(struct device *dev)
+{
+	int flags;
+
+	flags = vg_write_lock_held() ? O_RDWR : O_RDONLY;
+
+	return dev_open_flags(dev, flags, 1, 0);
+}
+
+static void _close(struct device *dev)
+{
+	if (close(dev->fd))
+		log_sys_error("close", dev_name(dev));
+	dev->fd = -1;
+	list_del(&dev->open_list);
+
+	log_debug("Closed %s", dev_name(dev));
+
+	if (dev->flags & DEV_ALLOCED) {
+		dbg_free((void *) list_item(dev->aliases.n, struct str_list)->
+			 str);
+		dbg_free(dev->aliases.n);
+		dbg_free(dev);
+	}
+}
+
+static int _dev_close(struct device *dev, int immediate)
 {
 	if (dev->fd < 0) {
 		log_error("Attempt to close device '%s' "
@@ -112,139 +374,127 @@ int dev_close(struct device *dev)
 		return 0;
 	}
 
+#ifndef O_DIRECT_SUPPORT
 	if (dev->flags & DEV_ACCESSED_W)
-		_flush(dev->fd);
+		dev_flush(dev);
+#endif
 
-	if (close(dev->fd))
-		log_sys_error("close", dev_name(dev));
-
-	dev->fd = -1;
+	/* FIXME lookup device in cache to get vgname and see if it's locked? */
+	if (--dev->open_count < 1 && (immediate || !vgs_locked()))
+		_close(dev);
 
 	return 1;
 }
 
-/*
- *  FIXME: factor common code out.
+int dev_close(struct device *dev)
+{
+	return _dev_close(dev, 0);
+}
+
+int dev_close_immediate(struct device *dev)
+{
+	return _dev_close(dev, 1);
+}
+
+void dev_close_all(void)
+{
+	struct list *doh, *doht;
+	struct device *dev;
+
+	list_iterate_safe(doh, doht, &_open_devices) {
+		dev = list_struct_base(doh, struct device, open_list);
+		if (dev->open_count < 1)
+			_close(dev);
+	}
+}
+
+int dev_read(struct device *dev, uint64_t offset, size_t len, void *buffer)
+{
+	struct device_area where;
+
+	if (!dev->open_count)
+		return 0;
+
+	where.dev = dev;
+	where.start = offset;
+	where.size = len;
+
+	return _aligned_io(&where, buffer, 0);
+}
+
+/* FIXME If O_DIRECT can't extend file, dev_extend first; dev_truncate after.
+ *       But fails if concurrent processes writing
  */
-int _read(int fd, void *buf, size_t count)
+
+/* FIXME pre-extend the file */
+int dev_append(struct device *dev, size_t len, void *buffer)
 {
-	size_t n = 0;
-	int tot = 0;
+	int r;
 
-	while (tot < count) {
-		do
-			n = read(fd, buf, count - tot);
-		while ((n < 0) && ((errno == EINTR) || (errno == EAGAIN)));
+	if (!dev->open_count)
+		return 0;
 
-		if (n <= 0)
-			return tot ? tot : n;
+	r = dev_write(dev, dev->end, len, buffer);
+	dev->end += (uint64_t) len;
 
-		tot += n;
-		buf += n;
-	}
-
-	return tot;
+#ifndef O_DIRECT_SUPPORT
+	dev_flush(dev);
+#endif
+	return r;
 }
 
-int64_t dev_read(struct device * dev, uint64_t offset,
-		 int64_t len, void *buffer)
+int dev_write(struct device *dev, uint64_t offset, size_t len, void *buffer)
 {
-	const char *name = dev_name(dev);
-	int fd = dev->fd;
+	struct device_area where;
 
-	if (fd < 0) {
-		log_err("Attempt to read an unopened device (%s).", name);
+	if (!dev->open_count)
 		return 0;
-	}
 
-	if (lseek(fd, offset, SEEK_SET) < 0) {
-		log_sys_error("lseek", name);
-		return 0;
-	}
-
-	return _read(fd, buffer, len);
-}
-
-int _write(int fd, const void *buf, size_t count)
-{
-	size_t n = 0;
-	int tot = 0;
-
-	/* Skip all writes */
-	if (test_mode())
-		return count;
-
-	while (tot < count) {
-		do
-			n = write(fd, buf, count - tot);
-		while ((n < 0) && ((errno == EINTR) || (errno == EAGAIN)));
-
-		if (n <= 0)
-			return tot ? tot : n;
-
-		tot += n;
-		buf += n;
-	}
-
-	return tot;
-}
-
-int64_t dev_write(struct device * dev, uint64_t offset,
-		  int64_t len, void *buffer)
-{
-	const char *name = dev_name(dev);
-	int fd = dev->fd;
-
-	if (fd < 0) {
-		log_error("Attempt to write to unopened device %s", name);
-		return 0;
-	}
-
-	if (lseek(fd, offset, SEEK_SET) < 0) {
-		log_sys_error("lseek", name);
-		return 0;
-	}
+	where.dev = dev;
+	where.start = offset;
+	where.size = len;
 
 	dev->flags |= DEV_ACCESSED_W;
 
-	return _write(fd, buffer, len);
+	return _aligned_io(&where, buffer, 1);
 }
 
-int dev_zero(struct device *dev, uint64_t offset, int64_t len)
+int dev_zero(struct device *dev, uint64_t offset, size_t len)
 {
-	int64_t r, s;
+	size_t s;
 	char buffer[4096];
-	const char *name = dev_name(dev);
-	int fd = dev->fd;
 
-	if (fd < 0) {
-		log_error("Attempt to zero part of an unopened device %s",
-			  name);
+	if (!dev_open(dev)) {
+		stack;
 		return 0;
 	}
 
-	if (lseek(fd, offset, SEEK_SET) < 0) {
-		log_sys_error("lseek", name);
-		return 0;
-	}
+	if ((offset % SECTOR_SIZE) || (len % SECTOR_SIZE))
+		log_debug("Wiping %s at %" PRIu64 " length %" PRIsize_t,
+			  dev_name(dev), offset, len);
+	else
+		log_debug("Wiping %s at sector %" PRIu64 " length %" PRIsize_t
+			  " sectors", dev_name(dev), offset >> SECTOR_SHIFT,
+			  len >> SECTOR_SHIFT);
 
 	memset(buffer, 0, sizeof(buffer));
 	while (1) {
 		s = len > sizeof(buffer) ? sizeof(buffer) : len;
-		r = _write(fd, buffer, s);
-
-		if (r <= 0)
+		if (!dev_write(dev, offset, s, buffer))
 			break;
 
-		len -= r;
-		if (!len) {
-			r = 1;
+		len -= s;
+		if (!len)
 			break;
-		}
+
+		offset += s;
 	}
 
 	dev->flags |= DEV_ACCESSED_W;
 
+	if (!dev_close(dev))
+		stack;
+
 	/* FIXME: Always display error */
 	return (len == 0);
 }

lib/device/device.c

@@ -1,32 +1,31 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This LVM library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * This file is part of LVM2.
  *
- * This LVM library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
+ * 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 Library General Public
- * License along with this LVM library; if not, write to the Free
- * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA
+ * 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 <sys/types.h>
+#if 0
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <ctype.h>
-#include <string.h>
+
 #include <errno.h>
 #include <sys/ioctl.h>
+#include <linux/fs.h>
+#include <linux/major.h>
+#include <linux/genhd.h>
 
 #include "dbg_malloc.h"
 #include "log.h"
@@ -34,11 +33,6 @@
 #include "metadata.h"
 #include "device.h"
 
-#include <linux/fs.h>
-#include <linux/major.h>
-#include <linux/genhd.h>
-
-#if 0
 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))

lib/device/device.h

@@ -1,28 +1,44 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_DEVICE_H
 #define _LVM_DEVICE_H
 
-#include "lvm-types.h"
-#include "list.h"
+#include "uuid.h"
+#include <fcntl.h>
 
 #define DEV_ACCESSED_W		0x00000001	/* Device written to? */
+#define DEV_REGULAR		0x00000002	/* Regular file? */
+#define DEV_ALLOCED		0x00000004	/* dbg_malloc used */
 
 /*
  * All devices in LVM will be represented by one of these.
  * pointer comparisons are valid.
  */
 struct device {
-	struct list aliases; /* struct str_list from lvm-types.h */
+	struct list aliases;	/* struct str_list from lvm-types.h */
 	dev_t dev;
 
 	/* private */
 	int fd;
+	int open_count;
 	uint32_t flags;
+	uint64_t end;
+	struct list open_list;
+
+	char pvid[ID_LEN + 1];
 };
 
 struct device_list {
@@ -30,33 +46,58 @@ struct device_list {
 	struct device *dev;
 };
 
+struct device_area {
+	struct device *dev;
+	uint64_t start;		/* Bytes */
+	uint64_t size;		/* Bytes */
+};
+
 /*
  * All io should use these routines.
  */
 int dev_get_size(struct device *dev, uint64_t *size);
 int dev_get_sectsize(struct device *dev, uint32_t *size);
 
-int dev_open(struct device *dev, int flags);
+/* Use quiet version if device number could change e.g. when opening LV */
+int dev_open(struct device *dev);
+int dev_open_quiet(struct device *dev);
+int dev_open_flags(struct device *dev, int flags, int append, int quiet);
 int dev_close(struct device *dev);
+int dev_close_immediate(struct device *dev);
+void dev_close_all(void);
 
-int64_t dev_read(struct device *dev,
-		 uint64_t offset, int64_t len, void *buffer);
-int64_t dev_write(struct device *dev,
-		  uint64_t offset, int64_t len, void *buffer);
-int dev_zero(struct device *dev, uint64_t offset, int64_t len);
+static inline int dev_fd(struct device *dev)
+{
+	return dev->fd;
+}
 
+int dev_read(struct device *dev, uint64_t offset, size_t len, void *buffer);
+int dev_write(struct device *dev, uint64_t offset, size_t len, void *buffer);
+int dev_append(struct device *dev, size_t len, void *buffer);
+int dev_zero(struct device *dev, uint64_t offset, size_t len);
+void dev_flush(struct device *dev);
 
-static inline const char *dev_name(struct device *dev) {
+struct device *dev_create_file(const char *filename, struct device *dev,
+			       struct str_list *alias);
+
+static inline const char *dev_name(const struct device *dev)
+{
 	return (dev) ? list_item(dev->aliases.n, struct str_list)->str :
-		       "unknown device";
+	    "unknown device";
 }
 
 /* Return a valid device name from the alias list; NULL otherwise */
-const char *dev_name_confirmed(struct device *dev);
+const char *dev_name_confirmed(struct device *dev, int quiet);
 
-static inline int is_lvm_partition(const char *name) {
+/* FIXME Check partition type if appropriate */
+
+#define is_lvm_partition(a) 1
+
+/*
+static inline int is_lvm_partition(const char *name)
+{
 	return 1;
 }
+*/
 
 #endif
-

lib/display/display.h

@@ -1,21 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This LVM library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
+ * This file is part of LVM2.
  *
- * This LVM library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this LVM library; if not, write to the Free
- * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA
+ * 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 _LVM_DISPLAY_H
@@ -25,19 +20,25 @@
 
 #include <stdint.h>
 
-typedef	enum {SIZE_LONG=0, SIZE_SHORT=1} size_len_t;
+typedef enum { SIZE_LONG = 0, SIZE_SHORT = 1, SIZE_UNIT = 2 } size_len_t;
+
+uint64_t units_to_bytes(const char *units, char *unit_type);
 
 /* Specify size in KB */
-char *display_size(uint64_t size, size_len_t sl);
+const char *display_size(struct cmd_context *cmd, uint64_t size, size_len_t sl);
 char *display_uuid(char *uuidstr);
+void display_stripe(const struct lv_segment *seg, uint32_t s, const char *pre);
 
 void pvdisplay_colons(struct physical_volume *pv);
-void pvdisplay_full(struct physical_volume *pv);
-int pvdisplay_short(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv);
+void pvdisplay_full(struct cmd_context *cmd, struct physical_volume *pv,
+		    void *handle);
+int pvdisplay_short(struct cmd_context *cmd, struct volume_group *vg,
+		    struct physical_volume *pv, void *handle);
 
 void lvdisplay_colons(struct logical_volume *lv);
 int lvdisplay_segments(struct logical_volume *lv);
-int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv);
+int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
+		   void *handle);
 
 void vgdisplay_extents(struct volume_group *vg);
 void vgdisplay_full(struct volume_group *vg);
@@ -45,14 +46,9 @@ void vgdisplay_colons(struct volume_group *vg);
 void vgdisplay_short(struct volume_group *vg);
 
 /*
- * Retrieve a text description of the allocation policy.  Only
- * extern because it's used by lvscan.
+ * Allocation policy display conversion routines.
  */
 const char *get_alloc_string(alloc_policy_t alloc);
-
-/*
- * FIXME: put this somewhere more sensible.
- */
 alloc_policy_t get_alloc_from_string(const char *str);
 
 #endif

lib/error/errseg.c

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "pool.h"
+#include "list.h"
+#include "toolcontext.h"
+#include "segtypes.h"
+#include "display.h"
+#include "text_export.h"
+#include "text_import.h"
+#include "config.h"
+#include "str_list.h"
+#include "targets.h"
+#include "lvm-string.h"
+#include "activate.h"
+
+static const char *_name(const struct lv_segment *seg)
+{
+	return seg->segtype->name;
+}
+
+static int _merge_segments(struct lv_segment *seg1, struct lv_segment *seg2)
+{
+	seg1->len += seg2->len;
+	seg1->area_len += seg2->area_len;
+
+	return 1;
+}
+
+#ifdef DEVMAPPER_SUPPORT
+static int _compose_target_line(struct dev_manager *dm, struct pool *mem,
+				struct config_tree *cft, void **target_state,
+				struct lv_segment *seg, char *params,
+				size_t paramsize, const char **target, int *pos,
+				uint32_t *pvmove_mirror_count)
+{
+	/*   error */
+
+	*target = "error";
+	*params = '\0';
+
+	return 1;
+}
+
+static int _target_present(void)
+{
+	static int checked = 0;
+	static int present = 0;
+
+	if (!checked)
+		present = target_present("error");
+
+	checked = 1;
+	return present;
+}
+#endif
+
+static void _destroy(const struct segment_type *segtype)
+{
+	dbg_free((void *) segtype);
+}
+
+static struct segtype_handler _error_ops = {
+	name:_name,
+	merge_segments:_merge_segments,
+#ifdef DEVMAPPER_SUPPORT
+	compose_target_line:_compose_target_line,
+	target_present:_target_present,
+#endif
+	destroy:_destroy,
+};
+
+struct segment_type *init_error_segtype(struct cmd_context *cmd)
+{
+	struct segment_type *segtype = dbg_malloc(sizeof(*segtype));
+
+	if (!segtype) {
+		stack;
+		return NULL;
+	}
+
+	segtype->cmd = cmd;
+	segtype->ops = &_error_ops;
+	segtype->name = "error";
+	segtype->private = NULL;
+	segtype->flags = SEG_CAN_SPLIT | SEG_VIRTUAL;
+
+	return segtype;
+}

lib/filters/filter-composite.c

@@ -1,12 +1,20 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "filter-composite.h"
-#include "dbg_malloc.h"
-#include "log.h"
 
 #include <stdarg.h>
 
@@ -20,6 +28,8 @@ static int _and_p(struct dev_filter *f, struct device *dev)
 		filters++;
 	}
 
+	log_debug("Using %s", dev_name(dev));
+
 	return 1;
 }
 
@@ -36,35 +46,32 @@ static void _destroy(struct dev_filter *f)
 	dbg_free(f);
 }
 
-struct dev_filter *composite_filter_create(int n, ...)
+struct dev_filter *composite_filter_create(int n, struct dev_filter **filters)
 {
-	struct dev_filter **filters = dbg_malloc(sizeof(*filters) * (n + 1));
-	struct dev_filter *cf;
-	va_list ap;
-	int i;
+	struct dev_filter **filters_copy, *cft;
 
 	if (!filters) {
 		stack;
 		return NULL;
 	}
 
-	if (!(cf = dbg_malloc(sizeof(*cf)))) {
-		stack;
-		dbg_free(filters);
+	if (!(filters_copy = dbg_malloc(sizeof(*filters) * (n + 1)))) {
+		log_error("composite filters allocation failed");
 		return NULL;
 	}
 
-	va_start(ap, n);
-	for (i = 0; i < n; i++) {
-		struct dev_filter *f = va_arg(ap, struct dev_filter *);
-		filters[i] = f;
+	memcpy(filters_copy, filters, sizeof(*filters) * n);
+	filters_copy[n] = NULL;
+
+	if (!(cft = dbg_malloc(sizeof(*cft)))) {
+		log_error("compsoite filters allocation failed");
+		dbg_free(filters_copy);
+		return NULL;
 	}
-	filters[i] = NULL;
-	va_end(ap);
 
-	cf->passes_filter = _and_p;
-	cf->destroy = _destroy;
-	cf->private = filters;
+	cft->passes_filter = _and_p;
+	cft->destroy = _destroy;
+	cft->private = filters_copy;
 
-	return cf;
+	return cft;
 }

lib/filters/filter-composite.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_FILTER_COMPOSITE_H
@@ -9,6 +18,6 @@
 
 #include "dev-cache.h"
 
-struct dev_filter *composite_filter_create(int n, ...);
+struct dev_filter *composite_filter_create(int n, struct dev_filter **filters);
 
 #endif

lib/filters/filter-md.c

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2004 Luca Berra
+ *
+ * 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 "filter-md.h"
+#include "metadata.h"
+
+#ifdef linux
+
+/* 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)
+
+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.
+		 */
+		return 1;
+
+	if (!dev_open(dev)) {
+		stack;
+		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 (!dev_close(dev))
+		stack;
+
+	return 1;
+}
+
+static void _destroy(struct dev_filter *f)
+{
+	dbg_free(f);
+}
+
+struct dev_filter *md_filter_create(void)
+{
+	struct dev_filter *f;
+
+	if (!(f = dbg_malloc(sizeof(*f)))) {
+		log_error("md filter allocation failed");
+		return NULL;
+	}
+
+	f->passes_filter = _ignore_md;
+	f->destroy = _destroy;
+	f->private = NULL;
+
+	return f;
+}
+
+#else
+
+struct dev_filter *md_filter_create(void)
+{
+	return NULL;
+}
+
+#endif

lib/filters/filter-md.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2004 Luca Berra
+ *
+ * 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
+ */
+
+#ifndef _LVM_FILTER_MD_H
+#define _LVM_FILTER_MD_H
+
+#include "dev-cache.h"
+
+struct dev_filter *md_filter_create(void);
+
+#endif
+

lib/filters/filter-persistent.c

@@ -1,17 +1,24 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "config.h"
 #include "dev-cache.h"
 #include "hash.h"
-#include "dbg_malloc.h"
-#include "log.h"
 #include "filter-persistent.h"
 
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
@@ -34,8 +41,12 @@ static int _init_hash(struct pfilter *pf)
 	if (pf->devices)
 		hash_destroy(pf->devices);
 
-	pf->devices = hash_create(128);
-	return pf->devices ? 1 : 0;
+	if (!(pf->devices = hash_create(128))) {
+		stack;
+		return 0;
+	}
+
+	return 1;
 }
 
 int persistent_filter_wipe(struct dev_filter *f)
@@ -43,16 +54,19 @@ int persistent_filter_wipe(struct dev_filter *f)
 	struct pfilter *pf = (struct pfilter *) f->private;
 
 	hash_wipe(pf->devices);
+	/* Trigger complete device scan */
+	dev_cache_scan(1);
+
 	return 1;
 }
 
-static int _read_array(struct pfilter *pf, struct config_file *cf,
+static int _read_array(struct pfilter *pf, struct config_tree *cft,
 		       const char *path, void *data)
 {
-	struct config_node *cn;
+	const struct config_node *cn;
 	struct config_value *cv;
 
-	if (!(cn = find_config_node(cf->root, path, '/'))) {
+	if (!(cn = find_config_node(cft->root, path))) {
 		log_very_verbose("Couldn't find %s array in '%s'",
 				 path, pf->file);
 		return 0;
@@ -72,6 +86,8 @@ static int _read_array(struct pfilter *pf, struct config_file *cf,
 		if (!hash_insert(pf->devices, cv->v.str, data))
 			log_verbose("Couldn't add '%s' to filter ... ignoring",
 				    cv->v.str);
+		/* Populate dev_cache ourselves */
+		dev_cache_get(cv->v.str, NULL);
 	}
 	return 1;
 }
@@ -81,32 +97,39 @@ int persistent_filter_load(struct dev_filter *f)
 	struct pfilter *pf = (struct pfilter *) f->private;
 
 	int r = 0;
-	struct config_file *cf;
+	struct config_tree *cft;
 
-	if (!(cf = create_config_file())) {
+	if (!(cft = create_config_tree(pf->file))) {
 		stack;
 		return 0;
 	}
 
-	if (!read_config(cf, pf->file)) {
+	if (!read_config_file(cft)) {
 		stack;
 		goto out;
 	}
 
-	_read_array(pf, cf, "persistent_filter_cache/valid_devices",
+	_read_array(pf, cft, "persistent_filter_cache/valid_devices",
 		    PF_GOOD_DEVICE);
-	_read_array(pf, cf, "persistent_filter_cache/invalid_devices",
-		    PF_BAD_DEVICE);
+	/* We don't gain anything by holding invalid devices */
+	/* _read_array(pf, cft, "persistent_filter_cache/invalid_devices",
+	   PF_BAD_DEVICE); */
 
-	if (hash_get_num_entries(pf->devices))
+	/* Did we find anything? */
+	if (hash_get_num_entries(pf->devices)) {
+		/* We populated dev_cache ourselves */
+		dev_cache_scan(0);
 		r = 1;
+	}
+
+	log_very_verbose("Loaded persistent filter cache from %s", pf->file);
 
       out:
-	destroy_config_file(cf);
+	destroy_config_tree(cft);
 	return r;
 }
 
-static void _write_array(struct pfilter *pf, FILE * fp, const char *path,
+static void _write_array(struct pfilter *pf, FILE *fp, const char *path,
 			 void *data)
 {
 	void *d;
@@ -147,6 +170,12 @@ int persistent_filter_dump(struct dev_filter *f)
 				 "- not writing to %s", pf->file);
 		return 0;
 	}
+	if (!dev_cache_has_scanned()) {
+		log_very_verbose("Device cache incomplete - not writing "
+				 "to %s", pf->file);
+		return 0;
+	}
+
 	log_very_verbose("Dumping persistent device cache to %s", pf->file);
 
 	fp = fopen(pf->file, "w");
@@ -160,7 +189,8 @@ int persistent_filter_dump(struct dev_filter *f)
 	fprintf(fp, "persistent_filter_cache {\n");
 
 	_write_array(pf, fp, "valid_devices", PF_GOOD_DEVICE);
-	_write_array(pf, fp, "invalid_devices", PF_BAD_DEVICE);
+	/* We don't gain anything by remembering invalid devices */
+	/* _write_array(pf, fp, "invalid_devices", PF_BAD_DEVICE); */
 
 	fprintf(fp, "}\n");
 	fclose(fp);
@@ -184,7 +214,11 @@ static int _lookup_p(struct dev_filter *f, struct device *dev)
 		}
 	}
 
-	return l == PF_GOOD_DEVICE;
+	if (l == PF_BAD_DEVICE) {
+		log_debug("%s: Skipping (cached)", dev_name(dev));
+		return 0;
+	} else
+		return 1;
 }
 
 static void _destroy(struct dev_filter *f)

lib/filters/filter-persistent.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_FILTER_PERSISTENT_H

lib/filters/filter-regex.c

@@ -1,15 +1,24 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "pool.h"
 #include "filter-regex.h"
 #include "matcher.h"
 #include "device.h"
 #include "bitset.h"
-#include "log.h"
 #include "list.h"
 
 struct rfilter {
@@ -19,7 +28,7 @@ struct rfilter {
 };
 
 static int _extract_pattern(struct pool *mem, const char *pat,
-			    char **regex, bitset_t accept, int index)
+			    char **regex, bitset_t accept, int ix)
 {
 	char sep, *r, *ptr;
 
@@ -28,11 +37,11 @@ static int _extract_pattern(struct pool *mem, const char *pat,
 	 */
 	switch (*pat) {
 	case 'a':
-		bit_set(accept, index);
+		bit_set(accept, ix);
 		break;
 
 	case 'r':
-		bit_clear(accept, index);
+		bit_clear(accept, ix);
 		break;
 
 	default:
@@ -42,7 +51,7 @@ static int _extract_pattern(struct pool *mem, const char *pat,
 	pat++;
 
 	/*
-	 * get the seperator
+	 * get the separator
 	 */
 	switch (*pat) {
 	case '(':
@@ -75,12 +84,12 @@ static int _extract_pattern(struct pool *mem, const char *pat,
 	 */
 	ptr = r + strlen(r) - 1;
 	if (*ptr != sep) {
-		log_info("invalid seperator at end of regex");
+		log_info("invalid separator at end of regex");
 		return 0;
 	}
 	*ptr = '\0';
 
-	regex[index] = r;
+	regex[ix] = r;
 	return 1;
 }
 
@@ -89,7 +98,8 @@ static int _build_matcher(struct rfilter *rf, struct config_value *val)
 	struct pool *scratch;
 	struct config_value *v;
 	char **regex;
-	int count = 0, i, r = 0;
+	unsigned count = 0;
+	int i, r = 0;
 
 	if (!(scratch = pool_create(1024))) {
 		stack;
@@ -137,7 +147,7 @@ static int _build_matcher(struct rfilter *rf, struct config_value *val)
 	 * build the matcher.
 	 */
 	if (!(rf->engine = matcher_create(rf->mem, (const char **) regex,
-					  count))) 
+					  count)))
 		stack;
 	r = 1;
 
@@ -161,6 +171,8 @@ static int _accept_p(struct dev_filter *f, struct device *dev)
 			if (bit(rf->accept, m)) {
 
 				if (!first) {
+					log_debug("%s: New preferred name",
+						  sl->str);
 					list_del(&sl->list);
 					list_add_h(&dev->aliases, &sl->list);
 				}

lib/filters/filter-regex.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_FILTER_REGEX_H

lib/filters/filter-sysfs.c

@@ -0,0 +1,288 @@
+/*
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "filter-sysfs.h"
+#include "lvm-string.h"
+#include "pool.h"
+
+#ifdef linux
+
+#include <dirent.h>
+
+static int _locate_sysfs_blocks(const char *proc, char *path, size_t len)
+{
+	char proc_mounts[PATH_MAX];
+	int r = 0;
+	FILE *fp;
+	char *split[4], buffer[PATH_MAX + 16];
+
+	if (!*proc) {
+		log_verbose("No proc filesystem found: skipping sysfs filter");
+		return 0;
+	}
+		
+	if (lvm_snprintf(proc_mounts, sizeof(proc_mounts),
+			 "%s/mounts", proc) < 0) {
+		log_error("Failed to create /proc/mounts string");
+		return 0;
+	}
+
+	if (!(fp = fopen(proc_mounts, "r"))) {
+		log_sys_error("fopen %s", proc_mounts);
+		return 0;
+	}
+
+	while (fgets(buffer, sizeof(buffer), fp)) {
+		if (split_words(buffer, 4, split) == 4 &&
+		    !strcmp(split[2], "sysfs")) {
+			if (lvm_snprintf(path, len, "%s/%s", split[1],
+					 "block") >= 0) {
+				r = 1;
+			}
+			break;
+		}
+	}
+
+	fclose(fp);
+	return r;
+}
+
+/*----------------------------------------------------------------
+ * We need to store a set of dev_t.
+ *--------------------------------------------------------------*/
+struct entry {
+	struct entry *next;
+	dev_t dev;
+};
+
+#define SET_BUCKETS 64
+struct dev_set {
+	struct pool *mem;
+	const char *sys_block;
+	int initialised;
+	struct entry *slots[SET_BUCKETS];
+};
+
+static struct dev_set *_dev_set_create(struct pool *mem, const char *sys_block)
+{
+	struct dev_set *ds;
+
+	if (!(ds = pool_zalloc(mem, sizeof(*ds))))
+		return NULL;
+
+	ds->mem = mem;
+	ds->sys_block = pool_strdup(mem, sys_block);
+	ds->initialised = 0;
+
+	return ds;
+}
+
+static inline unsigned _hash_dev(dev_t dev)
+{
+	return (major(dev) ^ minor(dev)) & (SET_BUCKETS - 1);
+}
+
+/*
+ * Doesn't check that the set already contains dev.
+ */
+static int _set_insert(struct dev_set *ds, dev_t dev)
+{
+	struct entry *e;
+	unsigned h = _hash_dev(dev);
+
+	if (!(e = pool_alloc(ds->mem, sizeof(*e))))
+		return 0;
+
+	e->next = ds->slots[h];
+	e->dev = dev;
+	ds->slots[h] = e;
+
+	return 1;
+}
+
+static int _set_lookup(struct dev_set *ds, dev_t dev)
+{
+	unsigned h = _hash_dev(dev);
+	struct entry *e;
+
+	for (e = ds->slots[h]; e; e = e->next)
+		if (e->dev == dev)
+			return 1;
+
+	return 0;
+}
+
+/*----------------------------------------------------------------
+ * filter methods
+ *--------------------------------------------------------------*/
+static int _parse_dev(const char *file, FILE *fp, dev_t *result)
+{
+	unsigned major, minor;
+	char buffer[64];
+
+	if (!fgets(buffer, sizeof(buffer), fp)) {
+		log_error("Empty sysfs device file: %s", file);
+		return 0;
+	}
+
+	if (sscanf(buffer, "%u:%u", &major, &minor) != 2) {
+		log_info("sysfs device file not correct format");
+		return 0;
+	}
+
+	*result = makedev(major, minor);
+	return 1;
+}
+
+static int _read_dev(const char *file, dev_t *result)
+{
+	int r;
+	FILE *fp;
+
+	if (!(fp = fopen(file, "r"))) {
+		log_sys_error("fopen", file);
+		return 0;
+	}
+
+	r = _parse_dev(file, fp, result);
+	fclose(fp);
+
+	return r;
+}
+
+/*
+ * Recurse through sysfs directories, inserting any devs found.
+ */
+static int _read_devs(struct dev_set *ds, const char *dir)
+{
+        struct dirent *d;
+        DIR *dr;
+	char path[PATH_MAX];
+	dev_t dev;
+	int r = 1;
+
+        if (!(dr = opendir(dir))) {
+                log_sys_error("opendir", dir);
+                return 0;
+        }
+
+        while ((d = readdir(dr))) {
+                if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
+			continue;
+
+		if (lvm_snprintf(path, sizeof(path), "%s/%s", dir,
+				 d->d_name) < 0) {
+			log_error("sysfs path name too long: %s in %s",
+				  d->d_name, dir);
+			continue;
+		}
+
+		if (d->d_type == DT_DIR) {
+			if (!_read_devs(ds, path)) {
+				r = 0;
+				break;
+			}
+		}
+
+		if ((d->d_type == DT_REG && !strcmp(d->d_name, "dev")))
+			if (!_read_dev(path, &dev) || !_set_insert(ds, dev)) {
+				r = 0;
+				break;
+			}
+
+	}
+
+        if (closedir(dr))
+                log_sys_error("closedir", dir);
+
+	return r;
+}
+
+static int _init_devs(struct dev_set *ds)
+{
+	if (!_read_devs(ds, ds->sys_block)) {
+		ds->initialised = -1;
+		return 0;
+	}
+
+	ds->initialised = 1;
+
+	return 1;
+}
+
+
+static int _accept_p(struct dev_filter *f, struct device *dev)
+{
+	struct dev_set *ds = (struct dev_set *) f->private;
+
+	if (!ds->initialised)
+		_init_devs(ds);
+
+	/* Pass through if initialisation failed */
+	if (ds->initialised != 1)
+		return 1;
+
+	return _set_lookup(ds, dev->dev);
+}
+
+static void _destroy(struct dev_filter *f)
+{
+	struct dev_set *ds = (struct dev_set *) f->private;
+	pool_destroy(ds->mem);
+}
+
+struct dev_filter *sysfs_filter_create(const char *proc)
+{
+	char sys_block[PATH_MAX];
+	struct pool *mem;
+	struct dev_set *ds;
+	struct dev_filter *f;
+
+	if (!_locate_sysfs_blocks(proc, sys_block, sizeof(sys_block)))
+		return NULL;
+
+	if (!(mem = pool_create(256))) {
+		log_error("sysfs pool creation failed");
+		return NULL;
+	}
+
+	if (!(ds = _dev_set_create(mem, sys_block))) {
+		log_error("sysfs dev_set creation failed");
+		goto bad;
+	}
+
+	if (!(f = pool_zalloc(mem, sizeof(*f)))) {
+		stack;
+		goto bad;
+	}
+
+	f->passes_filter = _accept_p;
+	f->destroy = _destroy;
+	f->private = ds;
+	return f;
+
+ bad:
+	pool_destroy(mem);
+	return NULL;
+}
+
+#else
+
+struct dev_filter *sysfs_filter_create(const char *proc)
+{
+	return NULL;
+}
+
+#endif

lib/filters/filter-sysfs.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_FILTER_SYSFS_H
+#define _LVM_FILTER_SYSFS_H
+
+#include "config.h"
+#include "dev-cache.h"
+
+struct dev_filter *sysfs_filter_create(const char *proc);
+
+#endif

lib/filters/filter.c

@@ -1,49 +1,46 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * lvm is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
+ * This file is part of LVM2.
  *
- * lvm is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * 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 GNU CC; see the file COPYING.  If not, write to
- * the Free Software Foundation, 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "dbg_malloc.h"
-#include "log.h"
+#include "lib.h"
 #include "dev-cache.h"
 #include "filter.h"
 #include "lvm-string.h"
+#include "config.h"
 
-#include <stdlib.h>
 #include <dirent.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <unistd.h>
-#include <string.h>
 #include <ctype.h>
 #include <fcntl.h>
-#include <linux/kdev_t.h>
+#include <limits.h>
 
 #define NUMBER_OF_MAJORS 256
 
 typedef struct {
-	char *name;
-	int max_partitions;
+	const char *name;
+	const int max_partitions;
 } device_info_t;
 
 static int _md_major = -1;
 
-static device_info_t device_info[] = {
+int md_major(void)
+{
+	return _md_major;
+}
+
+/* This list can be supplemented with devices/types in the config file */
+static const device_info_t device_info[] = {
 	{"ide", 16},		/* IDE disk */
 	{"sd", 16},		/* SCSI disk */
 	{"md", 16},		/* Multiple Disk driver (SoftRAID) */
@@ -55,24 +52,29 @@ static device_info_t device_info[] = {
 	{"cciss", 16},		/* Compaq CCISS array */
 	{"ubd", 16},		/* User-mode virtual block device */
 	{"ataraid", 16},	/* ATA Raid */
+	{"drbd", 16},		/* Distributed Replicated Block Device */
+	{"power2", 16},		/* EMC Powerpath */
+	{"i2o_block", 16},	/* i2o Block Disk */
 	{NULL, 0}
 };
 
-static int *scan_proc_dev(const char *proc);
-
-static int passes_lvm_type_device_filter(struct dev_filter *f,
-					 struct device *dev)
+static int _passes_lvm_type_device_filter(struct dev_filter *f,
+					  struct device *dev)
 {
 	int fd;
 	const char *name = dev_name(dev);
 
 	/* Is this a recognised device type? */
-	if (!(((int *) f->private)[MAJOR(dev->dev)]))
+	if (!(((int *) f->private)[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("Unable to open %s: %s", name, strerror(errno));
+		log_debug("%s: Skipping: open failed: %s", name,
+			  strerror(errno));
 		return 0;
 	}
 
@@ -81,48 +83,18 @@ static int passes_lvm_type_device_filter(struct dev_filter *f,
 	return 1;
 }
 
-struct dev_filter *lvm_type_filter_create(const char *proc)
-{
-	struct dev_filter *f;
-
-	if (!(f = dbg_malloc(sizeof(struct dev_filter)))) {
-		log_error("LVM type filter allocation failed");
-		return NULL;
-	}
-
-	f->passes_filter = passes_lvm_type_device_filter;
-	f->destroy = lvm_type_filter_destroy;
-
-	if (!(f->private = scan_proc_dev(proc)))
-		return NULL;
-
-	return f;
-}
-
-int md_major(void)
-{
-	return _md_major;
-}
-
-void lvm_type_filter_destroy(struct dev_filter *f)
-{
-	dbg_free(f->private);
-	dbg_free(f);
-	return;
-}
-
-static int *scan_proc_dev(const char *proc)
+static int *_scan_proc_dev(const char *proc, const struct config_node *cn)
 {
 	char line[80];
 	char proc_devices[PATH_MAX];
 	FILE *pd = NULL;
-	int ret = 0;
 	int i, j = 0;
 	int line_maj = 0;
 	int blocksection = 0;
-	int dev_len = 0;
-
+	size_t dev_len = 0;
+	struct config_value *cv;
 	int *max_partitions_by_major;
+	char *name;
 
 	if (!(max_partitions_by_major =
 	      dbg_malloc(sizeof(int) * NUMBER_OF_MAJORS))) {
@@ -130,6 +102,14 @@ static int *scan_proc_dev(const char *proc)
 		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;
+	}
+
 	if (lvm_snprintf(proc_devices, sizeof(proc_devices),
 			 "%s/devices", proc) < 0) {
 		log_error("Failed to create /proc/devices string");
@@ -173,12 +153,44 @@ static int *scan_proc_dev(const char *proc)
 		for (j = 0; device_info[j].name != NULL; j++) {
 
 			dev_len = strlen(device_info[j].name);
-			if (dev_len <= strlen(line + i)
-			    && !strncmp(device_info[j].name, line + i, dev_len)
-			    && (line_maj < NUMBER_OF_MAJORS)) {
+			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] =
 				    device_info[j].max_partitions;
-				ret++;
+				break;
+			}
+		}
+
+		if (max_partitions_by_major[line_maj] || !cn)
+			continue;
+
+		/* Check devices/types for local variations */
+		for (cv = cn->v; cv; cv = cv->next) {
+			if (cv->type != CFG_STRING) {
+				log_error("Expecting string in devices/types "
+					  "in config file");
+				return NULL;
+			}
+			dev_len = strlen(cv->v.str);
+			name = cv->v.str;
+			cv = cv->next;
+			if (!cv || cv->type != CFG_INT) {
+				log_error("Max partition count missing for %s "
+					  "in devices/types in config file",
+					  name);
+				return NULL;
+			}
+			if (!cv->v.i) {
+				log_error("Zero partition count invalid for "
+					  "%s in devices/types in config file",
+					  name);
+				return NULL;
+			}
+			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;
 				break;
 			}
 		}
@@ -186,3 +198,31 @@ static int *scan_proc_dev(const char *proc)
 	fclose(pd);
 	return max_partitions_by_major;
 }
+
+struct dev_filter *lvm_type_filter_create(const char *proc,
+					  const struct config_node *cn)
+{
+	struct dev_filter *f;
+
+	if (!(f = dbg_malloc(sizeof(struct dev_filter)))) {
+		log_error("LVM type filter allocation failed");
+		return NULL;
+	}
+
+	f->passes_filter = _passes_lvm_type_device_filter;
+	f->destroy = lvm_type_filter_destroy;
+
+	if (!(f->private = _scan_proc_dev(proc, cn))) {
+		stack;
+		return NULL;
+	}
+
+	return f;
+}
+
+void lvm_type_filter_destroy(struct dev_filter *f)
+{
+	dbg_free(f->private);
+	dbg_free(f);
+	return;
+}

lib/filters/filter.h

@@ -1,31 +1,38 @@
 /*
- * Copyright (C) 2001 Sistina Software
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * lvm is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
+ * This file is part of LVM2.
  *
- * lvm is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * 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 GNU CC; see the file COPYING.  If not, write to
- * the Free Software Foundation, 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
- *
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_FILTER_H
 #define _LVM_FILTER_H
 
-struct dev_filter *lvm_type_filter_create(const char *proc);
+#include "config.h"
+
+#include <sys/stat.h>
+
+#ifdef linux
+#  include <linux/kdev_t.h>
+#else
+#  define MAJOR(x) major((x))
+#  define MINOR(x) minor((x))
+#  define MKDEV(x,y) makedev((x),(y))
+#endif
+
+struct dev_filter *lvm_type_filter_create(const char *proc,
+					  const struct config_node *cn);
 
 void lvm_type_filter_destroy(struct dev_filter *f);
 
 int md_major(void);
 
 #endif
-

lib/format1/.exported_symbols

@@ -0,0 +1 @@
+init_format

lib/format1/Makefile.in

@@ -0,0 +1,38 @@
+#
+# Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
+# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+#
+# This file is part of the LVM2.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU General Public License v.2.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+
+SOURCES =\
+	disk-rep.c \
+	format1.c \
+	import-export.c \
+	import-extents.c \
+	layout.c \
+	lvm1-label.c \
+	vg_number.c
+
+LIB_SHARED = liblvm2format1.so
+
+include ../../make.tmpl
+
+.PHONY: install
+
+install: liblvm2format1.so
+	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
+		$(libdir)/liblvm2format1.so.$(LIB_VERSION)
+	$(LN_S) -f liblvm2format1.so.$(LIB_VERSION) $(libdir)/liblvm2format1.so
+

lib/format1/disk-rep.c

@@ -1,21 +1,26 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "disk-rep.h"
-#include "dbg_malloc.h"
 #include "pool.h"
 #include "xlate.h"
-#include "log.h"
-#include "vgcache.h"
 #include "filter.h"
+#include "lvmcache.h"
 
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <fcntl.h>
-#include <linux/kdev_t.h>
 
 #define fail do {stack; return 0;} while(0)
 #define xx16(v) disk->v = xlate16(disk->v)
@@ -96,7 +101,7 @@ static void _xlate_vgd(struct vg_disk *disk)
 	xx32(pvg_total);
 }
 
-static void _xlate_extents(struct pe_disk *extents, int count)
+static void _xlate_extents(struct pe_disk *extents, uint32_t count)
 {
 	int i;
 
@@ -112,16 +117,17 @@ static void _xlate_extents(struct pe_disk *extents, int count)
 static int _munge_formats(struct pv_disk *pvd)
 {
 	uint32_t pe_start;
+	int b, e;
 
 	switch (pvd->version) {
 	case 1:
 		pvd->pe_start = ((pvd->pe_on_disk.base +
-				  pvd->pe_on_disk.size) / SECTOR_SIZE);
+				  pvd->pe_on_disk.size) >> SECTOR_SHIFT);
 		break;
 
 	case 2:
 		pvd->version = 1;
-		pe_start = pvd->pe_start * SECTOR_SIZE;
+		pe_start = pvd->pe_start << SECTOR_SHIFT;
 		pvd->pe_on_disk.size = pe_start - pvd->pe_on_disk.base;
 		break;
 
@@ -129,37 +135,88 @@ static int _munge_formats(struct pv_disk *pvd)
 		return 0;
 	}
 
+        /* UUID too long? */
+        if (pvd->pv_uuid[ID_LEN]) {
+		/* Retain ID_LEN chars from end */
+                for (e = ID_LEN; e < sizeof(pvd->pv_uuid); e++) {
+                        if (!pvd->pv_uuid[e]) {
+                                e--;
+                                break;
+                        }
+                }
+		for (b = 0; b < ID_LEN; b++) {
+			pvd->pv_uuid[b] = pvd->pv_uuid[++e - ID_LEN];
+			/* FIXME Remove all invalid chars */
+			if (pvd->pv_uuid[b] == '/')
+				pvd->pv_uuid[b] = '#';
+		}
+		memset(&pvd->pv_uuid[ID_LEN], 0, sizeof(pvd->pv_uuid) - ID_LEN);
+        }
+
+	/* If UUID is missing, create one */
+	if (pvd->pv_uuid[0] == '\0')
+		uuid_from_num(pvd->pv_uuid, pvd->pv_number);
+
 	return 1;
 }
 
-int read_pvd(struct device *dev, struct pv_disk *pvd)
+/* 
+ * If exported, remove "PV_EXP" from end of VG name 
+ */
+static void _munge_exported_vg(struct pv_disk *pvd)
 {
-	if (dev_read(dev, 0, sizeof(*pvd), pvd) != sizeof(*pvd)) {
-		log_very_verbose("Failed to read PV data from %s",
-				 dev_name(dev));
-		return 0;
-	}
+	int l;
+	size_t s;
 
+	/* Return if PV not in a VG */
+	if ((!*pvd->vg_name))
+		return;
+	/* FIXME also check vgd->status & VG_EXPORTED? */
+
+	l = strlen(pvd->vg_name);
+	s = sizeof(EXPORTED_TAG);
+	if (!strncmp(pvd->vg_name + l - s + 1, EXPORTED_TAG, s)) {
+		pvd->vg_name[l - s + 1] = '\0';
+                pvd->pv_status |= VG_EXPORTED;
+        }
+}
+
+int munge_pvd(struct device *dev, struct pv_disk *pvd)
+{
 	_xlate_pvd(pvd);
 
 	if (pvd->id[0] != 'H' || pvd->id[1] != 'M') {
-		log_very_verbose("%s does not have a valid PV identifier",
+		log_very_verbose("%s does not have a valid LVM1 PV identifier",
 				 dev_name(dev));
 		return 0;
 	}
 
 	if (!_munge_formats(pvd)) {
-		log_very_verbose("Unknown metadata version %d found on %s",
-				 pvd->version, dev_name(dev));
+		log_very_verbose("format1: Unknown metadata version %d "
+				 "found on %s", pvd->version, dev_name(dev));
 		return 0;
 	}
 
+	/* If VG is exported, set VG name back to the real name */
+	_munge_exported_vg(pvd);
+
 	return 1;
 }
 
-static int _read_lvd(struct device *dev, ulong pos, struct lv_disk *disk)
+static int _read_pvd(struct device *dev, struct pv_disk *pvd)
 {
-	if (dev_read(dev, pos, sizeof(*disk), disk) != sizeof(*disk))
+	if (!dev_read(dev, UINT64_C(0), sizeof(*pvd), pvd)) {
+		log_very_verbose("Failed to read PV data from %s",
+				 dev_name(dev));
+		return 0;
+	}
+
+	return munge_pvd(dev, pvd);
+}
+
+static int _read_lvd(struct device *dev, uint64_t pos, struct lv_disk *disk)
+{
+	if (!dev_read(dev, pos, sizeof(*disk), disk))
 		fail;
 
 	_xlate_lvd(disk);
@@ -170,12 +227,19 @@ static int _read_lvd(struct device *dev, ulong pos, struct lv_disk *disk)
 static int _read_vgd(struct disk_list *data)
 {
 	struct vg_disk *vgd = &data->vgd;
-	ulong pos = data->pvd.vg_on_disk.base;
-	if (dev_read(data->dev, pos, sizeof(*vgd), vgd) != sizeof(*vgd))
+	uint64_t pos = data->pvd.vg_on_disk.base;
+	if (!dev_read(data->dev, pos, sizeof(*vgd), vgd))
 		fail;
 
 	_xlate_vgd(vgd);
 
+	if ((vgd->lv_max > MAX_LV) || (vgd->pv_max > MAX_PV))
+		fail;
+		
+	/* If UUID is missing, create one */
+	if (vgd->vg_uuid[0] == '\0')
+		uuid_from_num(vgd->vg_uuid, vgd->vg_number);
+
 	return 1;
 }
 
@@ -184,12 +248,11 @@ static int _read_uuids(struct disk_list *data)
 	int num_read = 0;
 	struct uuid_list *ul;
 	char buffer[NAME_LEN];
-	ulong pos = data->pvd.pv_uuidlist_on_disk.base;
-	ulong end = pos + data->pvd.pv_uuidlist_on_disk.size;
+	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;
+	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;
 
 	while (pos < end && num_read < data->vgd.pv_cur) {
-		if (dev_read(data->dev, pos, sizeof(buffer), buffer) !=
-		    sizeof(buffer))
+		if (!dev_read(data->dev, pos, sizeof(buffer), buffer))
 			fail;
 
 		if (!(ul = pool_alloc(data->mem, sizeof(*ul))))
@@ -214,8 +277,8 @@ static inline int _check_lvd(struct lv_disk *lvd)
 
 static int _read_lvs(struct disk_list *data)
 {
-	int i, read = 0;
-	ulong pos;
+	unsigned int i, read = 0;
+	uint64_t pos;
 	struct lvd_list *ll;
 	struct vg_disk *vgd = &data->vgd;
 
@@ -243,12 +306,12 @@ static int _read_extents(struct disk_list *data)
 {
 	size_t len = sizeof(struct pe_disk) * data->pvd.pe_total;
 	struct pe_disk *extents = pool_alloc(data->mem, len);
-	ulong pos = data->pvd.pe_on_disk.base;
+	uint64_t pos = data->pvd.pe_on_disk.base;
 
 	if (!extents)
 		fail;
 
-	if (dev_read(data->dev, pos, len, extents) != len)
+	if (!dev_read(data->dev, pos, len, extents))
 		fail;
 
 	_xlate_extents(extents, data->pvd.pe_total);
@@ -257,31 +320,13 @@ static int _read_extents(struct disk_list *data)
 	return 1;
 }
 
-/* 
- * If exported, remove "PV_EXP" from end of VG name 
- */
-static void _munge_exported_vg(struct disk_list *data)
-{
-	int l, s;
-
-	/* Return if PV not in a VG or VG not exported */
-	if ((!*data->pvd.vg_name) || !(data->vgd.vg_status & VG_EXPORTED))
-		return;
-
-	l = strlen(data->pvd.vg_name);
-	s = sizeof(EXPORTED_TAG);
-	if (!strncmp(data->pvd.vg_name + l - s + 1, EXPORTED_TAG, s))
-		data->pvd.vg_name[l - s + 1] = '\0';
-
-	data->pvd.pv_status |= VG_EXPORTED;
-}
-
-static struct disk_list *__read_disk(struct format_type *fmt,
+static struct disk_list *__read_disk(const struct format_type *fmt,
 				     struct device *dev, struct pool *mem,
 				     const char *vg_name)
 {
 	struct disk_list *dl = pool_alloc(mem, sizeof(*dl));
 	const char *name = dev_name(dev);
+	struct lvmcache_info *info;
 
 	if (!dl) {
 		stack;
@@ -293,11 +338,20 @@ static struct disk_list *__read_disk(struct format_type *fmt,
 	list_init(&dl->uuids);
 	list_init(&dl->lvds);
 
-	if (!read_pvd(dev, &dl->pvd)) {
+	if (!_read_pvd(dev, &dl->pvd)) {
 		stack;
 		goto bad;
 	}
 
+	if (!(info = lvmcache_add(fmt->labeller, dl->pvd.pv_uuid, dev,
+				  dl->pvd.vg_name, NULL)))
+		stack;
+	else {
+		info->device_size = xlate32(dl->pvd.pv_size) << SECTOR_SHIFT;
+		list_init(&info->mdas);
+		info->status &= ~CACHE_INVALID;
+	}
+
 	/*
 	 * is it an orphan ?
 	 */
@@ -305,7 +359,7 @@ static struct disk_list *__read_disk(struct format_type *fmt,
 		log_very_verbose("%s is not a member of any format1 VG", name);
 
 		/* Update VG cache */
-		vgcache_add(dl->pvd.vg_name, NULL, dev, fmt);
+		/* vgcache_add(dl->pvd.vg_name, NULL, dev, fmt); */
 
 		return (vg_name) ? NULL : dl;
 	}
@@ -315,11 +369,8 @@ static struct disk_list *__read_disk(struct format_type *fmt,
 		goto bad;
 	}
 
-	/* If VG is exported, set VG name back to the real name */
-	_munge_exported_vg(dl);
-
 	/* Update VG cache with what we found */
-	vgcache_add(dl->pvd.vg_name, dl->vgd.vg_uuid, dev, fmt);
+	/* vgcache_add(dl->pvd.vg_name, dl->vgd.vg_uuid, dev, fmt); */
 
 	if (vg_name && strcmp(vg_name, dl->pvd.vg_name)) {
 		log_very_verbose("%s is not a member of the VG %s",
@@ -353,12 +404,12 @@ static struct disk_list *__read_disk(struct format_type *fmt,
 	return NULL;
 }
 
-struct disk_list *read_disk(struct format_type *fmt, struct device *dev,
+struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
 			    struct pool *mem, const char *vg_name)
 {
 	struct disk_list *r;
 
-	if (!dev_open(dev, O_RDONLY)) {
+	if (!dev_open(dev)) {
 		stack;
 		return NULL;
 	}
@@ -400,21 +451,22 @@ static void _add_pv_to_list(struct list *head, struct disk_list *data)
  * We keep track of the first object allocated form the pool
  * so we can free off all the memory if something goes wrong.
  */
-int read_pvs_in_vg(struct format_type *fmt, const char *vg_name,
+int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		   struct dev_filter *filter, struct pool *mem,
 		   struct list *head)
 {
 	struct dev_iter *iter;
 	struct device *dev;
 	struct disk_list *data = NULL;
-
-	struct list *pvdh, *pvdh2;
+	struct list *vgih;
+	struct lvmcache_vginfo *vginfo;
 
 	/* Fast path if we already saw this VG and cached the list of PVs */
-	if ((pvdh = vgcache_find(vg_name))) {
-		list_iterate(pvdh2, pvdh) {
-			dev = list_item(pvdh2, struct pvdev_list)->dev;
-			if (!(data = read_disk(fmt, dev, mem, vg_name)))
+	if (vg_name && (vginfo = vginfo_from_vgname(vg_name)) &&
+	    vginfo->infos.n) {
+		list_iterate(vgih, &vginfo->infos) {
+			dev = list_item(vgih, struct lvmcache_info)->dev;
+			if (dev && !(data = read_disk(fmt, dev, mem, vg_name)))
 				break;
 			_add_pv_to_list(head, data);
 		}
@@ -422,11 +474,12 @@ int read_pvs_in_vg(struct format_type *fmt, const char *vg_name,
 		/* Did we find the whole VG? */
 		if (!vg_name || !*vg_name ||
 		    (data && *data->pvd.vg_name &&
-		     list_size(head) == data->vgd.pv_cur)) return 1;
+		     list_size(head) == data->vgd.pv_cur))
+			return 1;
 
-		/* Something changed. Remove the hints. */
+		/* Failed */
 		list_init(head);
-		vgcache_del(vg_name);
+		/* vgcache_del(vg_name); */
 	}
 
 	if (!(iter = dev_iter_create(filter))) {
@@ -451,10 +504,10 @@ int read_pvs_in_vg(struct format_type *fmt, const char *vg_name,
 static int _write_vgd(struct disk_list *data)
 {
 	struct vg_disk *vgd = &data->vgd;
-	ulong pos = data->pvd.vg_on_disk.base;
+	uint64_t pos = data->pvd.vg_on_disk.base;
 
 	_xlate_vgd(vgd);
-	if (dev_write(data->dev, pos, sizeof(*vgd), vgd) != sizeof(*vgd))
+	if (!dev_write(data->dev, pos, sizeof(*vgd), vgd))
 		fail;
 
 	_xlate_vgd(vgd);
@@ -466,8 +519,8 @@ static int _write_uuids(struct disk_list *data)
 {
 	struct uuid_list *ul;
 	struct list *uh;
-	ulong pos = data->pvd.pv_uuidlist_on_disk.base;
-	ulong end = pos + data->pvd.pv_uuidlist_on_disk.size;
+	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;
+	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;
 
 	list_iterate(uh, &data->uuids) {
 		if (pos >= end) {
@@ -477,7 +530,7 @@ static int _write_uuids(struct disk_list *data)
 		}
 
 		ul = list_item(uh, struct uuid_list);
-		if (dev_write(data->dev, pos, NAME_LEN, ul->uuid) != NAME_LEN)
+		if (!dev_write(data->dev, pos, NAME_LEN, ul->uuid))
 			fail;
 
 		pos += NAME_LEN;
@@ -486,10 +539,10 @@ static int _write_uuids(struct disk_list *data)
 	return 1;
 }
 
-static int _write_lvd(struct device *dev, ulong pos, struct lv_disk *disk)
+static int _write_lvd(struct device *dev, uint64_t pos, struct lv_disk *disk)
 {
 	_xlate_lvd(disk);
-	if (dev_write(dev, pos, sizeof(*disk), disk) != sizeof(*disk))
+	if (!dev_write(dev, pos, sizeof(*disk), disk))
 		fail;
 
 	_xlate_lvd(disk);
@@ -500,7 +553,7 @@ static int _write_lvd(struct device *dev, ulong pos, struct lv_disk *disk)
 static int _write_lvs(struct disk_list *data)
 {
 	struct list *lvh;
-	ulong pos, offset;
+	uint64_t pos, offset;
 
 	pos = data->pvd.lv_on_disk.base;
 
@@ -514,8 +567,7 @@ static int _write_lvs(struct disk_list *data)
 		struct lvd_list *ll = list_item(lvh, struct lvd_list);
 
 		offset = sizeof(struct lv_disk) * ll->lvd.lv_number;
-		if (offset + sizeof(struct lv_disk) >
-		    data->pvd.lv_on_disk.size) {
+		if (offset + sizeof(struct lv_disk) > data->pvd.lv_on_disk.size) {
 			log_error("lv_number %d too large", ll->lvd.lv_number);
 			return 0;
 		}
@@ -531,10 +583,10 @@ static int _write_extents(struct disk_list *data)
 {
 	size_t len = sizeof(struct pe_disk) * data->pvd.pe_total;
 	struct pe_disk *extents = data->extents;
-	ulong pos = data->pvd.pe_on_disk.base;
+	uint64_t pos = data->pvd.pe_on_disk.base;
 
 	_xlate_extents(extents, data->pvd.pe_total);
-	if (dev_write(data->dev, pos, len, extents) != len)
+	if (!dev_write(data->dev, pos, len, extents))
 		fail;
 
 	_xlate_extents(extents, data->pvd.pe_total);
@@ -545,8 +597,8 @@ static int _write_extents(struct disk_list *data)
 static int _write_pvd(struct disk_list *data)
 {
 	char *buf;
-	ulong pos = data->pvd.pv_on_disk.base;
-	ulong size = data->pvd.pv_on_disk.size;
+	uint64_t pos = data->pvd.pv_on_disk.base;
+	size_t size = data->pvd.pv_on_disk.size;
 
 	if (size < sizeof(struct pv_disk)) {
 		log_error("Invalid PV structure size.");
@@ -566,7 +618,7 @@ static int _write_pvd(struct disk_list *data)
 	memcpy(buf, &data->pvd, sizeof(struct pv_disk));
 
 	_xlate_pvd((struct pv_disk *) buf);
-	if (dev_write(data->dev, pos, size, buf) != size) {
+	if (!dev_write(data->dev, pos, size, buf)) {
 		dbg_free(buf);
 		fail;
 	}
@@ -578,7 +630,8 @@ static int _write_pvd(struct disk_list *data)
 /*
  * assumes the device has been opened.
  */
-static int __write_all_pvd(struct format_type *fmt, struct disk_list *data)
+static int __write_all_pvd(const struct format_type *fmt,
+			   struct disk_list *data)
 {
 	const char *pv_name = dev_name(data->dev);
 
@@ -587,19 +640,19 @@ static int __write_all_pvd(struct format_type *fmt, struct disk_list *data)
 		return 0;
 	}
 
-	vgcache_add(data->pvd.vg_name, data->vgd.vg_uuid, data->dev, fmt);
+	/* vgcache_add(data->pvd.vg_name, data->vgd.vg_uuid, data->dev, fmt); */
 	/*
 	 * Stop here for orphan pv's.
 	 */
 	if (data->pvd.vg_name[0] == '\0') {
-		if (!test_mode())
-			vgcache_add(data->pvd.vg_name, NULL, data->dev, fmt);
+		/* if (!test_mode())
+		   vgcache_add(data->pvd.vg_name, NULL, data->dev, fmt); */
 		return 1;
 	}
 
-	if (!test_mode())
-		vgcache_add(data->pvd.vg_name, data->vgd.vg_uuid, data->dev,
-			    fmt);
+	/* if (!test_mode())
+	   vgcache_add(data->pvd.vg_name, data->vgd.vg_uuid, data->dev,
+	   fmt); */
 
 	if (!_write_vgd(data)) {
 		log_error("Failed to write VG data to %s", pv_name);
@@ -627,11 +680,11 @@ static int __write_all_pvd(struct format_type *fmt, struct disk_list *data)
 /*
  * opens the device and hands to the above fn.
  */
-static int _write_all_pvd(struct format_type *fmt, struct disk_list *data)
+static int _write_all_pvd(const struct format_type *fmt, struct disk_list *data)
 {
 	int r;
 
-	if (!dev_open(data->dev, O_WRONLY)) {
+	if (!dev_open(data->dev)) {
 		stack;
 		return 0;
 	}
@@ -649,7 +702,7 @@ static int _write_all_pvd(struct format_type *fmt, struct disk_list *data)
  * little sanity checking, so make sure correct
  * data is passed to here.
  */
-int write_disks(struct format_type *fmt, struct list *pvs)
+int write_disks(const struct format_type *fmt, struct list *pvs)
 {
 	struct list *pvh;
 	struct disk_list *dl;

lib/format1/disk-rep.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef DISK_REP_FORMAT1_H
@@ -10,21 +19,20 @@
 #include "lvm-types.h"
 #include "metadata.h"
 #include "pool.h"
-
-
-#define SECTOR_SIZE 512
+#include "toolcontext.h"
 
 #define MAX_PV 256
 #define MAX_LV 256
 #define MAX_VG 99
 
-#define MAX_PV_SIZE	((uint32_t) -1) /* 2TB in sectors - 1 */
-#define MIN_PE_SIZE	(8192L / SECTOR_SIZE)     /* 8 KB in sectors */
-#define MAX_PE_SIZE	(16L * 1024L * 1024L / SECTOR_SIZE * 1024)
-#define PE_SIZE_PV_SIZE_REL 5   /* PV size must be at least 5 times PE size */
-#define	MAX_LE_TOTAL	65534   /* 2^16 - 2 */
-#define	MAX_PE_TOTAL	((uint32_t) -2)
+#define LVM_BLK_MAJOR 58
 
+#define MAX_PV_SIZE	((uint32_t) -1)	/* 2TB in sectors - 1 */
+#define MIN_PE_SIZE	(8192L >> SECTOR_SHIFT)	/* 8 KB in sectors */
+#define MAX_PE_SIZE	(16L * 1024L * (1024L >> SECTOR_SHIFT) * 1024L)
+#define PE_SIZE_PV_SIZE_REL 5	/* PV size must be at least 5 times PE size */
+#define	MAX_LE_TOTAL	65534	/* 2^16 - 2 */
+#define	MAX_PE_TOTAL	((uint32_t) -2)
 
 #define UNMAPPED_EXTENT 0
 
@@ -60,86 +68,84 @@
 #define EXPORTED_TAG "PV_EXP"	/* Identifier for exported PV */
 #define IMPORTED_TAG "PV_IMP"	/* Identifier for imported PV */
 
-
 struct data_area {
 	uint32_t base;
 	uint32_t size;
-};
+} __attribute__ ((packed));
 
 struct pv_disk {
-        uint8_t id[2];
-        uint16_t version;               /* lvm version */
-        struct data_area pv_on_disk;
-        struct data_area vg_on_disk;
-        struct data_area pv_uuidlist_on_disk;
-        struct data_area lv_on_disk;
-        struct data_area pe_on_disk;
-        uint8_t pv_uuid[NAME_LEN];
-        uint8_t vg_name[NAME_LEN];
-        uint8_t system_id[NAME_LEN];    /* for vgexport/vgimport */
-        uint32_t pv_major;
-        uint32_t pv_number;
-        uint32_t pv_status;
-        uint32_t pv_allocatable;
-        uint32_t pv_size;
-        uint32_t lv_cur;
-        uint32_t pe_size;
-        uint32_t pe_total;
-        uint32_t pe_allocated;
+	uint8_t id[2];
+	uint16_t version;	/* lvm version */
+	struct data_area pv_on_disk;
+	struct data_area vg_on_disk;
+	struct data_area pv_uuidlist_on_disk;
+	struct data_area lv_on_disk;
+	struct data_area pe_on_disk;
+	uint8_t pv_uuid[NAME_LEN];
+	uint8_t vg_name[NAME_LEN];
+	uint8_t system_id[NAME_LEN];	/* for vgexport/vgimport */
+	uint32_t pv_major;
+	uint32_t pv_number;
+	uint32_t pv_status;
+	uint32_t pv_allocatable;
+	uint32_t pv_size;
+	uint32_t lv_cur;
+	uint32_t pe_size;
+	uint32_t pe_total;
+	uint32_t pe_allocated;
 
 	/* only present on version == 2 pv's */
 	uint32_t pe_start;
-};
+} __attribute__ ((packed));
 
 struct lv_disk {
-        uint8_t lv_name[NAME_LEN];
-        uint8_t vg_name[NAME_LEN];
-        uint32_t lv_access;
-        uint32_t lv_status;
-        uint32_t lv_open;
-        uint32_t lv_dev;
-        uint32_t lv_number;
-        uint32_t lv_mirror_copies; /* for future use */
-        uint32_t lv_recovery;      /*       "        */
-        uint32_t lv_schedule;      /*       "        */
-        uint32_t lv_size;
-        uint32_t lv_snapshot_minor; /* minor number of original */
-        uint16_t lv_chunk_size;     /* chunk size of snapshot */
-        uint16_t dummy;
-        uint32_t lv_allocated_le;
-        uint32_t lv_stripes;
-        uint32_t lv_stripesize;
-        uint32_t lv_badblock;   /* for future use */
-        uint32_t lv_allocation;
-        uint32_t lv_io_timeout; /* for future use */
-        uint32_t lv_read_ahead;
-};
+	uint8_t lv_name[NAME_LEN];
+	uint8_t vg_name[NAME_LEN];
+	uint32_t lv_access;
+	uint32_t lv_status;
+	uint32_t lv_open;
+	uint32_t lv_dev;
+	uint32_t lv_number;
+	uint32_t lv_mirror_copies;	/* for future use */
+	uint32_t lv_recovery;	/*       "        */
+	uint32_t lv_schedule;	/*       "        */
+	uint32_t lv_size;
+	uint32_t lv_snapshot_minor;	/* minor number of original */
+	uint16_t lv_chunk_size;	/* chunk size of snapshot */
+	uint16_t dummy;
+	uint32_t lv_allocated_le;
+	uint32_t lv_stripes;
+	uint32_t lv_stripesize;
+	uint32_t lv_badblock;	/* for future use */
+	uint32_t lv_allocation;
+	uint32_t lv_io_timeout;	/* for future use */
+	uint32_t lv_read_ahead;
+} __attribute__ ((packed));
 
 struct vg_disk {
-        uint8_t vg_uuid[ID_LEN]; /* volume group UUID */
-        uint8_t vg_name_dummy[NAME_LEN - ID_LEN]; /* rest of v1 VG name */
-        uint32_t vg_number;     /* volume group number */
-        uint32_t vg_access;     /* read/write */
-        uint32_t vg_status;     /* active or not */
-        uint32_t lv_max;	/* maximum logical volumes */
-        uint32_t lv_cur;	/* current logical volumes */
-        uint32_t lv_open;	/* open logical volumes */
-        uint32_t pv_max;	/* maximum physical volumes */
-        uint32_t pv_cur;	/* current physical volumes FU */
-        uint32_t pv_act;	/* active physical volumes */
-        uint32_t dummy;
-        uint32_t vgda;          /* volume group descriptor arrays FU */
-        uint32_t pe_size;	/* physical extent size in sectors */
-        uint32_t pe_total;	/* total of physical extents */
-        uint32_t pe_allocated;  /* allocated physical extents */
-        uint32_t pvg_total;     /* physical volume groups FU */
-};
+	uint8_t vg_uuid[ID_LEN];	/* volume group UUID */
+	uint8_t vg_name_dummy[NAME_LEN - ID_LEN];	/* rest of v1 VG name */
+	uint32_t vg_number;	/* volume group number */
+	uint32_t vg_access;	/* read/write */
+	uint32_t vg_status;	/* active or not */
+	uint32_t lv_max;	/* maximum logical volumes */
+	uint32_t lv_cur;	/* current logical volumes */
+	uint32_t lv_open;	/* open logical volumes */
+	uint32_t pv_max;	/* maximum physical volumes */
+	uint32_t pv_cur;	/* current physical volumes FU */
+	uint32_t pv_act;	/* active physical volumes */
+	uint32_t dummy;
+	uint32_t vgda;		/* volume group descriptor arrays FU */
+	uint32_t pe_size;	/* physical extent size in sectors */
+	uint32_t pe_total;	/* total of physical extents */
+	uint32_t pe_allocated;	/* allocated physical extents */
+	uint32_t pvg_total;	/* physical volume groups FU */
+} __attribute__ ((packed));
 
 struct pe_disk {
 	uint16_t lv_num;
 	uint16_t le_num;
-};
-
+} __attribute__ ((packed));
 
 struct uuid_list {
 	struct list list;
@@ -163,7 +169,6 @@ struct disk_list {
 	struct pe_disk *extents;
 };
 
-
 /*
  * Layout constants.
  */
@@ -173,29 +178,26 @@ struct disk_list {
 #define	PV_SIZE 1024UL
 #define	VG_SIZE 4096UL
 
-
 /*
  * Functions to calculate layout info.
  */
 int calculate_layout(struct disk_list *dl);
-int calculate_extent_count(struct physical_volume *pv);
-
+int calculate_extent_count(struct physical_volume *pv, uint32_t extent_size,
+			   uint32_t max_extent_count, uint64_t pe_start);
 
 /*
  * Low level io routines which read/write
  * disk_lists.
  */
-int read_pvd(struct device *dev, struct pv_disk *pvd);
 
-struct disk_list *read_disk(struct format_type *fmt, struct device *dev,
+struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
 			    struct pool *mem, const char *vg_name);
 
-int read_pvs_in_vg(struct format_type *fmt, const char *vg_name,
+int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		   struct dev_filter *filter,
 		   struct pool *mem, struct list *results);
 
-int write_disks(struct format_type *fmt, struct list *pvds);
-
+int write_disks(const struct format_type *fmt, struct list *pvds);
 
 /*
  * Functions to translate to between disk and in
@@ -204,31 +206,26 @@ int write_disks(struct format_type *fmt, struct list *pvds);
 int import_pv(struct pool *mem, struct device *dev,
 	      struct volume_group *vg,
 	      struct physical_volume *pv, struct pv_disk *pvd);
-int export_pv(struct pool *mem, struct volume_group *vg,
+int export_pv(struct cmd_context *cmd, struct pool *mem,
+	      struct volume_group *vg,
 	      struct pv_disk *pvd, struct physical_volume *pv);
 
 int import_vg(struct pool *mem,
-	      struct volume_group *vg, struct disk_list *dl,
-	      int partial);
+	      struct volume_group *vg, struct disk_list *dl, int partial);
 int export_vg(struct vg_disk *vgd, struct volume_group *vg);
 
-int import_lv(struct pool *mem, struct logical_volume *lv,
-	      struct lv_disk *lvd);
-void export_lv(struct lv_disk *lvd, struct volume_group *vg,
-	       struct logical_volume *lv, const char *dev_dir);
+int import_lv(struct pool *mem, struct logical_volume *lv, struct lv_disk *lvd);
 
-int import_extents(struct pool *mem, struct volume_group *vg,
+int import_extents(struct cmd_context *cmd, struct volume_group *vg,
 		   struct list *pvds);
-int export_extents(struct disk_list *dl, int lv_num,
-		   struct logical_volume *lv,
-		   struct physical_volume *pv);
+int export_extents(struct disk_list *dl, uint32_t lv_num,
+		   struct logical_volume *lv, struct physical_volume *pv);
 
-int import_pvs(struct format_instance *fid, struct pool *mem,
+int import_pvs(const struct format_type *fmt, struct pool *mem,
 	       struct volume_group *vg,
 	       struct list *pvds, struct list *results, int *count);
 
-int import_lvs(struct pool *mem, struct volume_group *vg,
-	       struct list *pvds);
+int import_lvs(struct pool *mem, struct volume_group *vg, struct list *pvds);
 int export_lvs(struct disk_list *dl, struct volume_group *vg,
 	       struct physical_volume *pv, const char *dev_dir);
 
@@ -240,6 +237,7 @@ int export_uuids(struct disk_list *dl, struct volume_group *vg);
 void export_numbers(struct list *pvds, struct volume_group *vg);
 
 void export_pv_act(struct list *pvds);
+int munge_pvd(struct device *dev, struct pv_disk *pvd);
 
 /* blech */
 int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
@@ -247,5 +245,4 @@ int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 int export_vg_number(struct format_instance *fid, struct list *pvds,
 		     const char *vg_name, struct dev_filter *filter);
 
-
 #endif

lib/format1/format1.c

@@ -1,18 +1,31 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "disk-rep.h"
-#include "dbg_malloc.h"
 #include "pool.h"
 #include "hash.h"
 #include "limits.h"
 #include "list.h"
-#include "log.h"
 #include "display.h"
 #include "toolcontext.h"
+#include "lvmcache.h"
+#include "lvm1-label.h"
+#include "format1.h"
+
+#define FMT_LVM1_NAME "lvm1"
 
 /* VG consistency checks */
 static int _check_vgs(struct list *pvs, int *partial)
@@ -21,8 +34,9 @@ static int _check_vgs(struct list *pvs, int *partial)
 	struct disk_list *dl = NULL;
 	struct disk_list *first = NULL;
 
-	int pv_count = 0;
-	int exported = -1;
+	uint32_t pv_count = 0;
+	uint32_t exported = 0;
+	int first_time = 1;
 
 	*partial = 0;
 
@@ -34,8 +48,9 @@ static int _check_vgs(struct list *pvs, int *partial)
 	list_iterate(pvh, pvs) {
 		dl = list_item(pvh, struct disk_list);
 
-		if (exported < 0) {
+		if (first_time) {
 			exported = dl->pvd.pv_status & VG_EXPORTED;
+			first_time = 0;
 			continue;
 		}
 
@@ -60,6 +75,35 @@ static int _check_vgs(struct list *pvs, int *partial)
 		else if (memcmp(&first->vgd, &dl->vgd, sizeof(first->vgd))) {
 			log_error("VG data differs between PVs %s and %s",
 				  dev_name(first->dev), dev_name(dl->dev));
+			log_debug("VG data on %s: %s %s %" PRIu32 " %" PRIu32
+				  "  %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
+				  PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32
+				  " %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
+				  PRIu32 " %" PRIu32 " %" PRIu32,
+				  dev_name(first->dev), first->vgd.vg_uuid,
+				  first->vgd.vg_name_dummy,
+				  first->vgd.vg_number, first->vgd.vg_access,
+				  first->vgd.vg_status, first->vgd.lv_max,
+				  first->vgd.lv_cur, first->vgd.lv_open,
+				  first->vgd.pv_max, first->vgd.pv_cur,
+				  first->vgd.pv_act, first->vgd.dummy,
+				  first->vgd.vgda, first->vgd.pe_size,
+				  first->vgd.pe_total, first->vgd.pe_allocated,
+				  first->vgd.pvg_total);
+			log_debug("VG data on %s: %s %s %" PRIu32 " %" PRIu32
+				  "  %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
+				  PRIu32 " %" PRIu32 " %" PRIu32 " %" PRIu32
+				  " %" PRIu32 " %" PRIu32 " %" PRIu32 " %"
+				  PRIu32 " %" PRIu32 " %" PRIu32,
+				  dev_name(dl->dev), dl->vgd.vg_uuid,
+				  dl->vgd.vg_name_dummy, dl->vgd.vg_number,
+				  dl->vgd.vg_access, dl->vgd.vg_status,
+				  dl->vgd.lv_max, dl->vgd.lv_cur,
+				  dl->vgd.lv_open, dl->vgd.pv_max,
+				  dl->vgd.pv_cur, dl->vgd.pv_act, dl->vgd.dummy,
+				  dl->vgd.vgda, dl->vgd.pe_size,
+				  dl->vgd.pe_total, dl->vgd.pe_allocated,
+				  dl->vgd.pvg_total);
 			list_del(pvh);
 			if (partial_mode()) {
 				*partial = 1;
@@ -71,9 +115,9 @@ static int _check_vgs(struct list *pvs, int *partial)
 	}
 
 	/* On entry to fn, list known to be non-empty */
-	if (pv_count != dl->vgd.pv_cur) {
+	if (pv_count != first->vgd.pv_cur) {
 		log_error("%d PV(s) found for VG %s: expected %d",
-			  pv_count, dl->pvd.vg_name, dl->vgd.pv_cur);
+			  pv_count, first->pvd.vg_name, first->vgd.pv_cur);
 		if (!partial_mode())
 			return 0;
 		*partial = 1;
@@ -104,6 +148,7 @@ static struct volume_group *_build_vg(struct format_instance *fid,
 	list_init(&vg->pvs);
 	list_init(&vg->lvs);
 	list_init(&vg->snapshots);
+	list_init(&vg->tags);
 
 	if (!_check_vgs(pvs, &partial))
 		goto bad;
@@ -113,13 +158,13 @@ static struct volume_group *_build_vg(struct format_instance *fid,
 	if (!import_vg(mem, vg, dl, partial))
 		goto bad;
 
-	if (!import_pvs(fid, mem, vg, pvs, &vg->pvs, &vg->pv_count))
+	if (!import_pvs(fid->fmt, mem, vg, pvs, &vg->pvs, &vg->pv_count))
 		goto bad;
 
 	if (!import_lvs(mem, vg, pvs))
 		goto bad;
 
-	if (!import_extents(mem, vg, pvs))
+	if (!import_extents(fid->fmt->cmd, vg, pvs))
 		goto bad;
 
 	if (!import_snapshots(mem, vg, pvs))
@@ -134,7 +179,8 @@ static struct volume_group *_build_vg(struct format_instance *fid,
 }
 
 static struct volume_group *_vg_read(struct format_instance *fid,
-				     const char *vg_name, void *mda)
+				     const char *vg_name,
+				     struct metadata_area *mda)
 {
 	struct pool *mem = pool_create(1024 * 10);
 	struct list pvs;
@@ -165,7 +211,8 @@ static struct volume_group *_vg_read(struct format_instance *fid,
 	return vg;
 }
 
-static struct disk_list *_flatten_pv(struct pool *mem, struct volume_group *vg,
+static struct disk_list *_flatten_pv(struct format_instance *fid,
+				     struct pool *mem, struct volume_group *vg,
 				     struct physical_volume *pv,
 				     const char *dev_dir)
 {
@@ -182,11 +229,10 @@ static struct disk_list *_flatten_pv(struct pool *mem, struct volume_group *vg,
 	list_init(&dl->uuids);
 	list_init(&dl->lvds);
 
-	if (!export_pv(mem, vg, &dl->pvd, pv) ||
+	if (!export_pv(fid->fmt->cmd, mem, vg, &dl->pvd, pv) ||
 	    !export_vg(&dl->vgd, vg) ||
 	    !export_uuids(dl, vg) ||
-	    !export_lvs(dl, vg, pv, dev_dir) ||
-	    !calculate_layout(dl)) {
+	    !export_lvs(dl, vg, pv, dev_dir) || !calculate_layout(dl)) {
 		stack;
 		pool_free(mem, dl);
 		return NULL;
@@ -207,7 +253,7 @@ static int _flatten_vg(struct format_instance *fid, struct pool *mem,
 	list_iterate(pvh, &vg->pvs) {
 		pvl = list_item(pvh, struct pv_list);
 
-		if (!(data = _flatten_pv(mem, vg, pvl->pv, dev_dir))) {
+		if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir))) {
 			stack;
 			return 0;
 		}
@@ -227,7 +273,7 @@ static int _flatten_vg(struct format_instance *fid, struct pool *mem,
 }
 
 static int _vg_write(struct format_instance *fid, struct volume_group *vg,
-		     void *mdl)
+		     struct metadata_area *mda)
 {
 	struct pool *mem = pool_create(1024 * 10);
 	struct list pvds;
@@ -243,26 +289,28 @@ static int _vg_write(struct format_instance *fid, struct volume_group *vg,
 	r = (_flatten_vg(fid, mem, vg, &pvds, fid->fmt->cmd->dev_dir,
 			 fid->fmt->cmd->filter) &&
 	     write_disks(fid->fmt, &pvds));
+
+	lvmcache_update_vg(vg);
 	pool_destroy(mem);
 	return r;
 }
 
-int _pv_read(struct format_type *fmt, const char *name,
-	     struct physical_volume *pv)
+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 disk_list *dl;
 	struct device *dev;
 	int r = 0;
 
-	log_very_verbose("Reading physical volume data %s from disk", name);
+	log_very_verbose("Reading physical volume data %s from disk", pv_name);
 
 	if (!mem) {
 		stack;
 		return 0;
 	}
 
-	if (!(dev = dev_cache_get(name, fmt->cmd->filter))) {
+	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter))) {
 		stack;
 		goto out;
 	}
@@ -277,7 +325,7 @@ int _pv_read(struct format_type *fmt, const char *name,
 		goto out;
 	}
 
-	pv->fid = fmt->ops->create_instance(fmt, NULL, NULL);
+	pv->fmt = fmt;
 
 	r = 1;
 
@@ -286,144 +334,42 @@ int _pv_read(struct format_type *fmt, const char *name,
 	return r;
 }
 
-static struct list *_get_pvs(struct format_type *fmt, struct list *results)
+static int _pv_setup(const struct format_type *fmt,
+		     uint64_t pe_start, uint32_t extent_count,
+		     uint32_t extent_size,
+		     int pvmetadatacopies,
+		     uint64_t pvmetadatasize, struct list *mdas,
+		     struct physical_volume *pv, struct volume_group *vg)
 {
-	struct pool *mem = pool_create(1024 * 10);
-	struct list pvs;
-	uint32_t count;
-
-	if (!mem) {
-		stack;
-		return NULL;
-	}
-
-	list_init(&pvs);
-
-	if (!read_pvs_in_vg(fmt, NULL, fmt->cmd->filter, mem, &pvs)) {
-		stack;
-		goto bad;
-	}
-
-	if (!import_pvs(NULL, fmt->cmd->mem, NULL, &pvs, results, &count)) {
-		stack;
-		goto bad;
-	}
-
-	pool_destroy(mem);
-	return results;
-
-      bad:
-	pool_destroy(mem);
-	return NULL;
-}
-
-static int _find_vg_name(struct list *names, const char *vg)
-{
-	struct list *nh;
-	struct name_list *nl;
-
-	list_iterate(nh, names) {
-		nl = list_item(nh, struct name_list);
-		if (!strcmp(nl->name, vg))
-			return 1;
-	}
-
-	return 0;
-}
-
-static struct list *_get_vgs(struct format_type *fmt, struct list *names)
-{
-	struct list *pvh;
-	struct list *pvs;
-	struct name_list *nl;
-
-	if (!(pvs = pool_alloc(fmt->cmd->mem, sizeof(*pvs)))) {
-		log_error("PV list allocation failed");
-		goto err;
-	}
-
-	list_init(pvs);
-
-	if (!_get_pvs(fmt, pvs)) {
-		stack;
-		goto err;
-	}
-
-	list_iterate(pvh, pvs) {
-		struct pv_list *pvl = list_item(pvh, struct pv_list);
-
-		if (!(*pvl->pv->vg_name) ||
-		    _find_vg_name(names, pvl->pv->vg_name))
-			continue;
-
-		if (!(nl = pool_alloc(fmt->cmd->mem, sizeof(*nl)))) {
-			stack;
-			goto err;
-		}
-
-		if (!(nl->name = pool_strdup(fmt->cmd->mem, pvl->pv->vg_name))) {
-			stack;
-			goto err;
-		}
-
-		list_add(names, &nl->list);
-	}
-
-	if (list_empty(names))
-		pool_free(fmt->cmd->mem, pvs);
-
-	return names;
-
-      err:
-	pool_free(fmt->cmd->mem, pvs);
-	return NULL;
-}
-
-static int _pv_setup(struct format_instance *fid, struct physical_volume *pv,
-		     struct volume_group *vg)
-{
-	/* setup operations for the PV structure */
 	if (pv->size > MAX_PV_SIZE)
 		pv->size--;
 	if (pv->size > MAX_PV_SIZE) {
-		/* FIXME Limit hardcoded */
-		log_error("Physical volumes cannot be bigger than 2TB");
+		log_error("Physical volumes cannot be bigger than %s",
+			  display_size(fmt->cmd, (uint64_t) MAX_PV_SIZE,
+				       SIZE_SHORT));
 		return 0;
 	}
 
-	/* Nothing more to do if pe_size isn't known */
-	if (!vg)
+	/* Nothing more to do if extent size isn't provided */
+	if (!extent_size)
 		return 1;
 
 	/*
 	 * This works out pe_start and pe_count.
 	 */
-	if (!calculate_extent_count(pv)) {
+	if (!calculate_extent_count(pv, extent_size, extent_count, pe_start)) {
 		stack;
 		return 0;
 	}
 
-	return 1;
-}
-
-static int _find_free_lvnum(struct logical_volume *lv)
-{
-	int lvnum_used[MAX_LV];
-	int i = 0;
-	struct list *lvh;
-	struct lv_list *lvl;
-
-	memset(&lvnum_used, 0, sizeof(lvnum_used));
-
-	list_iterate(lvh, &lv->vg->lvs) {
-		lvl = list_item(lvh, struct lv_list);
-		lvnum_used[lvnum_from_lvid(&lvl->lv->lvid)] = 1;
+	/* Retain existing extent locations exactly */
+	if (((pe_start || extent_count) && (pe_start != pv->pe_start)) ||
+	    (extent_count && (extent_count != pv->pe_count))) {
+		log_error("Metadata would overwrite physical extents");
+		return 0;
 	}
 
-	while (lvnum_used[i])
-		i++;
-
-	return i;
+	return 1;
 }
 
 static int _lv_setup(struct format_instance *fid, struct logical_volume *lv)
@@ -431,7 +377,7 @@ static int _lv_setup(struct format_instance *fid, struct logical_volume *lv)
 	uint64_t max_size = UINT_MAX;
 
 	if (!*lv->lvid.s)
-		lvid_from_lvnum(&lv->lvid, &lv->vg->id, _find_free_lvnum(lv));
+		lvid_from_lvnum(&lv->lvid, &lv->vg->id, find_free_lvnum(lv));
 
 	if (lv->le_count > MAX_LE_TOTAL) {
 		log_error("logical volumes cannot contain more than "
@@ -439,29 +385,36 @@ static int _lv_setup(struct format_instance *fid, struct logical_volume *lv)
 		return 0;
 	}
 	if (lv->size > max_size) {
-		char *dummy = display_size(max_size, SIZE_SHORT);
-		log_error("logical volumes cannot be larger than %s", dummy);
-		dbg_free(dummy);
+		log_error("logical volumes cannot be larger than %s",
+			  display_size(fid->fmt->cmd, max_size,
+				       SIZE_SHORT));
 		return 0;
 	}
 
 	return 1;
 }
 
-static int _pv_write(struct format_instance *fid, struct physical_volume *pv,
-		     void *mdl)
+static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
+		     struct list *mdas, int64_t sector)
 {
 	struct pool *mem;
 	struct disk_list *dl;
 	struct list pvs;
+	struct label *label;
+	struct lvmcache_info *info;
 
-	list_init(&pvs);
-
-	if (*pv->vg_name || pv->pe_alloc_count) {
-		log_error("Assertion failed: can't _pv_write non-orphan PV "
-			  "(in VG %s)", pv->vg_name);
+	if (!(info = lvmcache_add(fmt->labeller, (char *) &pv->id, pv->dev,
+				  pv->vg_name, NULL))) {
+		stack;
 		return 0;
 	}
+	label = info->label;
+	info->device_size = pv->size << SECTOR_SHIFT;
+	info->fmt = fmt;
+
+	list_init(&info->mdas);
+
+	list_init(&pvs);
 
 	/* Ensure any residual PE structure is gone */
 	pv->pe_size = pv->pe_count = 0;
@@ -479,7 +432,7 @@ static int _pv_write(struct format_instance *fid, struct physical_volume *pv,
 	dl->mem = mem;
 	dl->dev = pv->dev;
 
-	if (!export_pv(mem, NULL, &dl->pvd, pv)) {
+	if (!export_pv(fmt->cmd, mem, NULL, &dl->pvd, pv)) {
 		stack;
 		goto bad;
 	}
@@ -488,10 +441,10 @@ static int _pv_write(struct format_instance *fid, struct physical_volume *pv,
 	   dev_write in order to make other disk tools happy */
 	dl->pvd.pv_on_disk.base = METADATA_BASE;
 	dl->pvd.pv_on_disk.size = PV_SIZE;
-	dl->pvd.pe_on_disk.base = PE_ALIGN * SECTOR_SIZE;
+	dl->pvd.pe_on_disk.base = PE_ALIGN << SECTOR_SHIFT;
 
 	list_add(&pvs, &dl->list);
-	if (!write_disks(fid->fmt, &pvs)) {
+	if (!write_disks(fmt, &pvs)) {
 		stack;
 		goto bad;
 	}
@@ -504,32 +457,29 @@ static int _pv_write(struct format_instance *fid, struct physical_volume *pv,
 	return 0;
 }
 
-int _vg_setup(struct format_instance *fid, struct volume_group *vg)
+static int _vg_setup(struct format_instance *fid, struct volume_group *vg)
 {
 	/* just check max_pv and max_lv */
-	if (vg->max_lv >= MAX_LV)
+	if (!vg->max_lv || vg->max_lv >= MAX_LV)
 		vg->max_lv = MAX_LV - 1;
 
-	if (vg->max_pv >= MAX_PV)
+	if (!vg->max_pv || vg->max_pv >= MAX_PV)
 		vg->max_pv = MAX_PV - 1;
 
 	if (vg->extent_size > MAX_PE_SIZE || vg->extent_size < MIN_PE_SIZE) {
-		char *dummy, *dummy2;
-
 		log_error("Extent size must be between %s and %s",
-			  (dummy = display_size(MIN_PE_SIZE / 2, SIZE_SHORT)),
-			  (dummy2 = display_size(MAX_PE_SIZE / 2, SIZE_SHORT)));
+			  display_size(fid->fmt->cmd, (uint64_t) MIN_PE_SIZE,
+				       SIZE_SHORT),
+			  display_size(fid->fmt->cmd, (uint64_t) MAX_PE_SIZE,
+				       SIZE_SHORT));
 
-		dbg_free(dummy);
-		dbg_free(dummy2);
 		return 0;
 	}
 
 	if (vg->extent_size % MIN_PE_SIZE) {
-		char *dummy;
 		log_error("Extent size must be multiple of %s",
-			  (dummy = display_size(MIN_PE_SIZE / 2, SIZE_SHORT)));
-		dbg_free(dummy);
+			  display_size(fid->fmt->cmd, (uint64_t) MIN_PE_SIZE,
+				       SIZE_SHORT));
 		return 0;
 	}
 
@@ -542,8 +492,14 @@ int _vg_setup(struct format_instance *fid, struct volume_group *vg)
 	return 1;
 }
 
-struct format_instance *_create_instance(struct format_type *fmt,
-					 const char *vgname, void *private)
+static struct metadata_area_ops _metadata_format1_ops = {
+	vg_read:_vg_read,
+	vg_write:_vg_write,
+};
+
+static struct format_instance *_create_instance(const struct format_type *fmt,
+						const char *vgname,
+						void *private)
 {
 	struct format_instance *fid;
 	struct metadata_area *mda;
@@ -563,38 +519,40 @@ struct format_instance *_create_instance(struct format_type *fmt,
 		return NULL;
 	}
 
+	mda->ops = &_metadata_format1_ops;
 	mda->metadata_locn = NULL;
 	list_add(&fid->metadata_areas, &mda->list);
 
 	return fid;
 }
 
-void _destroy_instance(struct format_instance *fid)
+static void _destroy_instance(struct format_instance *fid)
 {
 	return;
 }
 
-void _destroy(struct format_type *fmt)
+static void _destroy(const struct format_type *fmt)
 {
-	dbg_free(fmt);
+	dbg_free((void *) fmt);
 }
 
 static struct format_handler _format1_ops = {
-	get_vgs:	_get_vgs,
-	get_pvs:	_get_pvs,
-	pv_read:	_pv_read,
-	pv_setup:	_pv_setup,
-	pv_write:	_pv_write,
-	lv_setup:	_lv_setup,
-	vg_read:	_vg_read,
-	vg_setup:	_vg_setup,
-	vg_write:	_vg_write,
+	pv_read:_pv_read,
+	pv_setup:_pv_setup,
+	pv_write:_pv_write,
+	lv_setup:_lv_setup,
+	vg_setup:_vg_setup,
 	create_instance:_create_instance,
 	destroy_instance:_destroy_instance,
-	destroy:	_destroy,
+	destroy:_destroy,
 };
 
-struct format_type *create_lvm1_format(struct cmd_context *cmd)
+#ifdef LVM1_INTERNAL
+struct format_type *init_lvm1_format(struct cmd_context *cmd)
+#else				/* Shared */
+struct format_type *init_format(struct cmd_context *cmd);
+struct format_type *init_format(struct cmd_context *cmd)
+#endif
 {
 	struct format_type *fmt = dbg_malloc(sizeof(*fmt));
 
@@ -606,8 +564,19 @@ struct format_type *create_lvm1_format(struct cmd_context *cmd)
 	fmt->cmd = cmd;
 	fmt->ops = &_format1_ops;
 	fmt->name = FMT_LVM1_NAME;
-	fmt->features = 0;
+	fmt->alias = NULL;
+	fmt->features = FMT_RESTRICTED_LVIDS | FMT_ORPHAN_ALLOCATABLE;
 	fmt->private = NULL;
 
+	if (!(fmt->labeller = lvm1_labeller_create(fmt))) {
+		log_error("Couldn't create lvm1 label handler.");
+		return NULL;
+	}
+
+	if (!(label_register_handler(FMT_LVM1_NAME, fmt->labeller))) {
+		log_error("Couldn't register lvm1 label handler.");
+		return NULL;
+	}
+
 	return fmt;
 }

lib/format1/format1.h

@@ -1,7 +1,16 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the GPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #ifndef _LVM_FORMAT1_H
@@ -9,6 +18,8 @@
 
 #include "metadata.h"
 
-struct format_type *create_lvm1_format(struct cmd_context *cmd);
+#ifdef LVM1_INTERNAL
+struct format_type *init_lvm1_format(struct cmd_context *cmd);
+#endif
 
 #endif

lib/format1/import-export.c

@@ -1,22 +1,33 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * Translates between disk and in-core formats.
+ * This file is part of LVM2.
  *
- * This file is released under the LGPL.
+ * 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
  */
 
+/*
+ * Translates between disk and in-core formats.
+ */
+
+#include "lib.h"
 #include "disk-rep.h"
-#include "dbg_malloc.h"
 #include "pool.h"
 #include "hash.h"
 #include "list.h"
-#include "log.h"
 #include "lvm-string.h"
+#include "filter.h"
+#include "toolcontext.h"
+#include "segtypes.h"
 
 #include <time.h>
-#include <sys/utsname.h>
-#include <linux/kdev_t.h>
 
 static int _check_vg_name(const char *name)
 {
@@ -77,20 +88,16 @@ int import_pv(struct pool *mem, struct device *dev,
 	pv->pe_count = pvd->pe_total;
 	pv->pe_alloc_count = pvd->pe_allocated;
 
+	list_init(&pv->tags);
+
 	return 1;
 }
 
-int _system_id(char *s, const char *prefix)
+static int _system_id(struct cmd_context *cmd, char *s, const char *prefix)
 {
-	struct utsname uts;
-
-	if (uname(&uts) != 0) {
-		log_sys_error("uname", "_system_id");
-		return 0;
-	}
 
 	if (lvm_snprintf(s, NAME_LEN, "%s%s%lu",
-			 prefix, uts.nodename, time(NULL)) < 0) {
+			 prefix, cmd->hostname, time(NULL)) < 0) {
 		log_error("Generated system_id too long");
 		return 0;
 	}
@@ -98,7 +105,8 @@ int _system_id(char *s, const char *prefix)
 	return 1;
 }
 
-int export_pv(struct pool *mem, struct volume_group *vg,
+int export_pv(struct cmd_context *cmd, struct pool *mem,
+	      struct volume_group *vg,
 	      struct pv_disk *pvd, struct physical_volume *pv)
 {
 	memset(pvd, 0, sizeof(*pvd));
@@ -129,7 +137,7 @@ int export_pv(struct pool *mem, struct volume_group *vg,
 		if (!*vg->system_id ||
 		    strncmp(vg->system_id, EXPORTED_TAG,
 			    sizeof(EXPORTED_TAG) - 1)) {
-			if (!_system_id(pvd->system_id, EXPORTED_TAG)) {
+			if (!_system_id(cmd, pvd->system_id, EXPORTED_TAG)) {
 				stack;
 				return 0;
 			}
@@ -146,7 +154,7 @@ int export_pv(struct pool *mem, struct volume_group *vg,
 	/* Is VG being imported? */
 	if (vg && !(vg->status & EXPORTED_VG) && *vg->system_id &&
 	    !strncmp(vg->system_id, EXPORTED_TAG, sizeof(EXPORTED_TAG) - 1)) {
-		if (!_system_id(pvd->system_id, IMPORTED_TAG)) {
+		if (!_system_id(cmd, pvd->system_id, IMPORTED_TAG)) {
 			stack;
 			return 0;
 		}
@@ -154,7 +162,7 @@ int export_pv(struct pool *mem, struct volume_group *vg,
 
 	/* Generate system_id if PV is in VG */
 	if (!pvd->system_id || !*pvd->system_id)
-		if (!_system_id(pvd->system_id, "")) {
+		if (!_system_id(cmd, pvd->system_id, "")) {
 			stack;
 			return 0;
 		}
@@ -172,7 +180,10 @@ int export_pv(struct pool *mem, struct volume_group *vg,
 
 	pvd->pv_size = pv->size;
 	pvd->lv_cur = 0;	/* this is set when exporting the lv list */
-	pvd->pe_size = pv->pe_size;
+	if (vg)
+		pvd->pe_size = vg->extent_size;
+	else
+		pvd->pe_size = pv->pe_size;
 	pvd->pe_total = pv->pe_count;
 	pvd->pe_allocated = pv->pe_alloc_count;
 	pvd->pe_start = pv->pe_start;
@@ -226,6 +237,7 @@ int import_vg(struct pool *mem,
 	vg->free_count = vgd->pe_total - vgd->pe_allocated;
 	vg->max_lv = vgd->lv_max;
 	vg->max_pv = vgd->pv_max;
+	vg->alloc = ALLOC_NORMAL;
 
 	if (partial)
 		vg->status |= PARTIAL_VG;
@@ -278,14 +290,19 @@ int import_lv(struct pool *mem, struct logical_volume *lv, struct lv_disk *lvd)
 		return 0;
 	}
 
+	lv->status |= VISIBLE_LV;
+
 	if (lvd->lv_status & LV_SPINDOWN)
 		lv->status |= SPINDOWN_LV;
 
 	if (lvd->lv_status & LV_PERSISTENT_MINOR) {
 		lv->status |= FIXED_MINOR;
 		lv->minor = MINOR(lvd->lv_dev);
-	} else
+		lv->major = MAJOR(lvd->lv_dev);
+	} else {
+		lv->major = -1;
 		lv->minor = -1;
+	}
 
 	if (lvd->lv_access & LV_READ)
 		lv->status |= LVM_READ;
@@ -296,32 +313,29 @@ int import_lv(struct pool *mem, struct logical_volume *lv, struct lv_disk *lvd)
 	if (lvd->lv_badblock)
 		lv->status |= BADBLOCK_ON;
 
-	if (lvd->lv_allocation & LV_STRICT)
-		lv->alloc = ALLOC_STRICT;
-
+	/* Drop the unused LV_STRICT here */
 	if (lvd->lv_allocation & LV_CONTIGUOUS)
 		lv->alloc = ALLOC_CONTIGUOUS;
 	else
-		lv->alloc |= ALLOC_NEXT_FREE;
+		lv->alloc = ALLOC_NORMAL;
 
 	lv->read_ahead = lvd->lv_read_ahead;
 	lv->size = lvd->lv_size;
 	lv->le_count = lvd->lv_allocated_le;
 
 	list_init(&lv->segments);
+	list_init(&lv->tags);
 
 	return 1;
 }
 
-void export_lv(struct lv_disk *lvd, struct volume_group *vg,
-	       struct logical_volume *lv, const char *dev_dir)
+static void _export_lv(struct lv_disk *lvd, struct volume_group *vg,
+		       struct logical_volume *lv, const char *dev_dir)
 {
 	memset(lvd, 0, sizeof(*lvd));
 	snprintf(lvd->lv_name, sizeof(lvd->lv_name), "%s%s/%s",
 		 dev_dir, vg->name, lv->name);
 
-	/* FIXME: Add 'if' test */
-	_check_vg_name(vg->name);
 	strcpy(lvd->vg_name, vg->name);
 
 	if (lv->status & LVM_READ)
@@ -335,14 +349,16 @@ void export_lv(struct lv_disk *lvd, struct volume_group *vg,
 
 	if (lv->status & FIXED_MINOR) {
 		lvd->lv_status |= LV_PERSISTENT_MINOR;
-		lvd->lv_dev = MKDEV(0, lv->minor);
+		lvd->lv_dev = MKDEV(lv->major, lv->minor);
+	} else {
+		lvd->lv_dev = MKDEV(LVM_BLK_MAJOR, lvnum_from_lvid(&lv->lvid));
 	}
 
 	lvd->lv_read_ahead = lv->read_ahead;
-	lvd->lv_stripes = list_item(lv->segments.n,
-				    struct stripe_segment)->stripes;
-	lvd->lv_stripesize = list_item(lv->segments.n,
-				       struct stripe_segment)->stripe_size;
+	lvd->lv_stripes =
+	    list_item(lv->segments.n, struct lv_segment)->area_count;
+	lvd->lv_stripesize =
+	    list_item(lv->segments.n, struct lv_segment)->stripe_size;
 
 	lvd->lv_size = lv->size;
 	lvd->lv_allocated_le = lv->le_count;
@@ -350,33 +366,41 @@ void export_lv(struct lv_disk *lvd, struct volume_group *vg,
 	if (lv->status & BADBLOCK_ON)
 		lvd->lv_badblock = LV_BADBLOCK_ON;
 
-	if (lv->alloc == ALLOC_STRICT)
-		lvd->lv_allocation |= LV_STRICT;
-
 	if (lv->alloc == ALLOC_CONTIGUOUS)
 		lvd->lv_allocation |= LV_CONTIGUOUS;
 }
 
-int export_extents(struct disk_list *dl, int lv_num,
+int export_extents(struct disk_list *dl, uint32_t lv_num,
 		   struct logical_volume *lv, struct physical_volume *pv)
 {
 	struct list *segh;
 	struct pe_disk *ped;
-	struct stripe_segment *seg;
+	struct lv_segment *seg;
 	uint32_t pe, s;
 
 	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct stripe_segment);
+		seg = list_item(segh, struct lv_segment);
 
-		for (s = 0; s < seg->stripes; s++) {
-			if (seg->area[s].pv != pv)
+		for (s = 0; s < seg->area_count; s++) {
+			if (!(seg->segtype->flags & SEG_FORMAT1_SUPPORT)) {
+				log_error("Segment type %s in LV %s: "
+					  "unsupported by format1",
+					  seg->segtype->name, lv->name);
+				return 0;
+			}
+			if (seg->area[s].type != AREA_PV) {
+				log_error("LV stripe found in LV %s: "
+					  "unsupported by format1", lv->name);
+				return 0;
+			}
+			if (seg->area[s].u.pv.pv != pv)
 				continue;	/* not our pv */
 
-			for (pe = 0; pe < (seg->len / seg->stripes); pe++) {
-				ped = &dl->extents[pe + seg->area[s].pe];
+			for (pe = 0; pe < (seg->len / seg->area_count); pe++) {
+				ped = &dl->extents[pe + seg->area[s].u.pv.pe];
 				ped->lv_num = lv_num;
-				ped->le_num = (seg->le / seg->stripes) + pe +
-				    s * (lv->le_count / seg->stripes);
+				ped->le_num = (seg->le / seg->area_count) + pe +
+				    s * (lv->le_count / seg->area_count);
 			}
 		}
 	}
@@ -384,7 +408,7 @@ int export_extents(struct disk_list *dl, int lv_num,
 	return 1;
 }
 
-int import_pvs(struct format_instance *fid, struct pool *mem,
+int import_pvs(const struct format_type *fmt, struct pool *mem,
 	       struct volume_group *vg,
 	       struct list *pvds, struct list *results, int *count)
 {
@@ -397,7 +421,7 @@ int import_pvs(struct format_instance *fid, struct pool *mem,
 
 		dl = list_item(pvdh, struct disk_list);
 
-		if (!(pvl = pool_alloc(mem, sizeof(*pvl))) ||
+		if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) ||
 		    !(pvl->pv = pool_alloc(mem, sizeof(*pvl->pv)))) {
 			stack;
 			return 0;
@@ -408,7 +432,7 @@ int import_pvs(struct format_instance *fid, struct pool *mem,
 			return 0;
 		}
 
-		pvl->pv->fid = fid;
+		pvl->pv->fmt = fmt;
 		list_add(results, &pvl->list);
 		(*count)++;
 	}
@@ -474,9 +498,15 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 	struct list *lvh, *sh;
 	struct lv_list *ll;
 	struct lvd_list *lvdl;
-	int lv_num, len;
+	size_t len;
+	uint32_t lv_num;
 	struct hash_table *lvd_hash;
 
+	if (!_check_vg_name(vg->name)) {
+		stack;
+		return 0;
+	}
+
 	if (!(lvd_hash = hash_create(32))) {
 		stack;
 		return 0;
@@ -499,7 +529,7 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 			goto out;
 		}
 
-		export_lv(&lvdl->lvd, vg, ll->lv, dev_dir);
+		_export_lv(&lvdl->lvd, vg, ll->lv, dev_dir);
 
 		lv_num = lvnum_from_lvid(&ll->lv->lvid);
 
@@ -616,7 +646,8 @@ int import_snapshots(struct pool *mem, struct volume_group *vg,
 				continue;
 
 			/* insert the snapshot */
-			if (!vg_add_snapshot(org, cow, 1, lvd->lv_chunk_size)) {
+			if (!vg_add_snapshot(org, cow, 1, NULL,
+					     lvd->lv_chunk_size)) {
 				log_err("Couldn't add snapshot.");
 				return 0;
 			}

lib/format1/import-extents.c

@@ -1,15 +1,26 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "metadata.h"
 #include "hash.h"
-#include "dbg_malloc.h"
-#include "log.h"
 #include "pool.h"
 #include "disk-rep.h"
+#include "lv_alloc.h"
+#include "display.h"
+#include "segtypes.h"
 
 /*
  * After much thought I have decided it is easier,
@@ -192,43 +203,36 @@ static int _check_maps_are_complete(struct hash_table *maps)
 	return 1;
 }
 
-static struct stripe_segment *_alloc_seg(struct pool *mem, uint32_t stripes)
-{
-	struct stripe_segment *seg;
-	uint32_t len = sizeof(*seg) + (stripes * sizeof(seg->area[0]));
-
-	if (!(seg = pool_zalloc(mem, len))) {
-		stack;
-		return NULL;
-	}
-
-	return seg;
-}
-
-static int _read_linear(struct pool *mem, struct lv_map *lvm)
+static int _read_linear(struct cmd_context *cmd, struct lv_map *lvm)
 {
 	uint32_t le = 0;
-	struct stripe_segment *seg;
+	struct lv_segment *seg;
 
 	while (le < lvm->lv->le_count) {
-		seg = _alloc_seg(mem, 1);
+		seg = alloc_lv_segment(cmd->mem, 1);
 
 		seg->lv = lvm->lv;
+		if (!(seg->segtype = get_segtype_from_string(cmd, "striped"))) {
+			stack;
+			return 0;
+		}
+
 		seg->le = le;
 		seg->len = 0;
+		seg->area_len = 0;
 		seg->stripe_size = 0;
-		seg->stripes = 1;
 
-		seg->area[0].pv = lvm->map[le].pv;
-		seg->area[0].pe = lvm->map[le].pe;
+		seg->area[0].type = AREA_PV;
+		seg->area[0].u.pv.pv = lvm->map[le].pv;
+		seg->area[0].u.pv.pe = lvm->map[le].pe;
 
-		do
+		do {
 			seg->len++;
-
-		while ((lvm->map[le + seg->len].pv == seg->area[0].pv) &&
-		       (seg->area[0].pv &&
-			lvm->map[le + seg->len].pe == seg->area[0].pe +
-			seg->len));
+			seg->area_len++;
+		} while ((lvm->map[le + seg->len].pv == seg->area[0].u.pv.pv) &&
+			 (seg->area[0].u.pv.pv &&
+			  lvm->map[le + seg->len].pe == seg->area[0].u.pv.pe +
+			  seg->len));
 
 		le += seg->len;
 
@@ -238,7 +242,7 @@ static int _read_linear(struct pool *mem, struct lv_map *lvm)
 	return 1;
 }
 
-static int _check_stripe(struct lv_map *lvm, struct stripe_segment *seg,
+static int _check_stripe(struct lv_map *lvm, struct lv_segment *seg,
 			 uint32_t base_le, uint32_t len)
 {
 	uint32_t le, st;
@@ -248,19 +252,19 @@ static int _check_stripe(struct lv_map *lvm, struct stripe_segment *seg,
 	/*
 	 * Is the next physical extent in every stripe adjacent to the last?
 	 */
-	for (st = 0; st < seg->stripes; st++)
-		if ((lvm->map[le + st * len].pv != seg->area[st].pv) ||
-		    (seg->area[st].pv &&
-		     lvm->map[le + st * len].pe != seg->area[st].pe + seg->len))
-			return 0;
+	for (st = 0; st < seg->area_count; st++)
+		if ((lvm->map[le + st * len].pv != seg->area[st].u.pv.pv) ||
+		    (seg->area[st].u.pv.pv &&
+		     lvm->map[le + st * len].pe !=
+		     seg->area[st].u.pv.pe + seg->len)) return 0;
 
 	return 1;
 }
 
-static int _read_stripes(struct pool *mem, struct lv_map *lvm)
+static int _read_stripes(struct cmd_context *cmd, struct lv_map *lvm)
 {
 	uint32_t st, le = 0, len;
-	struct stripe_segment *seg;
+	struct lv_segment *seg;
 
 	/*
 	 * Work out overall striped length
@@ -273,34 +277,40 @@ static int _read_stripes(struct pool *mem, struct lv_map *lvm)
 	len = lvm->lv->le_count / lvm->stripes;
 
 	while (le < len) {
-		if (!(seg = _alloc_seg(mem, lvm->stripes))) {
+		if (!(seg = alloc_lv_segment(cmd->mem, lvm->stripes))) {
 			stack;
 			return 0;
 		}
 
 		seg->lv = lvm->lv;
+		if (!(seg->segtype = get_segtype_from_string(cmd, "striped"))) {
+			stack;
+			return 0;
+		}
 		seg->stripe_size = lvm->stripe_size;
-		seg->stripes = lvm->stripes;
-		seg->le = seg->stripes * le;
+		seg->le = seg->area_count * le;
 		seg->len = 1;
+		seg->area_len = 1;
 
 		/*
 		 * Set up start positions of each stripe in this segment
 		 */
-		for (st = 0; st < seg->stripes; st++) {
-			seg->area[st].pv = lvm->map[le + st * len].pv;
-			seg->area[st].pe = lvm->map[le + st * len].pe;
+		for (st = 0; st < seg->area_count; st++) {
+			seg->area[st].u.pv.pv = lvm->map[le + st * len].pv;
+			seg->area[st].u.pv.pe = lvm->map[le + st * len].pe;
 		}
 
 		/* 
 		 * Find how many blocks are contiguous in all stripes
 		 * and so can form part of this segment
 		 */
-		while (_check_stripe(lvm, seg, le, len))
+		while (_check_stripe(lvm, seg, le, len)) {
 			seg->len++;
+			seg->area_len++;
+		}
 
 		le += seg->len;
-		seg->len *= seg->stripes;
+		seg->len *= seg->area_count;
 
 		list_add(&lvm->lv->segments, &seg->list);
 	}
@@ -308,20 +318,20 @@ static int _read_stripes(struct pool *mem, struct lv_map *lvm)
 	return 1;
 }
 
-static int _build_segments(struct pool *mem, struct lv_map *lvm)
+static int _build_segments(struct cmd_context *cmd, struct lv_map *lvm)
 {
-	return (lvm->stripes > 1 ? _read_stripes(mem, lvm) :
-		_read_linear(mem, lvm));
+	return (lvm->stripes > 1 ? _read_stripes(cmd, lvm) :
+		_read_linear(cmd, lvm));
 }
 
-static int _build_all_segments(struct pool *mem, struct hash_table *maps)
+static int _build_all_segments(struct cmd_context *cmd, struct hash_table *maps)
 {
 	struct hash_node *n;
 	struct lv_map *lvm;
 
 	for (n = hash_get_first(maps); n; n = hash_get_next(maps, n)) {
 		lvm = (struct lv_map *) hash_get_data(maps, n);
-		if (!_build_segments(mem, lvm)) {
+		if (!_build_segments(cmd, lvm)) {
 			stack;
 			return 0;
 		}
@@ -330,7 +340,8 @@ static int _build_all_segments(struct pool *mem, struct hash_table *maps)
 	return 1;
 }
 
-int import_extents(struct pool *mem, struct volume_group *vg, struct list *pvds)
+int import_extents(struct cmd_context *cmd, struct volume_group *vg,
+		   struct list *pvds)
 {
 	int r = 0;
 	struct pool *scratch = pool_create(10 * 1024);
@@ -356,7 +367,7 @@ int import_extents(struct pool *mem, struct volume_group *vg, struct list *pvds)
 		goto out;
 	}
 
-	if (!_build_all_segments(mem, maps)) {
+	if (!_build_all_segments(cmd, maps)) {
 		log_err("Couldn't build extent segments.");
 		goto out;
 	}

lib/format1/layout.c

@@ -1,23 +1,31 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "disk-rep.h"
-#include "log.h"
-#include "dbg_malloc.h"
 
 /*
  * Only works with powers of 2.
  */
-static inline ulong _round_up(ulong n, ulong size)
+static inline uint32_t _round_up(uint32_t n, uint32_t size)
 {
 	size--;
 	return (n + size) & ~size;
 }
 
-static inline ulong _div_up(ulong n, ulong size)
+static inline uint32_t _div_up(uint32_t n, uint32_t size)
 {
 	return _round_up(n, size) / size;
 }
@@ -36,7 +44,7 @@ static uint32_t _next_base(struct data_area *area)
  */
 static int _adjust_pe_on_disk(struct pv_disk *pvd)
 {
-	uint32_t pe_start = pvd->pe_start * SECTOR_SIZE;
+	uint32_t pe_start = pvd->pe_start << SECTOR_SHIFT;
 
 	if (pe_start < pvd->pe_on_disk.base + pvd->pe_on_disk.size)
 		return 0;
@@ -63,7 +71,7 @@ static void _calc_simple_layout(struct pv_disk *pvd)
 	pvd->pe_on_disk.size = pvd->pe_total * sizeof(struct pe_disk);
 }
 
-int _check_vg_limits(struct disk_list *dl)
+static int _check_vg_limits(struct disk_list *dl)
 {
 	if (dl->vgd.lv_max > MAX_LV) {
 		log_error("MaxLogicalVolumes of %d exceeds format limit of %d "
@@ -103,11 +111,11 @@ int calculate_layout(struct disk_list *dl)
 }
 
 /*
- * It may seem strange to have a struct physical_volume in here,
- * but the number of extents that can fit on a disk *is* metadata
- * format dependant.
+ * The number of extents that can fit on a disk is metadata format dependant.
+ * pe_start is any existing value for pe_start
  */
-int calculate_extent_count(struct physical_volume *pv)
+int calculate_extent_count(struct physical_volume *pv, uint32_t extent_size,
+			   uint32_t max_extent_count, uint64_t pe_start)
 {
 	struct pv_disk *pvd = dbg_malloc(sizeof(*pvd));
 	uint32_t end;
@@ -122,10 +130,13 @@ int calculate_extent_count(struct physical_volume *pv)
 	 * one is going to be knocked off at the start of the
 	 * next loop.
 	 */
-	pvd->pe_total = (pv->size / pv->pe_size);
+	if (max_extent_count)
+		pvd->pe_total = max_extent_count + 1;
+	else
+		pvd->pe_total = (pv->size / extent_size);
 
 	if (pvd->pe_total < PE_SIZE_PV_SIZE_REL) {
-		log_error("Insufficient space for extents on %s",
+		log_error("Too few extents on %s.  Try smaller extent size.",
 			  dev_name(pv->dev));
 		dbg_free(pvd);
 		return 0;
@@ -135,11 +146,15 @@ int calculate_extent_count(struct physical_volume *pv)
 		pvd->pe_total--;
 		_calc_simple_layout(pvd);
 		end = ((pvd->pe_on_disk.base + pvd->pe_on_disk.size +
-		        SECTOR_SIZE - 1) / SECTOR_SIZE);
+			SECTOR_SIZE - 1) >> SECTOR_SHIFT);
+
+		if (pe_start && end < pe_start)
+			end = pe_start;
 
 		pvd->pe_start = _round_up(end, PE_ALIGN);
 
-	} while ((pvd->pe_start + (pvd->pe_total * pv->pe_size)) > pv->size);
+	} while ((pvd->pe_start + (pvd->pe_total * extent_size))
+		 > pv->size);
 
 	if (pvd->pe_total > MAX_PE_TOTAL) {
 		log_error("Metadata extent limit (%u) exceeded for %s - "
@@ -151,6 +166,7 @@ int calculate_extent_count(struct physical_volume *pv)
 
 	pv->pe_count = pvd->pe_total;
 	pv->pe_start = pvd->pe_start;
+	/* We can't set pe_size here without breaking LVM1 compatibility */
 	dbg_free(pvd);
 	return 1;
 }

lib/format1/lvm1-label.c

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "lvm1-label.h"
+#include "disk-rep.h"
+#include "label.h"
+#include "metadata.h"
+#include "xlate.h"
+#include "lvmcache.h"
+
+#include <sys/stat.h>
+#include <fcntl.h>
+
+static void _not_supported(const char *op)
+{
+	log_err("The '%s' operation is not supported for the lvm1 labeller.",
+		op);
+}
+
+static int _can_handle(struct labeller *l, char *buf, uint64_t sector)
+{
+	struct pv_disk *pvd = (struct pv_disk *) buf;
+	uint32_t version;
+
+	/* LVM1 label must always be in first sector */
+	if (sector)
+		return 0;
+
+	version = xlate16(pvd->version);
+
+	if (pvd->id[0] == 'H' && pvd->id[1] == 'M' &&
+	    (version == 1 || version == 2))
+		return 1;
+
+	return 0;
+}
+
+static int _write(struct label *label, char *buf)
+{
+	_not_supported("write");
+	return 0;
+}
+
+static int _read(struct labeller *l, struct device *dev, char *buf,
+		 struct label **label)
+{
+	struct pv_disk *pvd = (struct pv_disk *) buf;
+	struct lvmcache_info *info;
+
+	munge_pvd(dev, pvd);
+
+	if (!(info = lvmcache_add(l, pvd->pv_uuid, dev, pvd->vg_name, NULL))) {
+		stack;
+		return 0;
+	}
+	*label = info->label;
+
+	info->device_size = xlate32(pvd->pv_size) << SECTOR_SHIFT;
+	list_init(&info->mdas);
+
+	info->status &= ~CACHE_INVALID;
+
+	return 1;
+}
+
+static int _initialise_label(struct labeller *l, struct label *label)
+{
+	strcpy(label->type, "LVM1");
+
+	return 1;
+}
+
+static void _destroy_label(struct labeller *l, struct label *label)
+{
+	return;
+}
+
+static void _destroy(struct labeller *l)
+{
+	dbg_free(l);
+}
+
+struct label_ops _lvm1_ops = {
+	can_handle:_can_handle,
+	write:_write,
+	read:_read,
+	verify:_can_handle,
+	initialise_label:_initialise_label,
+	destroy_label:_destroy_label,
+	destroy:_destroy
+};
+
+struct labeller *lvm1_labeller_create(struct format_type *fmt)
+{
+	struct labeller *l;
+
+	if (!(l = dbg_malloc(sizeof(*l)))) {
+		log_err("Couldn't allocate labeller object.");
+		return NULL;
+	}
+
+	l->ops = &_lvm1_ops;
+	l->private = (const void *) fmt;
+
+	return l;
+}

lib/format1/lvm1-label.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_LVM1_LABEL_H
+#define _LVM_LVM1_LABEL_H
+
+#include "metadata.h"
+
+struct labeller *lvm1_labeller_create(struct format_type *fmt);
+
+#endif

lib/format1/lvm1_label.c

@@ -1,143 +0,0 @@
-/*
- * Copyright (C) 2002 Sistina Software (UK) Limited.
- *
- * This file is released under the LGPL.
- */
-
-#include "lvm1_label.h"
-#include "dbg_malloc.h"
-#include "disk-rep.h"
-#include "log.h"
-#include "label.h"
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-static void _not_supported(const char *op)
-{
-	log_err("The '%s' operation is not supported for the lvm1 labeller.",
-		op);
-}
-
-static int _can_handle(struct labeller *l, struct device *dev)
-{
-	struct pv_disk pvd;
-	int r;
-
-	if (!dev_open(dev, O_RDONLY)) {
-		stack;
-		return 0;
-	}
-
-	r = read_pvd(dev, &pvd);
-
-	if (!dev_close(dev))
-		stack;
-
-	return r;
-}
-
-static int _write(struct labeller *l, struct device *dev, struct label *label)
-{
-	_not_supported("write");
-	return 0;
-}
-
-static int _remove(struct labeller *l, struct device *dev)
-{
-	_not_supported("remove");
-	return 0;
-}
-
-static struct label *_to_label(struct pv_disk *pvd)
-{
-	struct label *l;
-	struct lvm_label_info *info;
-
-	if (!(l = dbg_malloc(sizeof(*l)))) {
-		log_err("Couldn't allocate label.");
-		return NULL;
-	}
-
-	if (!(info = (struct lvm_label_info *) dbg_strdup(pvd->vg_name))) {
-		dbg_free(l);
-		return NULL;
-	}
-
-	memcpy(&l->id, &pvd->pv_uuid, sizeof(l->id));
-	strcpy(l->volume_type, "lvm");
-	l->version[0] = 1;
-	l->version[0] = 0;
-	l->version[0] = 0;
-	l->extra_info = info;
-
-	return l;
-}
-
-static int _read(struct labeller *l, struct device *dev, struct label **label)
-{
-	struct pv_disk pvd;
-	int r = 0;
-
-	if (!dev_open(dev, O_RDONLY)) {
-		stack;
-		return 0;
-	}
-
-	r = read_pvd(dev, &pvd);
-
-	if (!dev_close(dev))
-		stack;
-
-	if (!r) {
-		stack;
-		return 0;
-	}
-
-	/*
-	 * Convert the disk_list into a label structure.
-	 */
-	if (!(*label = _to_label(&pvd))) {
-		stack;
-		return 0;
-	}
-
-	return 1;
-}
-
-static void _destroy_label(struct labeller *l, struct label *label)
-{
-	dbg_free(label->extra_info);
-	dbg_free(label);
-}
-
-static void _destroy(struct labeller *l)
-{
-	dbg_free(l);
-}
-
-struct label_ops _lvm1_ops = {
-	can_handle:	_can_handle,
-	write:		_write,
-	remove:		_remove,
-	read:		_read,
-	verify:		_can_handle,
-	destroy_label:	_destroy_label,
-	destroy:	_destroy
-};
-
-struct labeller *lvm1_labeller_create(void)
-{
-	struct labeller *l;
-
-	if (!(l = dbg_malloc(sizeof(*l)))) {
-		log_err("Couldn't allocate labeller object.");
-		return NULL;
-	}
-
-	l->ops = &_lvm1_ops;
-	l->private = NULL;
-
-	return l;
-}

lib/format1/lvm1_label.h

@@ -1,21 +0,0 @@
-/*
- * Copyright (C) 2002 Sistina Software (UK) Limited.
- *
- * This file is released under the LGPL.
- */
-
-#ifndef _LVM_LVM1_LABEL_H
-#define _LVM_LVM1_LABEL_H
-
-/*
- * This is what the 'extra_info' field of the label will point to
- * if the label type is lvm1.
- */
-struct lvm_label_info {
-	char volume_group[0];
-};
-
-
-struct labeller *lvm1_labeller_create(void);
-
-#endif

lib/format1/vg_number.c

@@ -1,10 +1,19 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "log.h"
+#include "lib.h"
 #include "pool.h"
 #include "disk-rep.h"
 

lib/format_pool/.exported_symbols

@@ -0,0 +1 @@
+init_format

lib/format_pool/Makefile.in

@@ -0,0 +1,37 @@
+#
+# Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.
+# Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+#
+# This file is part of the LVM2.
+#
+# This copyrighted material is made available to anyone wishing to use,
+# modify, copy, or redistribute it subject to the terms and conditions
+# of the GNU General Public License v.2.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+
+SOURCES =\
+	disk_rep.c \
+	format_pool.c \
+	import_export.c \
+	pool_label.c
+
+LIB_SHARED = liblvm2formatpool.so
+
+include ../../make.tmpl
+
+.PHONY: install
+
+install: liblvm2formatpool.so
+	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
+		$(libdir)/liblvm2formatpool.so.$(LIB_VERSION)
+	$(LN_S) -f liblvm2formatpool.so.$(LIB_VERSION) \
+		$(libdir)/liblvm2formatpool.so
+
+

lib/format_pool/disk_rep.c

@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "pool.h"
+#include "label.h"
+#include "metadata.h"
+#include "lvmcache.h"
+#include "filter.h"
+#include "list.h"
+#include "xlate.h"
+
+#include "disk_rep.h"
+
+/* FIXME: memcpy might not be portable */
+#define CPIN_8(x, y, z) {memcpy((x), (y), (z));}
+#define CPOUT_8(x, y, z) {memcpy((y), (x), (z));}
+#define CPIN_16(x, y) {(x) = xlate16_be((y));}
+#define CPOUT_16(x, y) {(y) = xlate16_be((x));}
+#define CPIN_32(x, y) {(x) = xlate32_be((y));}
+#define CPOUT_32(x, y) {(y) = xlate32_be((x));}
+#define CPIN_64(x, y) {(x) = xlate64_be((y));}
+#define CPOUT_64(x, y) {(y) = xlate64_be((x));}
+
+static int __read_pool_disk(const struct format_type *fmt, struct device *dev,
+			    struct pool *mem, struct pool_list *pl,
+			    const char *vg_name)
+{
+	char buf[512];
+
+	/* FIXME: Need to check the cache here first */
+	if (!dev_read(dev, UINT64_C(0), 512, buf)) {
+		log_very_verbose("Failed to read PV data from %s",
+				 dev_name(dev));
+		return 0;
+	}
+
+	if (!read_pool_label(pl, fmt->labeller, dev, buf, NULL)) {
+		stack;
+		return 0;
+	}
+
+	return 1;
+}
+
+static void _add_pl_to_list(struct list *head, struct pool_list *data)
+{
+	struct list *pvdh;
+	struct pool_list *pl;
+
+	list_iterate(pvdh, head) {
+		pl = list_item(pvdh, struct pool_list);
+
+		if (id_equal(&data->pv_uuid, &pl->pv_uuid)) {
+			char uuid[ID_LEN + 7];
+
+			id_write_format(&pl->pv_uuid, uuid, ID_LEN + 7);
+
+			if (MAJOR(data->dev->dev) != md_major()) {
+				log_very_verbose("Ignoring duplicate PV %s on "
+						 "%s", uuid,
+						 dev_name(data->dev));
+				return;
+			}
+			log_very_verbose("Duplicate PV %s - using md %s",
+					 uuid, dev_name(data->dev));
+			list_del(pvdh);
+			break;
+		}
+	}
+	list_add(head, &data->list);
+}
+
+int read_pool_label(struct pool_list *pl, struct labeller *l,
+		    struct device *dev, char *buf, struct label **label)
+{
+	struct lvmcache_info *info;
+	struct id pvid;
+	struct id vgid;
+	char uuid[ID_LEN + 7];
+	struct pool_disk *pd = &pl->pd;
+
+	pool_label_in(pd, buf);
+
+	get_pool_pv_uuid(&pvid, pd);
+	id_write_format(&pvid, uuid, ID_LEN + 7);
+	log_debug("Calculated uuid %s for %s", uuid, dev_name(dev));
+
+	get_pool_vg_uuid(&vgid, pd);
+	id_write_format(&vgid, uuid, ID_LEN + 7);
+	log_debug("Calculated uuid %s for %s", uuid, pd->pl_pool_name);
+
+	if (!(info = lvmcache_add(l, (char *) &pvid, dev, pd->pl_pool_name,
+				  (char *) &vgid))) {
+		stack;
+		return 0;
+	}
+	if (label)
+		*label = info->label;
+
+	info->device_size = xlate32_be(pd->pl_blocks) << SECTOR_SHIFT;
+	list_init(&info->mdas);
+
+	info->status &= ~CACHE_INVALID;
+
+	pl->dev = dev;
+	pl->pv = NULL;
+	memcpy(&pl->pv_uuid, &pvid, sizeof(pvid));
+
+	return 1;
+}
+
+/**
+ * pool_label_out - copies a pool_label_t into a char buffer
+ * @pl: ptr to a pool_label_t struct
+ * @buf: ptr to raw space where label info will be copied
+ *
+ * This function is important because it takes care of all of
+ * the endian issues when copying to disk.  This way, when
+ * machines of different architectures are used, they will
+ * be able to interpret ondisk labels correctly.  Always use
+ * this function before writing to disk.
+ */
+void pool_label_out(struct pool_disk *pl, char *buf)
+{
+	struct pool_disk *bufpl = (struct pool_disk *) buf;
+
+	CPOUT_64(pl->pl_magic, bufpl->pl_magic);
+	CPOUT_64(pl->pl_pool_id, bufpl->pl_pool_id);
+	CPOUT_8(pl->pl_pool_name, bufpl->pl_pool_name, POOL_NAME_SIZE);
+	CPOUT_32(pl->pl_version, bufpl->pl_version);
+	CPOUT_32(pl->pl_subpools, bufpl->pl_subpools);
+	CPOUT_32(pl->pl_sp_id, bufpl->pl_sp_id);
+	CPOUT_32(pl->pl_sp_devs, bufpl->pl_sp_devs);
+	CPOUT_32(pl->pl_sp_devid, bufpl->pl_sp_devid);
+	CPOUT_32(pl->pl_sp_type, bufpl->pl_sp_type);
+	CPOUT_64(pl->pl_blocks, bufpl->pl_blocks);
+	CPOUT_32(pl->pl_striping, bufpl->pl_striping);
+	CPOUT_32(pl->pl_sp_dmepdevs, bufpl->pl_sp_dmepdevs);
+	CPOUT_32(pl->pl_sp_dmepid, bufpl->pl_sp_dmepid);
+	CPOUT_32(pl->pl_sp_weight, bufpl->pl_sp_weight);
+	CPOUT_32(pl->pl_minor, bufpl->pl_minor);
+	CPOUT_32(pl->pl_padding, bufpl->pl_padding);
+	CPOUT_8(pl->pl_reserve, bufpl->pl_reserve, 184);
+}
+
+/**
+ * pool_label_in - copies a char buffer into a pool_label_t
+ * @pl: ptr to a pool_label_t struct
+ * @buf: ptr to raw space where label info is copied from
+ *
+ * This function is important because it takes care of all of
+ * the endian issues when information from disk is about to be
+ * used.  This way, when machines of different architectures
+ * are used, they will be able to interpret ondisk labels
+ * correctly.  Always use this function before using labels that
+ * were read from disk.
+ */
+void pool_label_in(struct pool_disk *pl, char *buf)
+{
+	struct pool_disk *bufpl = (struct pool_disk *) buf;
+
+	CPIN_64(pl->pl_magic, bufpl->pl_magic);
+	CPIN_64(pl->pl_pool_id, bufpl->pl_pool_id);
+	CPIN_8(pl->pl_pool_name, bufpl->pl_pool_name, POOL_NAME_SIZE);
+	CPIN_32(pl->pl_version, bufpl->pl_version);
+	CPIN_32(pl->pl_subpools, bufpl->pl_subpools);
+	CPIN_32(pl->pl_sp_id, bufpl->pl_sp_id);
+	CPIN_32(pl->pl_sp_devs, bufpl->pl_sp_devs);
+	CPIN_32(pl->pl_sp_devid, bufpl->pl_sp_devid);
+	CPIN_32(pl->pl_sp_type, bufpl->pl_sp_type);
+	CPIN_64(pl->pl_blocks, bufpl->pl_blocks);
+	CPIN_32(pl->pl_striping, bufpl->pl_striping);
+	CPIN_32(pl->pl_sp_dmepdevs, bufpl->pl_sp_dmepdevs);
+	CPIN_32(pl->pl_sp_dmepid, bufpl->pl_sp_dmepid);
+	CPIN_32(pl->pl_sp_weight, bufpl->pl_sp_weight);
+	CPIN_32(pl->pl_minor, bufpl->pl_minor);
+	CPIN_32(pl->pl_padding, bufpl->pl_padding);
+	CPIN_8(pl->pl_reserve, bufpl->pl_reserve, 184);
+}
+
+static char _calc_char(unsigned int id)
+{
+	/*
+	 * [0-9A-Za-z!#] - 64 printable chars (6-bits)
+	 */
+
+	if (id < 10)
+		return id + 48;
+	if (id < 36)
+		return (id - 10) + 65;
+	if (id < 62)
+		return (id - 36) + 97;
+	if (id == 62)
+		return '!';
+	if (id == 63)
+		return '#';
+
+	return '%';
+}
+
+void get_pool_uuid(char *uuid, uint64_t poolid, uint32_t spid, uint32_t devid)
+{
+	int i;
+	unsigned shifter = 0x003F;
+
+	assert(ID_LEN == 32);
+	memset(uuid, 0, ID_LEN);
+	strcat(uuid, "POOL0000000000");
+
+	/* We grab the entire 64 bits (+2 that get shifted in) */
+	for (i = 13; i < 24; i++) {
+		uuid[i] = _calc_char(((unsigned) poolid) & shifter);
+		poolid = poolid >> 6;
+	}
+
+	/* We grab the entire 32 bits (+4 that get shifted in) */
+	for (i = 24; i < 30; i++) {
+		uuid[i] = _calc_char((unsigned) (spid & shifter));
+		spid = spid >> 6;
+	}
+
+	/*
+	 * Since we can only have 128 devices, we only worry about the
+	 * last 12 bits
+	 */
+	for (i = 30; i < 32; i++) {
+		uuid[i] = _calc_char((unsigned) (devid & shifter));
+		devid = devid >> 6;
+	}
+
+}
+
+static int _read_vg_pds(const struct format_type *fmt, struct pool *mem,
+			struct lvmcache_vginfo *vginfo, struct list *head,
+			uint32_t *devcount)
+{
+
+	struct list *vgih = NULL;
+	struct device *dev;
+	struct pool_list *pl = NULL;
+	struct pool *tmpmem = NULL;
+
+	uint32_t sp_count = 0;
+	uint32_t *sp_devs = NULL;
+	int i;
+
+	/* FIXME: maybe should return a different error in memory
+	 * allocation failure */
+	if (!(tmpmem = pool_create(512))) {
+		stack;
+		return 0;
+	}
+
+	list_iterate(vgih, &vginfo->infos) {
+		dev = list_item(vgih, struct lvmcache_info)->dev;
+		if (dev &&
+		    !(pl = read_pool_disk(fmt, dev, mem, vginfo->vgname)))
+			    break;
+		/*
+		 * We need to keep track of the total expected number
+		 * of devices per subpool
+		 */
+		if (!sp_count) {
+			sp_count = pl->pd.pl_subpools;
+			if (!(sp_devs =
+			      pool_zalloc(tmpmem,
+					  sizeof(uint32_t) * sp_count))) {
+				log_error("Unable to allocate %d 32-bit uints",
+					  sp_count);
+				pool_destroy(tmpmem);
+				return 0;
+			}
+		}
+		/*
+		 * watch out for a pool label with a different subpool
+		 * count than the original - give up if it does
+		 */
+		if (sp_count != pl->pd.pl_subpools)
+			break;
+
+		_add_pl_to_list(head, pl);
+
+		if (sp_count > pl->pd.pl_sp_id && sp_devs[pl->pd.pl_sp_id] == 0)
+			sp_devs[pl->pd.pl_sp_id] = pl->pd.pl_sp_devs;
+	}
+
+	*devcount = 0;
+	for (i = 0; i < sp_count; i++) {
+		*devcount += sp_devs[i];
+	}
+
+	pool_destroy(tmpmem);
+
+	if (pl && *pl->pd.pl_pool_name)
+		return 1;
+
+	return 0;
+
+}
+
+int read_pool_pds(const struct format_type *fmt, const char *vg_name,
+		  struct pool *mem, struct list *pdhead)
+{
+	struct lvmcache_vginfo *vginfo;
+	uint32_t totaldevs;
+	int full_scan = -1;
+
+	do {
+		/*
+		 * If the cache scanning doesn't work, this will never work
+		 */
+		if (vg_name && (vginfo = vginfo_from_vgname(vg_name)) &&
+		    vginfo->infos.n) {
+
+			if (_read_vg_pds(fmt, mem, vginfo, pdhead, &totaldevs)) {
+				/*
+				 * If we found all the devices we were
+				 * expecting, return success
+				 */
+				if (list_size(pdhead) == totaldevs)
+					return 1;
+
+				/*
+				 * accept partial pool if we've done a full
+				 * rescan of the cache
+				 */
+				if (full_scan > 0)
+					return 1;
+			}
+		}
+		/* Failed */
+		list_init(pdhead);
+
+		full_scan++;
+		if (full_scan > 1) {
+			log_debug("No devices for vg %s found in cache",
+				  vg_name);
+			return 0;
+		}
+		lvmcache_label_scan(fmt->cmd, full_scan);
+
+	} while (1);
+
+}
+
+struct pool_list *read_pool_disk(const struct format_type *fmt,
+				 struct device *dev, struct pool *mem,
+				 const char *vg_name)
+{
+	struct pool_list *pl;
+
+	if (!dev_open(dev)) {
+		stack;
+		return NULL;
+	}
+
+	if (!(pl = pool_zalloc(mem, sizeof(*pl)))) {
+		log_error("Unable to allocate pool list structure");
+		return 0;
+	}
+
+	if (!__read_pool_disk(fmt, dev, mem, pl, vg_name)) {
+		stack;
+		return NULL;
+	}
+
+	if (!dev_close(dev))
+		stack;
+
+	return pl;
+
+}

lib/format_pool/disk_rep.h

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef DISK_REP_FORMAT_POOL_H
+#define DISK_REP_FORMAT_POOL_H
+
+#include "label.h"
+#include "metadata.h"
+#include "pool.h"
+
+/* From NSP.cf */
+#define NSPMajorVersion	4
+#define NSPMinorVersion	1
+#define NSPUpdateLevel	3
+
+/* From pool_std.h */
+#define POOL_NAME_SIZE          (256)
+#define POOL_MAGIC 		0x011670
+#define POOL_MAJOR              (121)
+#define POOL_MAX_DEVICES 	128
+
+/* When checking for version matching, the first two numbers **
+** are important for metadata formats, a.k.a pool labels.   **
+** All the numbers are important when checking if the user  **
+** space tools match up with the kernel module............. */
+#define POOL_VERSION		(NSPMajorVersion << 16 | \
+				 NSPMinorVersion <<  8 | \
+				 NSPUpdateLevel)
+
+/* Pool label is at the head of every pool disk partition */
+#define SIZEOF_POOL_LABEL       (8192)
+
+/* in sectors */
+#define POOL_PE_SIZE     (SIZEOF_POOL_LABEL >> SECTOR_SHIFT)
+#define POOL_PE_START    (SIZEOF_POOL_LABEL >> SECTOR_SHIFT)
+
+/* Helper fxns */
+#define get_pool_vg_uuid(id, pd) do { get_pool_uuid((char *)(id), \
+                                                    (pd)->pl_pool_id, 0, 0); \
+                                    } while(0)
+#define get_pool_pv_uuid(id, pd) do { get_pool_uuid((char *)(id), \
+                                                    (pd)->pl_pool_id, \
+                                                    (pd)->pl_sp_id, \
+                                                    (pd)->pl_sp_devid); \
+                                    } while(0)
+#define get_pool_lv_uuid(id, pd) do { get_pool_uuid((char *)&(id)[0], \
+                                                    (pd)->pl_pool_id, 0, 0); \
+                                      get_pool_uuid((char*)&(id)[1], \
+                                                    (pd)->pl_pool_id, 0, 0); \
+                                    } while(0)
+
+struct pool_disk;
+struct pool_list;
+struct user_subpool;
+struct user_device;
+
+/* This must be kept up to date with sistina/pool/module/pool_sptypes.h */
+
+/*  Generic Labels  */
+#define SPTYPE_DATA                (0x00000000)
+
+/*  GFS specific labels  */
+#define SPTYPE_GFS_DATA            (0x68011670)
+#define SPTYPE_GFS_JOURNAL         (0x69011670)
+
+struct sptype_name {
+	const char *name;
+	uint32_t label;
+};
+
+static const struct sptype_name sptype_names[] = {
+	{"data",	SPTYPE_DATA},
+
+	{"gfs_data",	SPTYPE_GFS_DATA},
+	{"gfs_journal",	SPTYPE_GFS_JOURNAL},
+
+	{"", 0x0}		/*  This must be the last flag.  */
+};
+
+struct pool_disk {
+	uint64_t pl_magic;	/* Pool magic number */
+	uint64_t pl_pool_id;	/* Unique pool identifier */
+	char pl_pool_name[POOL_NAME_SIZE];	/* Name of pool */
+	uint32_t pl_version;	/* Pool version */
+	uint32_t pl_subpools;	/* Number of subpools in this pool */
+	uint32_t pl_sp_id;	/* Subpool number within pool */
+	uint32_t pl_sp_devs;	/* Number of data partitions in this subpool */
+	uint32_t pl_sp_devid;	/* Partition number within subpool */
+	uint32_t pl_sp_type;	/* Partition type */
+	uint64_t pl_blocks;	/* Number of blocks in this partition */
+	uint32_t pl_striping;	/* Striping size within subpool */
+	/*
+	 * If the number of DMEP devices is zero, then the next field **
+	 * ** (pl_sp_dmepid) becomes the subpool ID for redirection.  In **
+	 * ** other words, if this subpool does not have the capability  **
+	 * ** to do DMEP, then it must specify which subpool will do it  **
+	 * ** in it's place
+	 */
+
+	/*
+	 * While the next 3 field are no longer used, they must stay to keep **
+	 * ** backward compatibility...........................................
+	 */
+	uint32_t pl_sp_dmepdevs;/* Number of dmep devices in this subpool */
+	uint32_t pl_sp_dmepid;	/* Dmep device number within subpool */
+	uint32_t pl_sp_weight;	/* if dmep dev, pref to using it */
+
+	uint32_t pl_minor;	/* the pool minor number */
+	uint32_t pl_padding;	/* reminder - think about alignment */
+
+	/*
+	 * Even though we're zeroing out 8k at the front of the disk before
+	 * writing the label, putting this in
+	 */
+	char pl_reserve[184];	/* bump the structure size out to 512 bytes */
+};
+
+struct pool_list {
+	struct list list;
+	struct pool_disk pd;
+	struct physical_volume *pv;
+	struct id pv_uuid;
+	struct device *dev;
+};
+
+struct user_subpool {
+	uint32_t initialized;
+	uint32_t id;
+	uint32_t striping;
+	uint32_t num_devs;
+	uint32_t type;
+	uint32_t dummy;
+	struct user_device *devs;
+};
+
+struct user_device {
+	uint32_t initialized;
+	uint32_t sp_id;
+	uint32_t devid;
+	uint32_t dummy;
+	uint64_t blocks;
+	struct physical_volume *pv;
+};
+
+int read_pool_label(struct pool_list *pl, struct labeller *l,
+		    struct device *dev, char *buf, struct label **label);
+void pool_label_out(struct pool_disk *pl, char *buf);
+void pool_label_in(struct pool_disk *pl, char *buf);
+void get_pool_uuid(char *uuid, uint64_t poolid, uint32_t spid, uint32_t devid);
+int import_pool_vg(struct volume_group *vg, struct pool *mem, struct list *pls);
+int import_pool_lvs(struct volume_group *vg, struct pool *mem,
+		    struct list *pls);
+int import_pool_pvs(const struct format_type *fmt, struct volume_group *vg,
+		    struct list *pvs, struct pool *mem, struct list *pls);
+int import_pool_pv(const struct format_type *fmt, struct pool *mem,
+		   struct volume_group *vg, struct physical_volume *pv,
+		   struct pool_list *pl);
+int import_pool_segments(struct list *lvs, struct pool *mem,
+			 struct user_subpool *usp, int sp_count);
+int read_pool_pds(const struct format_type *fmt, const char *vgname,
+		  struct pool *mem, struct list *head);
+struct pool_list *read_pool_disk(const struct format_type *fmt,
+				 struct device *dev, struct pool *mem,
+				 const char *vg_name);
+
+#endif				/* DISK_REP_POOL_FORMAT_H */

lib/format_pool/format_pool.c

@@ -0,0 +1,361 @@
+/*
+ * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "pool.h"
+#include "label.h"
+#include "metadata.h"
+#include "hash.h"
+#include "limits.h"
+#include "list.h"
+#include "display.h"
+#include "toolcontext.h"
+#include "lvmcache.h"
+#include "disk_rep.h"
+#include "format_pool.h"
+#include "pool_label.h"
+
+#define FMT_POOL_NAME "pool"
+
+/* Must be called after pvs are imported */
+static struct user_subpool *_build_usp(struct list *pls, struct pool *mem,
+				       int *sps)
+{
+
+	struct list *plhs;
+	struct pool_list *pl;
+	struct user_subpool *usp = NULL, *cur_sp = NULL;
+	struct user_device *cur_dev = NULL;
+
+	/*
+	 * FIXME: Need to do some checks here - I'm tempted to add a
+	 * user_pool structure and build the entire thing to check against.
+	 */
+	list_iterate(plhs, pls) {
+		pl = list_item(plhs, struct pool_list);
+
+		*sps = pl->pd.pl_subpools;
+		if (!usp && (!(usp = pool_zalloc(mem, sizeof(*usp) * (*sps))))) {
+			log_error("Unable to allocate %d subpool structures",
+				  *sps);
+			return 0;
+		}
+
+		if (cur_sp != &usp[pl->pd.pl_sp_id]) {
+			cur_sp = &usp[pl->pd.pl_sp_id];
+
+			cur_sp->id = pl->pd.pl_sp_id;
+			cur_sp->striping = pl->pd.pl_striping;
+			cur_sp->num_devs = pl->pd.pl_sp_devs;
+			cur_sp->type = pl->pd.pl_sp_type;
+			cur_sp->initialized = 1;
+		}
+
+		if (!cur_sp->devs &&
+		    (!(cur_sp->devs =
+		       pool_zalloc(mem,
+				   sizeof(*usp->devs) * pl->pd.pl_sp_devs)))) {
+
+			log_error("Unable to allocate %d pool_device "
+				  "structures", pl->pd.pl_sp_devs);
+			return 0;
+		}
+		cur_dev = &cur_sp->devs[pl->pd.pl_sp_devid];
+		cur_dev->sp_id = cur_sp->id;
+		cur_dev->devid = pl->pd.pl_sp_id;
+		cur_dev->blocks = pl->pd.pl_blocks;
+		cur_dev->pv = pl->pv;
+		cur_dev->initialized = 1;
+
+	}
+
+	return usp;
+}
+
+static int _check_usp(char *vgname, struct user_subpool *usp, int sp_count)
+{
+	int i, j;
+
+	for (i = 0; i < sp_count; i++) {
+		if (!usp[i].initialized) {
+			log_error("Missing subpool %d in pool %s", i, vgname);
+			return 0;
+		}
+		for (j = 0; j < usp[i].num_devs; j++) {
+			if (!usp[i].devs[j].initialized) {
+				log_error("Missing device %d for subpool %d"
+					  " in pool %s", j, i, vgname);
+				return 0;
+			}
+
+		}
+	}
+
+	return 1;
+}
+
+static struct volume_group *_build_vg_from_pds(struct format_instance
+					       *fid, struct pool *mem,
+					       struct list *pds)
+{
+	struct pool *smem = fid->fmt->cmd->mem;
+	struct volume_group *vg = NULL;
+	struct user_subpool *usp = NULL;
+	int sp_count;
+
+	if (!(vg = pool_zalloc(smem, sizeof(*vg)))) {
+		log_error("Unable to allocate volume group structure");
+		return NULL;
+	}
+
+	vg->cmd = fid->fmt->cmd;
+	vg->fid = fid;
+	vg->name = NULL;
+	vg->status = 0;
+	vg->extent_count = 0;
+	vg->pv_count = 0;
+	vg->lv_count = 0;
+	vg->snapshot_count = 0;
+	vg->seqno = 1;
+	vg->system_id = NULL;
+	list_init(&vg->pvs);
+	list_init(&vg->lvs);
+	list_init(&vg->snapshots);
+	list_init(&vg->tags);
+
+	if (!import_pool_vg(vg, smem, pds)) {
+		stack;
+		return NULL;
+	}
+
+	if (!import_pool_pvs(fid->fmt, vg, &vg->pvs, smem, pds)) {
+		stack;
+		return NULL;
+	}
+
+	if (!import_pool_lvs(vg, smem, pds)) {
+		stack;
+		return NULL;
+	}
+
+	/*
+	 * I need an intermediate subpool structure that contains all the
+	 * relevant info for this.  Then i can iterate through the subpool
+	 * structures for checking, and create the segments
+	 */
+	if (!(usp = _build_usp(pds, mem, &sp_count))) {
+		stack;
+		return NULL;
+	}
+
+	/*
+	 * check the subpool structures - we can't handle partial VGs in
+	 * the pool format, so this will error out if we're missing PVs
+	 */
+	if (!_check_usp(vg->name, usp, sp_count)) {
+		stack;
+		return NULL;
+	}
+
+	if (!import_pool_segments(&vg->lvs, smem, usp, sp_count)) {
+		stack;
+		return NULL;
+	}
+
+	return vg;
+}
+
+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 list pds;
+	struct volume_group *vg = NULL;
+
+	list_init(&pds);
+
+	/* We can safely ignore the mda passed in */
+
+	if (!mem) {
+		stack;
+		return NULL;
+	}
+
+	/* Strip dev_dir if present */
+	vg_name = strip_dir(vg_name, fid->fmt->cmd->dev_dir);
+
+	/* Read all the pvs in the vg */
+	if (!read_pool_pds(fid->fmt, vg_name, mem, &pds)) {
+		stack;
+		goto out;
+	}
+
+	/* Do the rest of the vg stuff */
+	if (!(vg = _build_vg_from_pds(fid, mem, &pds))) {
+		stack;
+		goto out;
+	}
+
+      out:
+	pool_destroy(mem);
+	return vg;
+}
+
+static int _pv_setup(const struct format_type *fmt,
+		     uint64_t pe_start, uint32_t extent_count,
+		     uint32_t extent_size,
+		     int pvmetadatacopies,
+		     uint64_t pvmetadatasize, struct list *mdas,
+		     struct physical_volume *pv, struct volume_group *vg)
+{
+	return 1;
+}
+
+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_list *pl;
+	struct device *dev;
+	int r = 0;
+
+	log_very_verbose("Reading physical volume data %s from disk", pv_name);
+
+	if (!mem) {
+		stack;
+		return 0;
+	}
+
+	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter))) {
+		stack;
+		goto out;
+	}
+
+	/*
+	 * I need to read the disk and populate a pv structure here
+	 * I'll probably need to abstract some of this later for the
+	 * vg_read code
+	 */
+	if (!(pl = read_pool_disk(fmt, dev, mem, NULL))) {
+		stack;
+		goto out;
+	}
+
+	if (!import_pool_pv(fmt, fmt->cmd->mem, NULL, pv, pl)) {
+		stack;
+		goto out;
+	}
+
+	pv->fmt = fmt;
+
+	r = 1;
+
+      out:
+	pool_destroy(mem);
+	return r;
+}
+
+/* *INDENT-OFF* */
+static struct metadata_area_ops _metadata_format_pool_ops = {
+	vg_read:_vg_read,
+};
+/* *INDENT-ON* */
+
+static struct format_instance *_create_instance(const struct format_type *fmt,
+						const char *vgname,
+						void *private)
+{
+	struct format_instance *fid;
+	struct metadata_area *mda;
+
+	if (!(fid = pool_zalloc(fmt->cmd->mem, sizeof(*fid)))) {
+		log_error("Unable to allocate format instance structure for "
+			  "pool format");
+		return NULL;
+	}
+
+	fid->fmt = fmt;
+	list_init(&fid->metadata_areas);
+
+	/* Define a NULL metadata area */
+	if (!(mda = pool_zalloc(fmt->cmd->mem, sizeof(*mda)))) {
+		log_error("Unable to allocate metadata area structure "
+			  "for pool format");
+		pool_free(fmt->cmd->mem, fid);
+		return NULL;
+	}
+
+	mda->ops = &_metadata_format_pool_ops;
+	mda->metadata_locn = NULL;
+	list_add(&fid->metadata_areas, &mda->list);
+
+	return fid;
+}
+
+static void _destroy_instance(struct format_instance *fid)
+{
+	return;
+}
+
+static void _destroy(const struct format_type *fmt)
+{
+	dbg_free((void *) fmt);
+}
+
+/* *INDENT-OFF* */
+static struct format_handler _format_pool_ops = {
+	pv_read:_pv_read,
+	pv_setup:_pv_setup,
+	create_instance:_create_instance,
+	destroy_instance:_destroy_instance,
+	destroy:_destroy,
+};
+/* *INDENT-ON */
+
+#ifdef POOL_INTERNAL
+struct format_type *init_pool_format(struct cmd_context *cmd)
+#else				/* Shared */
+struct format_type *init_format(struct cmd_context *cmd);
+struct format_type *init_format(struct cmd_context *cmd)
+#endif
+{
+	struct format_type *fmt = dbg_malloc(sizeof(*fmt));
+
+	if (!fmt) {
+		log_error("Unable to allocate format type structure for pool "
+			  "format");
+		return NULL;
+	}
+
+	fmt->cmd = cmd;
+	fmt->ops = &_format_pool_ops;
+	fmt->name = FMT_POOL_NAME;
+	fmt->alias = NULL;
+	fmt->features = 0;
+	fmt->private = NULL;
+
+	if (!(fmt->labeller = pool_labeller_create(fmt))) {
+		log_error("Couldn't create pool label handler.");
+		return NULL;
+	}
+
+	if (!(label_register_handler(FMT_POOL_NAME, fmt->labeller))) {
+		log_error("Couldn't register pool label handler.");
+		return NULL;
+	}
+
+	return fmt;
+}

lib/format_pool/format_pool.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_FORMAT_POOL_H
+#define _LVM_FORMAT_POOL_H
+
+#include "metadata.h"
+
+#ifdef POOL_INTERNAL
+struct format_type *init_pool_format(struct cmd_context *cmd);
+#endif
+
+#endif

lib/format_pool/import_export.c

@@ -0,0 +1,309 @@
+/*
+ * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "pool.h"
+#include "label.h"
+#include "metadata.h"
+#include "lvmcache.h"
+#include "disk_rep.h"
+#include "lv_alloc.h"
+#include "str_list.h"
+#include "display.h"
+#include "segtypes.h"
+
+/* This file contains only imports at the moment... */
+
+int import_pool_vg(struct volume_group *vg, struct pool *mem, struct list *pls)
+{
+	struct list *plhs;
+	struct pool_list *pl;
+
+	list_iterate(plhs, pls) {
+		pl = list_item(plhs, struct pool_list);
+
+		vg->extent_count +=
+		    ((pl->pd.pl_blocks) / POOL_PE_SIZE);
+
+		vg->pv_count++;
+
+		if (vg->name)
+			continue;
+
+		vg->name = pool_strdup(mem, pl->pd.pl_pool_name);
+		get_pool_vg_uuid(&vg->id, &pl->pd);
+		vg->extent_size = POOL_PE_SIZE;
+		vg->status |= LVM_READ | LVM_WRITE | CLUSTERED | SHARED;
+		vg->free_count = 0;
+		vg->max_lv = 1;
+		vg->max_pv = POOL_MAX_DEVICES;
+		vg->alloc = ALLOC_NORMAL;
+		vg->lv_count = 0;
+	}
+
+	return 1;
+}
+
+int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
+{
+	struct pool_list *pl;
+	struct list *plhs;
+	struct lv_list *lvl = pool_zalloc(mem, sizeof(*lvl));
+	struct logical_volume *lv;
+
+	if (!lvl) {
+		log_error("Unable to allocate lv list structure");
+		return 0;
+	}
+
+	if (!(lvl->lv = pool_zalloc(mem, sizeof(*lvl->lv)))) {
+		log_error("Unable to allocate logical volume structure");
+		return 0;
+	}
+
+	lv = lvl->lv;
+	lv->status = 0;
+	lv->vg = vg;
+	lv->alloc = ALLOC_NORMAL;
+	lv->size = 0;
+	lv->name = NULL;
+	lv->le_count = 0;
+	lv->read_ahead = 0;
+	list_init(&lv->segments);
+	list_init(&lv->tags);
+
+	list_iterate(plhs, pls) {
+		pl = list_item(plhs, struct pool_list);
+
+		lv->size += pl->pd.pl_blocks;
+
+		if (lv->name)
+			continue;
+
+		if (!(lv->name = pool_strdup(mem, pl->pd.pl_pool_name))) {
+			stack;
+			return 0;
+		}
+
+		get_pool_lv_uuid(lv->lvid.id, &pl->pd);
+		log_debug("Calculated lv uuid for lv %s: %s", lv->name,
+			  lv->lvid.s);
+
+		lv->status |= VISIBLE_LV | LVM_READ | LVM_WRITE;
+		lv->major = POOL_MAJOR;
+
+		/* for pool a minor of 0 is dynamic */
+		if (pl->pd.pl_minor) {
+			lv->status |= FIXED_MINOR;
+			lv->minor = pl->pd.pl_minor;
+		} else {
+			lv->minor = -1;
+		}
+		list_init(&lv->segments);
+		list_init(&lv->tags);
+	}
+
+	lv->le_count = lv->size / POOL_PE_SIZE;
+	lvl->lv = lv;
+	list_add(&vg->lvs, &lvl->list);
+	vg->lv_count++;
+
+	return 1;
+}
+
+int import_pool_pvs(const struct format_type *fmt, struct volume_group *vg,
+		    struct list *pvs, struct pool *mem, struct list *pls)
+{
+	struct pv_list *pvl;
+	struct pool_list *pl;
+	struct list *plhs;
+
+	list_iterate(plhs, pls) {
+		pl = list_item(plhs, struct pool_list);
+
+		if (!(pvl = pool_zalloc(mem, sizeof(*pvl)))) {
+			log_error("Unable to allocate pv list structure");
+			return 0;
+		}
+		if (!(pvl->pv = pool_zalloc(mem, sizeof(*pvl->pv)))) {
+			log_error("Unable to allocate pv structure");
+			return 0;
+		}
+		if (!import_pool_pv(fmt, mem, vg, pvl->pv, pl)) {
+			return 0;
+		}
+		pl->pv = pvl->pv;
+		pvl->mdas = NULL;
+		pvl->alloc_areas = NULL;
+		list_add(pvs, &pvl->list);
+	}
+
+	return 1;
+}
+
+int import_pool_pv(const struct format_type *fmt, struct pool *mem,
+		   struct volume_group *vg, struct physical_volume *pv,
+		   struct pool_list *pl)
+{
+	struct pool_disk *pd = &pl->pd;
+
+	memset(pv, 0, sizeof(*pv));
+
+	get_pool_pv_uuid(&pv->id, pd);
+	pv->fmt = fmt;
+
+	pv->dev = pl->dev;
+	if (!(pv->vg_name = pool_strdup(mem, pd->pl_pool_name))) {
+		log_error("Unable to duplicate vg_name string");
+		return 0;
+	}
+	pv->status = 0;
+	pv->size = pd->pl_blocks;
+	pv->pe_size = POOL_PE_SIZE;
+	pv->pe_start = POOL_PE_START;
+	pv->pe_count = pv->size / POOL_PE_SIZE;
+	pv->pe_alloc_count = pv->pe_count;
+
+	list_init(&pv->tags);
+
+	return 1;
+}
+
+static const char *_cvt_sptype(uint32_t sptype)
+{
+	int i;
+	for (i = 0; sptype_names[i].name[0]; i++) {
+		if (sptype == sptype_names[i].label) {
+			break;
+		}
+	}
+	log_debug("Found sptype %X and converted it to %s",
+		  sptype, sptype_names[i].name);
+	return sptype_names[i].name;
+}
+
+static int _add_stripe_seg(struct pool *mem,
+			   struct user_subpool *usp, struct logical_volume *lv,
+			   uint32_t *le_cur)
+{
+	struct lv_segment *seg;
+	int j;
+
+	if (!(seg = alloc_lv_segment(mem, usp->num_devs))) {
+		log_error("Unable to allocate striped lv_segment structure");
+		return 0;
+	}
+	if(usp->striping & (usp->striping - 1)) {
+		log_error("Stripe size must be a power of 2");
+		return 0;
+	}
+	seg->stripe_size = usp->striping;
+	seg->status |= 0;
+	seg->le += *le_cur;
+
+	/* add the subpool type to the segment tag list */
+	str_list_add(mem, &seg->tags, _cvt_sptype(usp->type));
+
+	for (j = 0; j < usp->num_devs; j++) {
+		if (!(seg->segtype = get_segtype_from_string(lv->vg->cmd,
+							     "striped"))) {
+			stack;
+			return 0;
+		}
+
+		seg->area_len = (usp->devs[j].blocks) / POOL_PE_SIZE;
+		seg->len += seg->area_len;
+		*le_cur += seg->area_len;
+		seg->lv = lv;
+
+		seg->area[j].type = AREA_PV;
+		seg->area[j].u.pv.pv = usp->devs[j].pv;
+		seg->area[j].u.pv.pe = 0;
+	}
+	list_add(&lv->segments, &seg->list);
+	return 1;
+}
+
+static int _add_linear_seg(struct pool *mem,
+			   struct user_subpool *usp, struct logical_volume *lv,
+			   uint32_t *le_cur)
+{
+	struct lv_segment *seg;
+	int j;
+
+	for (j = 0; j < usp->num_devs; j++) {
+		/* linear segments only have 1 data area */
+		if (!(seg = alloc_lv_segment(mem, 1))) {
+			log_error("Unable to allocate linear lv_segment "
+				  "structure");
+			return 0;
+		}
+		seg->stripe_size = usp->striping;
+		seg->le += *le_cur;
+		seg->chunk_size = POOL_PE_SIZE;
+		seg->status |= 0;
+		if (!(seg->segtype = get_segtype_from_string(lv->vg->cmd,
+							     "striped"))) {
+			stack;
+			return 0;
+		}
+		/* add the subpool type to the segment tag list */
+		str_list_add(mem, &seg->tags, _cvt_sptype(usp->type));
+
+		seg->lv = lv;
+
+		seg->area_len = (usp->devs[j].blocks) / POOL_PE_SIZE;
+		seg->len = seg->area_len;
+		*le_cur += seg->len;
+		seg->area[0].type = AREA_PV;
+		seg->area[0].u.pv.pv = usp->devs[j].pv;
+		seg->area[0].u.pv.pe = 0;
+		list_add(&lv->segments, &seg->list);
+	}
+	return 1;
+}
+
+int import_pool_segments(struct list *lvs, struct pool *mem,
+			 struct user_subpool *usp, int subpools)
+{
+
+	struct list *lvhs;
+	struct lv_list *lvl;
+	struct logical_volume *lv;
+	uint32_t le_cur = 0;
+	int i;
+
+	list_iterate(lvhs, lvs) {
+		lvl = list_item(lvhs, struct lv_list);
+
+		lv = lvl->lv;
+		for (i = 0; i < subpools; i++) {
+			if (usp[i].striping) {
+				if (!_add_stripe_seg(mem, &usp[i], lv, &le_cur)) {
+					stack;
+					return 0;
+				}
+			} else {
+				if (!_add_linear_seg(mem, &usp[i], lv, &le_cur)) {
+					stack;
+					return 0;
+				}
+			}
+		}
+	}
+
+	return 1;
+
+}

lib/format_pool/pool_label.c

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "pool.h"
+#include "label.h"
+#include "metadata.h"
+#include "xlate.h"
+#include "disk_rep.h"
+#include "pool_label.h"
+
+#include <sys/stat.h>
+#include <fcntl.h>
+
+static void _not_supported(const char *op)
+{
+	log_error("The '%s' operation is not supported for the pool labeller.",
+		  op);
+}
+
+static int _can_handle(struct labeller *l, char *buf, uint64_t sector)
+{
+
+	struct pool_disk pd;
+
+	/*
+	 * POOL label must always be in first sector
+	 */
+	if (sector)
+		return 0;
+
+	pool_label_in(&pd, buf);
+
+	/* can ignore 8 rightmost bits for ondisk format check */
+	if ((pd.pl_magic == POOL_MAGIC) &&
+	    (pd.pl_version >> 8 == POOL_VERSION >> 8))
+		return 1;
+
+	return 0;
+}
+
+static int _write(struct label *label, char *buf)
+{
+	_not_supported("write");
+	return 0;
+}
+
+static int _read(struct labeller *l, struct device *dev, char *buf,
+		 struct label **label)
+{
+	struct pool_list pl;
+
+	return read_pool_label(&pl, l, dev, buf, label);
+}
+
+static int _initialise_label(struct labeller *l, struct label *label)
+{
+	strcpy(label->type, "POOL");
+
+	return 1;
+}
+
+static void _destroy_label(struct labeller *l, struct label *label)
+{
+	return;
+}
+
+static void _destroy(struct labeller *l)
+{
+	dbg_free(l);
+}
+
+struct label_ops _pool_ops = {
+      can_handle:_can_handle,
+      write:_write,
+      read:_read,
+      verify:_can_handle,
+      initialise_label:_initialise_label,
+      destroy_label:_destroy_label,
+      destroy:_destroy
+};
+
+struct labeller *pool_labeller_create(struct format_type *fmt)
+{
+	struct labeller *l;
+
+	if (!(l = dbg_malloc(sizeof(*l)))) {
+		log_error("Couldn't allocate labeller object.");
+		return NULL;
+	}
+
+	l->ops = &_pool_ops;
+	l->private = (const void *) fmt;
+
+	return l;
+}

lib/format_pool/pool_label.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 1997-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_POOL_LABEL_H
+#define _LVM_POOL_LABEL_H
+
+#include "metadata.h"
+
+struct labeller *pool_labeller_create(struct format_type *fmt);
+
+#endif

lib/format_text/archive.c

@@ -1,12 +1,21 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "format-text.h"
 
-#include "log.h"
 #include "pool.h"
 #include "config.h"
 #include "hash.h"
@@ -17,7 +26,6 @@
 
 #include <dirent.h>
 #include <unistd.h>
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <fcntl.h>
@@ -51,32 +59,32 @@ struct archive_file {
 /*
  * Extract vg name and version number from a filename.
  */
-static int _split_vg(const char *filename, char *vg, size_t vg_size,
-		     uint32_t * index)
+static int _split_vg(const char *filename, char *vgname, size_t vg_size,
+		     uint32_t *ix)
 {
-	int len, vg_len;
-	char *dot, *underscore;
+	size_t len, vg_len;
+	const char *dot, *underscore;
 
 	len = strlen(filename);
 	if (len < 7)
 		return 0;
 
-	dot = (char *) (filename + len - 3);
+	dot = (filename + len - 3);
 	if (strcmp(".vg", dot))
 		return 0;
 
 	if (!(underscore = rindex(filename, '_')))
 		return 0;
 
-	if (sscanf(underscore + 1, "%u", index) != 1)
+	if (sscanf(underscore + 1, "%u", ix) != 1)
 		return 0;
 
 	vg_len = underscore - filename;
 	if (vg_len + 1 > vg_size)
 		return 0;
 
-	strncpy(vg, filename, vg_len);
-	vg[vg_len] = '\0';
+	strncpy(vgname, filename, vg_len);
+	vgname[vg_len] = '\0';
 
 	return 1;
 }
@@ -84,7 +92,7 @@ static int _split_vg(const char *filename, char *vg, size_t vg_size,
 static void _insert_file(struct list *head, struct archive_file *b)
 {
 	struct list *bh;
-	struct archive_file *bf;
+	struct archive_file *bf = NULL;
 
 	if (list_empty(head)) {
 		list_add(head, &b->list);
@@ -122,10 +130,10 @@ static char *_join(struct pool *mem, const char *dir, const char *name)
  * Returns a list of archive_files.
  */
 static struct list *_scan_archive(struct pool *mem,
-				  const char *vg, const char *dir)
+				  const char *vgname, const char *dir)
 {
-	int i, count, index;
-	char vg_name[64], *path;
+	int i, count, ix;
+	char vgname_found[64], *path;
 	struct dirent **dirent;
 	struct archive_file *af;
 	struct list *results;
@@ -149,12 +157,12 @@ static struct list *_scan_archive(struct pool *mem,
 			continue;
 
 		/* check the name is the correct format */
-		if (!_split_vg(dirent[i]->d_name, vg_name, sizeof(vg_name),
-			       &index))
+		if (!_split_vg(dirent[i]->d_name, vgname_found,
+			       sizeof(vgname_found), &ix))
 			continue;
 
 		/* is it the vg we're interested in ? */
-		if (strcmp(vg, vg_name))
+		if (strcmp(vgname, vgname_found))
 			continue;
 
 		if (!(path = _join(mem, dir, dirent[i]->d_name))) {
@@ -171,7 +179,7 @@ static struct list *_scan_archive(struct pool *mem,
 			goto out;
 		}
 
-		af->index = index;
+		af->index = ix;
 		af->path = path;
 
 		/*
@@ -202,7 +210,7 @@ static void _remove_expired(struct list *archives, uint32_t archives_size,
 		return;
 
 	/* Convert retain_days into the time after which we must retain */
-	retain_time = time(NULL) - (time_t) retain_days * SECS_PER_DAY;
+	retain_time = time(NULL) - (time_t) retain_days *SECS_PER_DAY;
 
 	/* Assume list is ordered oldest first (by index) */
 	list_iterate(bh, archives) {
@@ -232,7 +240,7 @@ int archive_vg(struct volume_group *vg,
 	       uint32_t retain_days, uint32_t min_archive)
 {
 	int i, fd, renamed = 0;
-	unsigned int index = 0;
+	unsigned int ix = 0;
 	struct archive_file *last;
 	FILE *fp = NULL;
 	char temp_file[PATH_MAX], archive_name[PATH_MAX];
@@ -252,7 +260,7 @@ int archive_vg(struct volume_group *vg,
 		return 0;
 	}
 
-	if (!text_vg_export(fp, vg, desc)) {
+	if (!text_vg_export_file(vg, desc, fp)) {
 		stack;
 		fclose(fp);
 		return 0;
@@ -269,15 +277,15 @@ int archive_vg(struct volume_group *vg,
 	}
 
 	if (list_empty(archives))
-		index = 0;
+		ix = 0;
 	else {
 		last = list_item(archives->p, struct archive_file);
-		index = last->index + 1;
+		ix = last->index + 1;
 	}
 
 	for (i = 0; i < 10; i++) {
 		if (lvm_snprintf(archive_name, sizeof(archive_name),
-				 "%s/%s_%05d.vg", dir, vg->name, index) < 0) {
+				 "%s/%s_%05d.vg", dir, vg->name, ix) < 0) {
 			log_error("Archive file name too long.");
 			return 0;
 		}
@@ -285,7 +293,7 @@ int archive_vg(struct volume_group *vg,
 		if ((renamed = lvm_rename(temp_file, archive_name)))
 			break;
 
-		index++;
+		ix++;
 	}
 
 	if (!renamed)
@@ -297,8 +305,7 @@ int archive_vg(struct volume_group *vg,
 	return 1;
 }
 
-static void _display_archive(struct cmd_context *cmd, struct uuid_map *um,
-			     struct archive_file *af)
+static void _display_archive(struct cmd_context *cmd, struct archive_file *af)
 {
 	struct volume_group *vg = NULL;
 	struct format_instance *tf;
@@ -306,10 +313,12 @@ static void _display_archive(struct cmd_context *cmd, struct uuid_map *um,
 	char *desc;
 	void *context;
 
-	log_print("path:\t\t%s", af->path);
+	log_print(" ");
+	log_print("File:\t\t%s", af->path);
 
-	if (!(context = create_text_context(cmd->fmtt, af->path, NULL)) ||
-	    !(tf = cmd->fmtt->ops->create_instance(cmd->fmtt, NULL, context))) {
+	if (!(context = create_text_context(cmd, af->path, NULL)) ||
+	    !(tf = cmd->fmt_backup->ops->create_instance(cmd->fmt_backup, NULL,
+							 context))) {
 		log_error("Couldn't create text instance object.");
 		return;
 	}
@@ -319,41 +328,55 @@ static void _display_archive(struct cmd_context *cmd, struct uuid_map *um,
 	 * retrieve the archive time and description.
 	 */
 	/* FIXME Use variation on _vg_read */
-	if (!(vg = text_vg_import(tf, af->path, um, &when, &desc))) {
+	if (!(vg = text_vg_import_file(tf, af->path, &when, &desc))) {
 		log_print("Unable to read archive file.");
 		tf->fmt->ops->destroy_instance(tf);
 		return;
 	}
 
-	log_print("description:\t%s", desc ? desc : "<No description>");
-	log_print("time:\t\t%s", ctime(&when));
+	log_print("VG name:    \t%s", vg->name);
+	log_print("Description:\t%s", desc ? desc : "<No description>");
+	log_print("Backup Time:\t%s", ctime(&when));
 
 	pool_free(cmd->mem, vg);
 	tf->fmt->ops->destroy_instance(tf);
 }
 
-int archive_list(struct cmd_context *cmd, struct uuid_map *um,
-		 const char *dir, const char *vg)
+int archive_list(struct cmd_context *cmd, const char *dir, const char *vgname)
 {
 	struct list *archives, *ah;
 	struct archive_file *af;
 
-	if (!(archives = _scan_archive(cmd->mem, vg, dir))) {
+	if (!(archives = _scan_archive(cmd->mem, vgname, dir))) {
 		log_err("Couldn't scan the archive directory (%s).", dir);
 		return 0;
 	}
 
 	if (list_empty(archives))
-		log_print("No archives found.");
+		log_print("No archives found in %s.", dir);
 
 	list_iterate(ah, archives) {
 		af = list_item(ah, struct archive_file);
 
-		_display_archive(cmd, um, af);
-		log_print(" ");
+		_display_archive(cmd, af);
 	}
 
 	pool_free(cmd->mem, archives);
 
 	return 1;
 }
+
+int backup_list(struct cmd_context *cmd, const char *dir, const char *vgname)
+{
+	struct archive_file af;
+
+	if (!(af.path = _join(cmd->mem, dir, vgname))) {
+		stack;
+		return 0;
+	}
+
+	if (path_exists(af.path))
+		_display_archive(cmd, &af);
+
+	return 1;
+}

lib/format_text/export.c

@@ -1,44 +1,81 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "lib.h"
 #include "import-export.h"
 #include "metadata.h"
-#include "log.h"
 #include "hash.h"
 #include "pool.h"
-#include "dbg_malloc.h"
-#include "lvm-string.h"
 #include "display.h"
+#include "lvm-string.h"
+#include "segtypes.h"
+#include "text_export.h"
 
-#include <stdio.h>
 #include <stdarg.h>
 #include <time.h>
+#include <sys/utsname.h>
 
-
+struct formatter;
+typedef int (*out_with_comment_fn) (struct formatter * f, const char *comment,
+				    const char *fmt, va_list ap);
+typedef void (*nl_fn) (struct formatter * f);
+/*
+ * The first half of this file deals with
+ * exporting the vg, ie. writing it to a file.
+ */
 struct formatter {
 	struct pool *mem;	/* pv names allocated from here */
 	struct hash_table *pv_names;	/* dev_name -> pv_name (eg, pv1) */
 
-	FILE *fp;		/* where we're writing to */
-	int indent;		/* current level of indentation */
+	union {
+		FILE *fp;	/* where we're writing to */
+		struct {
+			char *buf;
+			uint32_t size;
+			uint32_t used;
+		} buf;
+	} data;
 
+	out_with_comment_fn out_with_comment;
+	nl_fn nl;
+
+	int indent;		/* current level of indentation */
 	int error;
+	int header;		/* 1 => comments at start; 0 => end */
 };
 
+static struct utsname _utsname;
+
+static void _init(void)
+{
+	static int _initialised = 0;
+
+	if (_initialised)
+		return;
+
+	if (uname(&_utsname)) {
+		log_error("uname failed: %s", strerror(errno));
+		memset(&_utsname, 0, sizeof(_utsname));
+	}
+
+	_initialised = 1;
+}
+
 /*
  * Formatting functions.
  */
-static void _out_size(struct formatter *f, uint64_t size, const char *fmt, ...)
-    __attribute__ ((format(printf, 3, 4)));
-
-static void _out_hint(struct formatter *f, const char *fmt, ...)
-    __attribute__ ((format(printf, 2, 3)));
-
-static void _out(struct formatter *f, const char *fmt, ...)
-    __attribute__ ((format(printf, 2, 3)));
 
 #define MAX_INDENT 5
 static void _inc_indent(struct formatter *f)
@@ -58,26 +95,39 @@ static void _dec_indent(struct formatter *f)
 /*
  * Newline function for prettier layout.
  */
-static void _nl(struct formatter *f)
+static void _nl_file(struct formatter *f)
 {
-	fprintf(f->fp, "\n");
+	fprintf(f->data.fp, "\n");
+}
+
+static void _nl_raw(struct formatter *f)
+{
+	if (f->data.buf.used >= f->data.buf.size - 1)
+		return;
+
+	*f->data.buf.buf = '\n';
+	f->data.buf.buf += 1;
+	f->data.buf.used += 1;
+	*f->data.buf.buf = '\0';
+
+	return;
 }
 
 #define COMMENT_TAB 6
-static void _out_with_comment(struct formatter *f, const char *comment,
-			      const char *fmt, va_list ap)
+static int _out_with_comment_file(struct formatter *f, const char *comment,
+				  const char *fmt, va_list ap)
 {
 	int i;
 	char white_space[MAX_INDENT + 1];
 
-	if (ferror(f->fp))
-		return;
+	if (ferror(f->data.fp))
+		return 0;
 
 	for (i = 0; i < f->indent; i++)
 		white_space[i] = '\t';
 	white_space[i] = '\0';
-	fprintf(f->fp, white_space);
-	i = vfprintf(f->fp, fmt, ap);
+	fprintf(f->data.fp, white_space);
+	i = vfprintf(f->data.fp, fmt, ap);
 
 	if (comment) {
 		/*
@@ -88,13 +138,34 @@ static void _out_with_comment(struct formatter *f, const char *comment,
 		i++;
 
 		do
-			fputc('\t', f->fp);
+			fputc('\t', f->data.fp);
 
 		while (++i < COMMENT_TAB);
 
-		fprintf(f->fp, comment);
+		fprintf(f->data.fp, comment);
 	}
-	fputc('\n', f->fp);
+	fputc('\n', f->data.fp);
+
+	return 1;
+}
+
+static int _out_with_comment_raw(struct formatter *f, const char *comment,
+				 const char *fmt, va_list ap)
+{
+	int n;
+
+	n = vsnprintf(f->data.buf.buf, f->data.buf.size - f->data.buf.used,
+		      fmt, ap);
+
+	if (n < 0 || (n > f->data.buf.size - f->data.buf.used - 1))
+		return 0;
+
+	f->data.buf.buf += n;
+	f->data.buf.used += n;
+
+	f->nl(f);
+
+	return 1;
 }
 
 /*
@@ -105,11 +176,11 @@ static void _out_with_comment(struct formatter *f, const char *comment,
  */
 static int _sectors_to_units(uint64_t sectors, char *buffer, size_t s)
 {
-	static char *_units[] = {
+	static const char *_units[] = {
 		"Kilobytes",
 		"Megabytes",
 		"Gigabytes",
-		"Terrabytes",
+		"Terabytes",
 		NULL
 	};
 
@@ -129,41 +200,51 @@ static int _sectors_to_units(uint64_t sectors, char *buffer, size_t s)
  * Appends a comment giving a size in more easily
  * readable form (eg, 4M instead of 8096).
  */
-static void _out_size(struct formatter *f, uint64_t size, const char *fmt, ...)
+int out_size(struct formatter *f, uint64_t size, const char *fmt, ...)
 {
 	char buffer[64];
 	va_list ap;
+	int r;
 
-	_sectors_to_units(size, buffer, sizeof(buffer));
+	if (!_sectors_to_units(size, buffer, sizeof(buffer)))
+		return 0;
 
 	va_start(ap, fmt);
-	_out_with_comment(f, buffer, fmt, ap);
+	r = f->out_with_comment(f, buffer, fmt, ap);
 	va_end(ap);
+
+	return r;
 }
 
 /*
  * Appends a comment indicating that the line is
  * only a hint.
  */
-static void _out_hint(struct formatter *f, const char *fmt, ...)
+int out_hint(struct formatter *f, const char *fmt, ...)
 {
 	va_list ap;
+	int r;
 
 	va_start(ap, fmt);
-	_out_with_comment(f, "# Hint only", fmt, ap);
+	r = f->out_with_comment(f, "# Hint only", fmt, ap);
 	va_end(ap);
+
+	return r;
 }
 
 /*
  * The normal output function.
  */
-static void _out(struct formatter *f, const char *fmt, ...)
+int out_text(struct formatter *f, const char *fmt, ...)
 {
 	va_list ap;
+	int r;
 
 	va_start(ap, fmt);
-	_out_with_comment(f, NULL, fmt, ap);
+	r = f->out_with_comment(f, NULL, fmt, ap);
 	va_end(ap);
+
+	return r;
 }
 
 static int _print_header(struct formatter *f,
@@ -173,42 +254,65 @@ static int _print_header(struct formatter *f,
 
 	t = time(NULL);
 
-	_out(f,
-	     "# This file was originally generated by the LVM2 library\n"
-	     "# Generated: %s", ctime(&t));
+	outf(f, "# Generated by LVM2: %s", ctime(&t));
+	outf(f, CONTENTS_FIELD " = \"" CONTENTS_VALUE "\"");
+	outf(f, FORMAT_VERSION_FIELD " = %d", FORMAT_VERSION_VALUE);
+	f->nl(f);
 
-	_out(f, CONTENTS_FIELD " = \"" CONTENTS_VALUE "\"");
-	_out(f, FORMAT_VERSION_FIELD " = %d\n", FORMAT_VERSION_VALUE);
-
-	_out(f, "description = \"%s\"", desc);
-	_out(f, "creation_time = %lu\n", t);
+	outf(f, "description = \"%s\"", desc);
+	f->nl(f);
+	outf(f, "creation_host = \"%s\"\t# %s %s %s %s %s", _utsname.nodename,
+	     _utsname.sysname, _utsname.nodename, _utsname.release,
+	     _utsname.version, _utsname.machine);
+	outf(f, "creation_time = %lu\t# %s", t, ctime(&t));
 
 	return 1;
 }
 
 static int _print_vg(struct formatter *f, struct volume_group *vg)
 {
-	char buffer[256];
+	char buffer[4096];
 
 	if (!id_write_format(&vg->id, buffer, sizeof(buffer))) {
 		stack;
 		return 0;
 	}
 
-	_out(f, "id = \"%s\"", buffer);
+	outf(f, "id = \"%s\"", buffer);
+
+	outf(f, "seqno = %u", vg->seqno);
 
-	_out(f, "seqno = %u", vg->seqno);
 	if (!print_flags(vg->status, VG_FLAGS, buffer, sizeof(buffer))) {
 		stack;
 		return 0;
 	}
+	outf(f, "status = %s", buffer);
+
+	if (!list_empty(&vg->tags)) {
+		if (!print_tags(&vg->tags, buffer, sizeof(buffer))) {
+			stack;
+			return 0;
+		}
+		outf(f, "tags = %s", buffer);
+	}
 
-	_out(f, "status = %s", buffer);
 	if (vg->system_id && *vg->system_id)
-		_out(f, "system_id = \"%s\"", vg->system_id);
-	_out_size(f, vg->extent_size, "extent_size = %u", vg->extent_size);
-	_out(f, "max_lv = %u", vg->max_lv);
-	_out(f, "max_pv = %u", vg->max_pv);
+		outf(f, "system_id = \"%s\"", vg->system_id);
+
+	if (!out_size(f, (uint64_t) vg->extent_size, "extent_size = %u",
+		      vg->extent_size)) {
+		stack;
+		return 0;
+	}
+	outf(f, "max_lv = %u", vg->max_lv);
+	outf(f, "max_pv = %u", vg->max_pv);
+
+	/* Default policy is NORMAL; INHERIT is meaningless */
+	if (vg->alloc != ALLOC_NORMAL && vg->alloc != ALLOC_INHERIT) {
+		f->nl(f);
+		outf(f, "allocation_policy = \"%s\"",
+		     get_alloc_string(vg->alloc));
+	}
 
 	return 1;
 }
@@ -228,14 +332,13 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 {
 	struct list *pvh;
 	struct physical_volume *pv;
-	char buffer[256];
+	char buffer[4096];
 	const char *name;
 
-	_out(f, "physical_volumes {");
+	outf(f, "physical_volumes {");
 	_inc_indent(f);
 
 	list_iterate(pvh, &vg->pvs) {
-
 		pv = list_item(pvh, struct pv_list)->pv;
 
 		if (!(name = _get_pv_name(f, pv))) {
@@ -243,8 +346,8 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 			return 0;
 		}
 
-		_nl(f);
-		_out(f, "%s {", name);
+		f->nl(f);
+		outf(f, "%s {", name);
 		_inc_indent(f);
 
 		if (!id_write_format(&pv->id, buffer, sizeof(buffer))) {
@@ -252,69 +355,117 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 			return 0;
 		}
 
-		_out(f, "id = \"%s\"", buffer);
-		_out_hint(f, "device = \"%s\"", dev_name(pv->dev));
-		_nl(f);
+		outf(f, "id = \"%s\"", buffer);
+		if (!out_hint(f, "device = \"%s\"", dev_name(pv->dev))) {
+			stack;
+			return 0;
+		}
+		f->nl(f);
 
 		if (!print_flags(pv->status, PV_FLAGS, buffer, sizeof(buffer))) {
 			stack;
 			return 0;
 		}
+		outf(f, "status = %s", buffer);
 
-		_out(f, "status = %s", buffer);
-		_out(f, "pe_start = %llu", pv->pe_start);
-		_out_size(f, vg->extent_size * (uint64_t) pv->pe_count,
-			  "pe_count = %u", pv->pe_count);
+		if (!list_empty(&pv->tags)) {
+			if (!print_tags(&pv->tags, buffer, sizeof(buffer))) {
+				stack;
+				return 0;
+			}
+			outf(f, "tags = %s", buffer);
+		}
 
-		_dec_indent(f);
-		_out(f, "}");
-	}
-
-	_dec_indent(f);
-	_out(f, "}");
-	return 1;
-}
-
-static int _print_segment(struct formatter *f, struct volume_group *vg,
-			  int count, struct stripe_segment *seg)
-{
-	int s;
-	const char *name;
-
-	_out(f, "segment%u {", count);
-	_inc_indent(f);
-
-	_out(f, "start_extent = %u", seg->le);
-	_out_size(f, seg->len * vg->extent_size, "extent_count = %u", seg->len);
-	_out(f, "stripes = %u", seg->stripes);
-
-	if (seg->stripes > 1)
-		_out_size(f, seg->stripe_size,
-			  "stripe_size = %u", seg->stripe_size);
-
-	_nl(f);
-	_out(f, "areas = [");
-	_inc_indent(f);
-
-	for (s = 0; s < seg->stripes; s++) {
-		if (!(name = _get_pv_name(f, seg->area[s].pv))) {
+		outf(f, "pe_start = %" PRIu64, pv->pe_start);
+		if (!out_size(f, vg->extent_size * (uint64_t) pv->pe_count,
+			      "pe_count = %u", pv->pe_count)) {
 			stack;
 			return 0;
 		}
 
-		_out(f, "\"%s\", %u%s", name, seg->area[s].pe,
-		     (s == seg->stripes - 1) ? "" : ",");
+		_dec_indent(f);
+		outf(f, "}");
 	}
 
 	_dec_indent(f);
-	_out(f, "]");
+	outf(f, "}");
+	return 1;
+}
+
+static int _print_segment(struct formatter *f, struct volume_group *vg,
+			  int count, struct lv_segment *seg)
+{
+	char buffer[4096];
+
+	outf(f, "segment%u {", count);
+	_inc_indent(f);
+
+	outf(f, "start_extent = %u", seg->le);
+	if (!out_size(f, (uint64_t) seg->len * vg->extent_size,
+		      "extent_count = %u", seg->len)) {
+		stack;
+		return 0;
+	}
+
+	f->nl(f);
+	outf(f, "type = \"%s\"", seg->segtype->name);
+
+	if (!list_empty(&seg->tags)) {
+		if (!print_tags(&seg->tags, buffer, sizeof(buffer))) {
+			stack;
+			return 0;
+		}
+		outf(f, "tags = %s", buffer);
+	}
+
+	if (seg->segtype->ops->text_export &&
+	    !seg->segtype->ops->text_export(seg, f)) {
+		stack;
+		return 0;
+	}
 
 	_dec_indent(f);
-	_out(f, "}");
+	outf(f, "}");
 
 	return 1;
 }
 
+int out_areas(struct formatter *f, const struct lv_segment *seg,
+	      const char *type)
+{
+	const char *name;
+	unsigned int s;
+
+	f->nl(f);
+
+	outf(f, "%ss = [", type);
+	_inc_indent(f);
+
+	for (s = 0; s < seg->area_count; s++) {
+		switch (seg->area[s].type) {
+		case AREA_PV:
+			if (!(name = _get_pv_name(f, seg->area[s].u.pv.pv))) {
+				stack;
+				return 0;
+			}
+
+			outf(f, "\"%s\", %u%s", name,
+			     seg->area[s].u.pv.pe,
+			     (s == seg->area_count - 1) ? "" : ",");
+			break;
+		case AREA_LV:
+			outf(f, "\"%s\", %u%s",
+			     seg->area[s].u.lv.lv->name,
+			     seg->area[s].u.lv.le,
+			     (s == seg->area_count - 1) ? "" : ",");
+		}
+	}
+
+	_dec_indent(f);
+	outf(f, "]");
+	return 1;
+}
+
 static int _count_segments(struct logical_volume *lv)
 {
 	int r = 0;
@@ -326,86 +477,65 @@ static int _count_segments(struct logical_volume *lv)
 	return r;
 }
 
-static int _print_lvs(struct formatter *f, struct volume_group *vg)
+static int _print_snapshot(struct formatter *f, struct snapshot *snap,
+			   unsigned int count)
 {
-	struct list *lvh, *segh;
-	struct logical_volume *lv;
-	struct stripe_segment *seg;
 	char buffer[256];
-	int seg_count;
+	struct lv_segment seg;
 
-	/*
-	 * Don't bother with an lv section if there are no lvs.
-	 */
-	if (list_empty(&vg->lvs))
-		return 1;
+	f->nl(f);
 
-	_out(f, "logical_volumes {");
+	outf(f, "snapshot%u {", count);
 	_inc_indent(f);
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
+	if (!id_write_format(&snap->id, buffer, sizeof(buffer))) {
+		stack;
+		return 0;
+	}
 
-		_nl(f);
-		_out(f, "%s {", lv->name);
-		_inc_indent(f);
+	outf(f, "id = \"%s\"", buffer);
 
-		/* FIXME: Write full lvid */
-		if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {
-			stack;
-			return 0;
-		}
+	seg.status = LVM_READ | LVM_WRITE | VISIBLE_LV;
+	if (!print_flags(seg.status, LV_FLAGS, buffer, sizeof(buffer))) {
+		stack;
+		return 0;
+	}
 
-		_out(f, "id = \"%s\"", buffer);
+	outf(f, "status = %s", buffer);
+	outf(f, "segment_count = 1");
 
-		if (!print_flags(lv->status, LV_FLAGS,
-				 buffer, sizeof(buffer))) {
-			stack;
-			return 0;
-		}
+	f->nl(f);
 
-		_out(f, "status = %s", buffer);
-		_out(f, "allocation_policy = \"%s\"",
-		     get_alloc_string(lv->alloc));
-		_out(f, "read_ahead = %u", lv->read_ahead);
-		if (lv->minor >= 0)
-			_out(f, "minor = %d", lv->minor);
-		_out(f, "segment_count = %u", _count_segments(lv));
-		_nl(f);
+	if (!(seg.segtype = get_segtype_from_string(snap->origin->vg->cmd,
+						    "snapshot"))) {
+		stack;
+		return 0;
+	}
 
-		seg_count = 1;
-		list_iterate(segh, &lv->segments) {
-			seg = list_item(segh, struct stripe_segment);
+	seg.le = 0;
+	seg.len = snap->origin->le_count;
+	seg.origin = snap->origin;
+	seg.cow = snap->cow;
+	seg.chunk_size = snap->chunk_size;
 
-			if (!_print_segment(f, vg, seg_count++, seg)) {
-				stack;
-				return 0;
-			}
-		}
+	/* FIXME Dummy values */
+	list_init(&seg.list);
+	seg.lv = snap->cow;
+	seg.stripe_size = 0;
+	seg.area_count = 0;
+	seg.area_len = 0;
+	seg.extents_copied = 0;
 
-		_dec_indent(f);
-		_out(f, "}");
+	/* Can't tag a snapshot independently of its origin */
+	list_init(&seg.tags);
+
+	if (!_print_segment(f, snap->origin->vg, 1, &seg)) {
+		stack;
+		return 0;
 	}
 
 	_dec_indent(f);
-	_out(f, "}");
-
-	return 1;
-}
-
-static int _print_snapshot(struct formatter *f, struct snapshot *s,
-			   unsigned int count)
-{
-	_nl(f);
-	_out(f, "snapshot%u {", count);
-	_inc_indent(f);
-
-	_out(f, "chunk_size = %u", s->chunk_size);
-	_out(f, "origin = \"%s\"", s->origin->name);
-	_out(f, "cow_store = \"%s\"", s->cow->name);
-
-	_dec_indent(f);
-	_out(f, "}");
+	outf(f, "}");
 
 	return 1;
 }
@@ -416,16 +546,6 @@ static int _print_snapshots(struct formatter *f, struct volume_group *vg)
 	struct snapshot *s;
 	unsigned int count = 0;
 
-	/*
-	 * Don't bother with a snapshot section if there are no
-	 * snapshots.
-	 */
-	if (list_empty(&vg->snapshots))
-		return 1;
-
-	_out(f, "snapshots {");
-	_inc_indent(f);
-
 	list_iterate(sh, &vg->snapshots) {
 		s = list_item(sh, struct snapshot_list)->snapshot;
 
@@ -435,8 +555,87 @@ static int _print_snapshots(struct formatter *f, struct volume_group *vg)
 		}
 	}
 
+	return 1;
+}
+
+static int _print_lvs(struct formatter *f, struct volume_group *vg)
+{
+	struct list *lvh;
+	struct logical_volume *lv;
+	struct lv_segment *seg;
+	char buffer[4096];
+	int seg_count;
+
+	/*
+	 * Don't bother with an lv section if there are no lvs.
+	 */
+	if (list_empty(&vg->lvs))
+		return 1;
+
+	outf(f, "logical_volumes {");
+	_inc_indent(f);
+
+	list_iterate(lvh, &vg->lvs) {
+		lv = list_item(lvh, struct lv_list)->lv;
+
+		f->nl(f);
+		outf(f, "%s {", lv->name);
+		_inc_indent(f);
+
+		/* FIXME: Write full lvid */
+		if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {
+			stack;
+			return 0;
+		}
+
+		outf(f, "id = \"%s\"", buffer);
+
+		if (!print_flags(lv->status, LV_FLAGS, buffer, sizeof(buffer))) {
+			stack;
+			return 0;
+		}
+		outf(f, "status = %s", buffer);
+
+		if (!list_empty(&lv->tags)) {
+			if (!print_tags(&lv->tags, buffer, sizeof(buffer))) {
+				stack;
+				return 0;
+			}
+			outf(f, "tags = %s", buffer);
+		}
+
+		if (lv->alloc != ALLOC_INHERIT)
+			outf(f, "allocation_policy = \"%s\"",
+			     get_alloc_string(lv->alloc));
+
+		if (lv->read_ahead)
+			outf(f, "read_ahead = %u", lv->read_ahead);
+		if (lv->major >= 0)
+			outf(f, "major = %d", lv->major);
+		if (lv->minor >= 0)
+			outf(f, "minor = %d", lv->minor);
+		outf(f, "segment_count = %u", _count_segments(lv));
+		f->nl(f);
+
+		seg_count = 1;
+		list_iterate_items(seg, &lv->segments) {
+			if (!_print_segment(f, vg, seg_count++, seg)) {
+				stack;
+				return 0;
+			}
+		}
+
+		_dec_indent(f);
+		outf(f, "}");
+	}
+
+	if (!_print_snapshots(f, vg)) {
+		stack;
+		return 0;
+	}
+
 	_dec_indent(f);
-	_out(f, "}");
+	outf(f, "}");
 
 	return 1;
 }
@@ -466,6 +665,7 @@ static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 	list_iterate(pvh, &vg->pvs) {
 		pv = list_item(pvh, struct pv_list)->pv;
 
+		/* FIXME But skip if there's already an LV called pv%d ! */
 		if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0) {
 			stack;
 			goto bad;
@@ -494,19 +694,10 @@ static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 	return 0;
 }
 
-int text_vg_export(FILE * fp, struct volume_group *vg, const char *desc)
+static int _text_vg_export(struct formatter *f,
+			   struct volume_group *vg, const char *desc)
 {
 	int r = 0;
-	struct formatter *f;
-
-	if (!(f = dbg_malloc(sizeof(*f)))) {
-		stack;
-		return 0;
-	}
-
-	memset(f, 0, sizeof(*f));
-	f->fp = fp;
-	f->indent = 0;
 
 	if (!_build_pv_names(f, vg)) {
 		stack;
@@ -514,32 +705,34 @@ int text_vg_export(FILE * fp, struct volume_group *vg, const char *desc)
 	}
 #define fail do {stack; goto out;} while(0)
 
-	if (!_print_header(f, vg, desc))
+	if (f->header && !_print_header(f, vg, desc))
+		fail;
+
+	if (!out_text(f, "%s {", vg->name))
 		fail;
 
-	_out(f, "%s {", vg->name);
 	_inc_indent(f);
 
 	if (!_print_vg(f, vg))
 		fail;
 
-	_nl(f);
+	f->nl(f);
 	if (!_print_pvs(f, vg))
 		fail;
 
-	_nl(f);
+	f->nl(f);
 	if (!_print_lvs(f, vg))
 		fail;
 
-	_nl(f);
-	if (!_print_snapshots(f, vg))
+	_dec_indent(f);
+	if (!out_text(f, "}"))
+		fail;
+
+	if (!f->header && !_print_header(f, vg, desc))
 		fail;
 
 #undef fail
-
-	_dec_indent(f);
-	_out(f, "}");
-	r = !ferror(f->fp);
+	r = 1;
 
       out:
 	if (f->mem)
@@ -548,6 +741,68 @@ int text_vg_export(FILE * fp, struct volume_group *vg, const char *desc)
 	if (f->pv_names)
 		hash_destroy(f->pv_names);
 
+	return r;
+}
+
+int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp)
+{
+	struct formatter *f;
+	int r;
+
+	_init();
+
+	if (!(f = dbg_malloc(sizeof(*f)))) {
+		stack;
+		return 0;
+	}
+
+	memset(f, 0, sizeof(*f));
+	f->data.fp = fp;
+	f->indent = 0;
+	f->header = 1;
+	f->out_with_comment = &_out_with_comment_file;
+	f->nl = &_nl_file;
+
+	r = _text_vg_export(f, vg, desc);
+	if (r)
+		r = !ferror(f->data.fp);
 	dbg_free(f);
 	return r;
 }
+
+/* Returns amount of buffer used incl. terminating NUL */
+int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
+		       uint32_t size)
+{
+	struct formatter *f;
+	int r;
+
+	_init();
+
+	if (!(f = dbg_malloc(sizeof(*f)))) {
+		stack;
+		return 0;
+	}
+
+	memset(f, 0, sizeof(*f));
+	f->data.buf.buf = buf;
+	f->data.buf.size = size;
+	f->indent = 0;
+	f->header = 0;
+	f->out_with_comment = &_out_with_comment_raw;
+	f->nl = &_nl_raw;
+
+	if (!_text_vg_export(f, vg, desc)) {
+		stack;
+		r = 0;
+		goto out;
+	}
+
+	r = f->data.buf.used + 1;
+
+      out:
+	dbg_free(f);
+	return r;
+}
+
+#undef outf

lib/format_text/flags.c

@@ -1,10 +1,19 @@
 /*
- * Copyright (C) 2001 Sistina Software (UK) Limited.
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
  *
- * This file is released under the LGPL.
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#include "log.h"
+#include "lib.h"
 #include "metadata.h"
 #include "import-export.h"
 #include "lvm-string.h"
@@ -14,14 +23,15 @@
  * converted into arrays of strings.
  */
 struct flag {
-	int mask;
-	char *description;
+	const int mask;
+	const char *description;
 };
 
 static struct flag _vg_flags[] = {
 	{EXPORTED_VG, "EXPORTED"},
 	{RESIZEABLE_VG, "RESIZEABLE"},
 	{PARTIAL_VG, "PARTIAL"},
+	{PVMOVE, "PVMOVE"},
 	{LVM_READ, "READ"},
 	{LVM_WRITE, "WRITE"},
 	{CLUSTERED, "CLUSTERED"},
@@ -40,6 +50,10 @@ static struct flag _lv_flags[] = {
 	{LVM_WRITE, "WRITE"},
 	{FIXED_MINOR, "FIXED_MINOR"},
 	{VISIBLE_LV, "VISIBLE"},
+	{PVMOVE, "PVMOVE"},
+	{LOCKED, "LOCKED"},
+	{MIRRORED, NULL},
+	{VIRTUAL, NULL},
 	{0, NULL}
 };
 
@@ -60,23 +74,6 @@ static struct flag *_get_flags(int type)
 	return NULL;
 }
 
-static int _emit(char **buffer, size_t * size, const char *fmt, ...)
-{
-	size_t n;
-	va_list ap;
-
-	va_start(ap, fmt);
-	n = vsnprintf(*buffer, *size, fmt, ap);
-	va_end(ap);
-
-	if (n < 0 || (n == *size))
-		return 0;
-
-	*buffer += n;
-	*size -= n;
-	return 1;
-}
-
 /*
  * Converts a bitset to an array of string values,
  * using one of the tables defined at the top of
@@ -92,27 +89,30 @@ int print_flags(uint32_t status, int type, char *buffer, size_t size)
 		return 0;
 	}
 
-	if (!_emit(&buffer, &size, "["))
+	if (!emit_to_buffer(&buffer, &size, "["))
 		return 0;
 
 	for (f = 0; flags[f].mask; f++) {
 		if (status & flags[f].mask) {
-			if (!first) {
-				if (!_emit(&buffer, &size, ", "))
-					return 0;
+			status &= ~flags[f].mask;
 
+			/* Internal-only flag? */
+			if (!flags[f].description)
+				continue;
+
+			if (!first) {
+				if (!emit_to_buffer(&buffer, &size, ", "))
+					return 0;
 			} else
 				first = 0;
-
-			if (!_emit(&buffer, &size, "\"%s\"",
-				   flags[f].description))
+	
+			if (!emit_to_buffer(&buffer, &size, "\"%s\"",
+			    flags[f].description))
 				return 0;
-
-			status &= ~flags[f].mask;
 		}
 	}
 
-	if (!_emit(&buffer, &size, "]"))
+	if (!emit_to_buffer(&buffer, &size, "]"))
 		return 0;
 
 	if (status)
@@ -122,7 +122,7 @@ int print_flags(uint32_t status, int type, char *buffer, size_t size)
 	return 1;
 }
 
-int read_flags(uint32_t * status, int type, struct config_value *cv)
+int read_flags(uint32_t *status, int type, struct config_value *cv)
 {
 	int f;
 	uint32_t s = 0;
@@ -133,31 +133,30 @@ int read_flags(uint32_t * status, int type, struct config_value *cv)
 		return 0;
 	}
 
-	/*
-	 * Only scan the flags if it wasn't an empty array.
-	 */
-	if (cv->type != CFG_EMPTY_ARRAY) {
-		while (cv) {
-			if (cv->type != CFG_STRING) {
-				log_err("Status value is not a string.");
-				return 0;
-			}
+	if (cv->type == CFG_EMPTY_ARRAY)
+		goto out;
 
-			for (f = 0; flags[f].description; f++)
-				if (!strcmp(flags[f].description, cv->v.str)) {
-					s |= flags[f].mask;
-					break;
-				}
-
-			if (!flags[f].description) {
-				log_err("Unknown status flag '%s'.", cv->v.str);
-				return 0;
-			}
-
-			cv = cv->next;
+	while (cv) {
+		if (cv->type != CFG_STRING) {
+			log_err("Status value is not a string.");
+			return 0;
 		}
+
+		for (f = 0; flags[f].description; f++)
+			if (!strcmp(flags[f].description, cv->v.str)) {
+				s |= flags[f].mask;
+				break;
+			}
+
+		if (!flags[f].description) {
+			log_err("Unknown status flag '%s'.", cv->v.str);
+			return 0;
+		}
+
+		cv = cv->next;
 	}
 
+      out:
 	*status = s;
 	return 1;
 }