pre-release

Requires kernel patches to have any effect.
Library version incremented.

VERSION

@@ -1 +1 @@
-2.01.11-cvs (2005-05-03)
+2.01.15-cvs (2005-10-16)

WHATS_NEW

@@ -1,5 +1,83 @@
-Version 2.01.11 - 
-==============================
+Version 2.01.15 - 16th October 2005
+===================================
+  Refuse to run pvcreate/pvremove on devices we can't open exclusively.
+  Use ORPHAN lock definition throughout.
+  Validate chunksize in lvcreate.
+  Reduce chunksize limit to 512k.
+  Fix chunksize field in reports.
+  Don't hide snapshots from default 'lvs' output.
+  Add is_dm_major() for use in duplicate device detection in lvmcache_add().
+  Really switch device number in lvmcache when it says it is doing so.
+  Option for bitset memory allocation using malloc as well as pool.
+  Don't assume exactly two mirrors when parsing mirror status.
+  Suppress fsync() error message on filesystems that don't support it.
+  Fix yes_no_prompt() error handling.
+  Add lvm.conf comment warning against multiple filter lines.
+  Tidy lvmconf.sh.
+  Add format1 dev_write debug messages.
+  Add clustered VG attribute to report.
+  Move lvconvert parameters into struct lvconvert_params.
+  Add clustered VG flag to LV lock requests.
+  Change LV locking macros to take lv instead of lvid.
+  Prepend 'cluster' activation parameter to mirror log when appropriate.
+  Pass exclusive flag to lv_activate and on to target activation code.
+  Prevent snapshot creation in a clustered VG for now.
+  Factor out adjusted_mirror_region_size() and generate_log_name_format().
+  Move compose_log_line() into mirror directory.
+  Factor out _get_library_path().
+  Don't kill idling clvmd threads.
+  clvmd no longer takes out locks for non-clustered LVs.
+  Recognise ATA over Ethernet (aoe) devices.
+
+Version 2.01.14 - 4th August 2005
+=================================
+  Fix lvconvert PV parameter in help string.
+  Prevent snapshots getting activated in a clustered VG.
+  Separate out _build_dev_string.
+  Move zero_lv to toollib.
+  Fix pool format handler to work with pv segment code.
+
+Version 2.01.13 - 13th July 2005
+================================
+  Fix pvmove segment splitting.
+  Abstract vg_validate.
+  Only make one attempt at contiguous allocation.
+  Fix lvm1 format metadata read.
+  Fix lvm1 format non-mirror lvcreate.
+
+Version 2.01.12 - 14th June 2005
+================================
+  Various allocation-related pvmove fixes.
+  Log an error if clvmd can't resolve a host name got from CCS.
+  Fix potential spin loop in clvmd.
+
+Version 2.01.11 - 13th June 2005
+================================
+  Added lvmconf.sh.
+  Use matchpathcon mode parameter.
+  Don't defer closing dead FDs in clvmd.
+  Remove hard-coded 64k text metadata writing restriction.
+  Make VG name restrictions consistent.
+  Introduce lvconvert.  So far only removes mirror images.
+  Allow mirror images to be resized.
+  Allow mirror images to have more than one segment.
+  Centralise restrictions on LV names.
+  Always insert an intermediate layer for mirrors.
+  Suppress hidden LVs from reports unless --all is given.
+  Use square brackets for hidden LVs in reports.
+  Allow the creation of mirrors with contiguous extents.
+  Always perform sanity checks against metadata before committing it to disk.
+  Split lv_extend into two steps: choosing extents + allocation to LV(s).
+  Add mirror log region size to metadata.
+  Use list_iterate_items throughout and add list*back macros.
+  Introduce seg_ macros to access areas.
+  Add segtype_is_ macros.
+  Support tiny metadata areas for pool conversions.
+  Mirror activation handles disk log as well as core.
+  Activation code recognises mirror log dependency.
+  Add mirror_log and regionsize fields to report.
+  Fix non-orphan pvchange -u.
+  Fix vgmerge to handle duplicate LVIDs.
   Move archiver code from tools into library.
   vgscan/change/display/vgs automatically create metadata backups if needed.
   Merge cloned allocation functions.

WHATS_NEW_DM

@@ -1,3 +1,26 @@
+Version 1.02.00 - 
+=============================
+  Added dependency tree functions to library.
+  Added ls --tree to dmsetup.
+  Added dmsetup --nolockfs support for suspend/reload.
+
+Version 1.01.05 - 26 Sep 2005
+=============================
+  Resync list.h with LVM2.
+  Remember increased buffer size and use for subsequent calls.
+  On 'buffer full' condition, double buffer size and repeat ioctl.
+  Fix termination of getopt_long() option array.
+  Report 'buffer full' condition with v4 ioctl as well as with v1.
+
+Version 1.01.04 - 2 Aug 2005
+============================
+  Fix dmsetup ls -j and status --target with empty table.
+
+Version 1.01.03 - 13 Jun 2005
+=============================
+  Use matchpathcon mode parameter.
+  Fix configure script to re-enable selinux.
+
 Version 1.01.02 - 17 May 2005
 =============================
   Call dm_lib_exit() and dm_lib_release() automatically now.

daemons/clvmd/clvmd-command.c

@@ -109,7 +109,7 @@ int do_command(struct local_client *client, struct clvm_header *msg, int msglen,
 
 	case CLVMD_CMD_LOCK_LV:
 		/* This is the biggie */
-		lock_cmd = args[0];
+		lock_cmd = args[0] & 0x3F;
 		lock_flags = args[1];
 		lockname = &args[2];
 		status = do_lock_lv(lock_cmd, lock_flags, lockname);
@@ -161,7 +161,7 @@ static int lock_vg(struct local_client *client)
 	client->bits.localsock.private = (void *)lock_hash;
     }
 
-    lock_cmd = args[0];
+    lock_cmd = args[0] & 0x3F;
     lock_flags = args[1];
     lockname = &args[2];
     DEBUGLOG("doing PRE command LOCK_VG '%s' at %x (client=%p)\n", lockname, lock_cmd, client);

daemons/clvmd/clvmd-gulm.c

@@ -944,7 +944,13 @@ static int get_all_cluster_nodes()
 	}
 	else
 	{
-	    DEBUGLOG("node %s has clvm disabled\n", nodename);
+		if (!clvmflag) {
+			DEBUGLOG("node %s has clvm disabled\n", nodename);
+		}
+		else {
+			DEBUGLOG("Cannot resolve host name %s\n", nodename);
+			log_err("Cannot resolve host name %s\n", nodename);
+		}
 	}
 	free(nodename);
     }

daemons/clvmd/clvmd.c

@@ -512,6 +512,10 @@ static void main_loop(int local_sock, int cmd_timeout)
 		FD_ZERO(&in);
 		for (thisfd = &local_client_head; thisfd != NULL;
 		     thisfd = thisfd->next) {
+
+			if (thisfd->removeme)
+				continue;
+
 			/* if the cluster is not quorate then don't listen for new requests */
 			if ((thisfd->type != LOCAL_RENDEZVOUS &&
 			     thisfd->type != LOCAL_SOCK) || quorate)
@@ -578,6 +582,7 @@ static void main_loop(int local_sock, int cmd_timeout)
 						lastfd->next = thisfd->next;
 						free_fd = thisfd;
 						thisfd = lastfd;
+						close(free_fd->fd);
 
 						/* Queue cleanup, this also frees the client struct */
 						add_to_lvmqueue(free_fd, NULL, 0, NULL);
@@ -742,6 +747,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 
 		/* If the client went away in mid command then tidy up */
 		if (thisfd->bits.localsock.in_progress) {
+			pthread_kill(thisfd->bits.localsock.threadid, SIGUSR2);
 			pthread_mutex_lock(&thisfd->bits.localsock.mutex);
 			thisfd->bits.localsock.state = POST_COMMAND;
 			pthread_cond_signal(&thisfd->bits.localsock.cond);
@@ -758,7 +764,6 @@ static int read_from_local_sock(struct local_client *thisfd)
 			thisfd->bits.localsock.state = PRE_COMMAND;
 			pthread_cond_signal(&thisfd->bits.localsock.cond);
 			pthread_mutex_unlock(&thisfd->bits.localsock.mutex);
-			pthread_kill(thisfd->bits.localsock.threadid, SIGUSR2);
 
 			jstat =
 			    pthread_join(thisfd->bits.localsock.threadid,
@@ -1610,7 +1615,6 @@ static int process_work_item(struct lvm_thread_cmd *cmd)
 	/* If msg is NULL then this is a cleanup request */
 	if (cmd->msg == NULL) {
 		DEBUGLOG("process_work_item: free fd %d\n", cmd->client->fd);
-		close(cmd->client->fd);
 		cmd_client_cleanup(cmd->client);
 		free(cmd->client);
 		return 0;

daemons/clvmd/lvm-functions.c

@@ -168,11 +168,12 @@ int hold_unlock(char *resource)
 */
 
 /* Activate LV exclusive or non-exclusive */
-static int do_activate_lv(char *resource, int mode)
+static int do_activate_lv(char *resource, unsigned char lock_flags, int mode)
 {
 	int oldmode;
 	int status;
 	int activate_lv;
+	int exclusive = 0;
 	struct lvinfo lvi;
 
 	/* Is it already open ? */
@@ -189,13 +190,17 @@ static int do_activate_lv(char *resource, int mode)
 		return 0;	/* Success, we did nothing! */
 
 	/* Do we need to activate exclusively? */
-	if (activate_lv == 2)
+	if ((activate_lv == 2) || (mode == LKM_EXMODE)) {
+		exclusive = 1;
 		mode = LKM_EXMODE;
+	}
 
-	/* OK, try to get the lock */
-	status = hold_lock(resource, mode, LKF_NOQUEUE);
-	if (status)
-		return errno;
+	/* Try to get the lock if it's a clustered volume group */
+	if (lock_flags & LCK_CLUSTER_VG) {
+		status = hold_lock(resource, mode, LKF_NOQUEUE);
+		if (status)
+			return errno;
+	}
 
 	/* If it's suspended then resume it */
 	if (!lv_info_by_lvid(cmd, resource, &lvi, 0))
@@ -206,7 +211,7 @@ static int do_activate_lv(char *resource, int mode)
 			return EIO;
 
 	/* Now activate it */
-	if (!lv_activate(cmd, resource))
+	if (!lv_activate(cmd, resource, exclusive))
 		return EIO;
 
 	return 0;
@@ -255,14 +260,14 @@ static int do_suspend_lv(char *resource)
 	return 0;
 }
 
-static int do_deactivate_lv(char *resource)
+static int do_deactivate_lv(char *resource, unsigned char lock_flags)
 {
 	int oldmode;
 	int status;
 
 	/* Is it open ? */
 	oldmode = get_current_lock(resource);
-	if (oldmode == -1) {
+	if (oldmode == -1 && (lock_flags & LCK_CLUSTER_VG)) {
 		DEBUGLOG("do_deactivate_lock, lock not already held\n");
 		return 0;	/* We don't need to do anything */
 	}
@@ -270,9 +275,11 @@ static int do_deactivate_lv(char *resource)
 	if (!lv_deactivate(cmd, resource))
 		return EIO;
 
-	status = hold_unlock(resource);
-	if (status)
-		return errno;
+	if (lock_flags & LCK_CLUSTER_VG) {
+		status = hold_unlock(resource);
+		if (status)
+			return errno;
+	}
 
 	return 0;
 }
@@ -283,7 +290,7 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 {
 	int status = 0;
 
-	DEBUGLOG("do_lock_lv: resource '%s', cmd = 0x%x, flags = %d\n",
+	DEBUGLOG("do_lock_lv: resource '%s', cmd = 0x%x, flags = %x\n",
 		 resource, command, lock_flags);
 
 	if (!cmd->config_valid || config_files_changed(cmd)) {
@@ -296,7 +303,7 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 
 	switch (command) {
 	case LCK_LV_EXCLUSIVE:
-		status = do_activate_lv(resource, LKM_EXMODE);
+		status = do_activate_lv(resource, lock_flags, LKM_EXMODE);
 		break;
 
 	case LCK_LV_SUSPEND:
@@ -309,11 +316,11 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 		break;
 
 	case LCK_LV_ACTIVATE:
-		status = do_activate_lv(resource, LKM_CRMODE);
+		status = do_activate_lv(resource, lock_flags, LKM_CRMODE);
 		break;
 
 	case LCK_LV_DEACTIVATE:
-		status = do_deactivate_lv(resource);
+		status = do_deactivate_lv(resource, lock_flags);
 		break;
 
 	default:
@@ -433,23 +440,24 @@ static void drop_vg_locks()
  */
 static void *get_initial_state()
 {
-	char lv[64], vg[64], flags[25];
+	char lv[64], vg[64], flags[25], vg_flags[25];
 	char uuid[65];
 	char line[255];
 	FILE *lvs =
 	    popen
-	    ("lvm lvs --nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr",
+	    ("lvm lvs --nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr,vg_attr",
 	     "r");
 
 	if (!lvs)
 		return NULL;
 
 	while (fgets(line, sizeof(line), lvs)) {
-	        if (sscanf(line, "%s %s %s\n", vg, lv, flags) == 3) {
+	        if (sscanf(line, "%s %s %s %s\n", vg, lv, flags, vg_flags) == 4) {
 
 			/* States: s:suspended a:active S:dropped snapshot I:invalid snapshot */
 		        if (strlen(vg) == 38 &&                         /* is is a valid UUID ? */
-			    (flags[4] == 'a' || flags[4] == 's')) {	/* is it active or suspended? */
+			    (flags[4] == 'a' || flags[4] == 's') &&	/* is it active or suspended? */
+			    vg_flags[5] == 'c') {			/* is it clustered ? */
 				/* Convert hyphen-separated UUIDs into one */
 				memcpy(&uuid[0], &vg[0], 6);
 				memcpy(&uuid[6], &vg[7], 4);

daemons/clvmd/tcp-comms.c

@@ -106,6 +106,7 @@ void tcp_remove_client(char *csid)
     {
 	hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
 	client->removeme = 1;
+	close(client->fd);
     }
 
     /* Look for a mangled one too */
@@ -116,6 +117,7 @@ void tcp_remove_client(char *csid)
     {
 	hash_remove_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
 	client->removeme = 1;
+	close(client->fd);
     }
 
     /* Put it back as we found it */
@@ -228,6 +230,25 @@ int cluster_fd_gulm_callback(struct local_client *fd, char *buf, int len, char *
     return newfd;
 }
 
+/* Try to get at least 'len' bytes from the socket */
+static int really_read(int fd, char *buf, int len)
+{
+	int got, offset;
+
+	got = offset = 0;
+
+	do {
+		got = read(fd, buf+offset, len-offset);
+		DEBUGLOG("really_read. got %d bytes\n", got);
+		offset += got;
+	} while (got > 0 && offset < len);
+
+	if (got < 0)
+		return got;
+	else
+		return offset;
+}
+
 
 static int read_from_tcpsock(struct local_client *client, char *buf, int len, char *csid,
 			     struct local_client **new_client)
@@ -248,7 +269,7 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
     /* Read just the header first, then get the rest if there is any.
      * Stream sockets, sigh.
      */
-    status = read(client->fd, buf, sizeof(struct clvm_header));
+    status = really_read(client->fd, buf, sizeof(struct clvm_header));
     if (status > 0)
     {
 	    int status2;
@@ -258,7 +279,7 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
 	    /* Get the rest */
 	    if (arglen && arglen < GULM_MAX_CLUSTER_MESSAGE)
 	    {
-		    status2 = read(client->fd, buf+status, arglen);
+		    status2 = really_read(client->fd, buf+status, arglen);
 		    if (status2 > 0)
 			    status += status2;
 		    else

daemons/dmeventd/Makefile.in

@@ -28,7 +28,7 @@ else
   LIB_SHARED = libdmeventdnoop.so
 endif
  
-LDFLAGS += -ldl -ldevmapper -lpthread -lmultilog
+LDFLAGS += -ldl -ldevmapper -lmultilog
 
 include ../make.tmpl
 
@@ -36,11 +36,11 @@ libdmeventdnoop.so: noop.o
 
 dmevent: dmevent.o $(interfacedir)/libdevmapper.$(LIB_SUFFIX) $(top_srcdir)/lib/event/libdmevent.$(LIB_SUFFIX)
 	$(CC) -o $@ dmevent.o $(LDFLAGS) \
-	      -L$(interfacedir) -L$(DESTDIR)/lib -L$(top_srcdir)/lib/event -L$(top_srcdir)/multilog -ldmevent $(LIBS)
+	      -L$(interfacedir) -L$(DESTDIR)/lib -L$(top_srcdir)/lib/event -L$(top_srcdir)/multilog $(LIBS)
 
 dmeventd: dmeventd.o $(interfacedir)/libdevmapper.$(LIB_SUFFIX) $(top_srcdir)/lib/event/libdmevent.$(LIB_SUFFIX)
 	$(CC) -o $@ dmeventd.o $(LDFLAGS) \
-	      -L$(interfacedir) -L$(DESTDIR)/lib -L$(top_srcdir)/lib/event -L$(top_srcdir)/multilog -ldmevent $(LIBS)
+	      -L$(interfacedir) -L$(DESTDIR)/lib -L$(top_srcdir)/lib/event -L$(top_srcdir)/multilog -lpthread -ldmevent $(LIBS)
 
 install: $(INSTALL_TYPE)
 

daemons/dmeventd/dmevent.c

@@ -26,10 +26,23 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <dlfcn.h>
 
 static enum event_type events = ALL_ERRORS; /* All until we can distinguish. */
 static char default_dso_name[] = "noop";  /* default DSO is noop */
 static int default_reg = 1;		 /* default action is register */
+static uint32_t timeout;
+
+struct event_ops {
+int (*dm_register_for_event)(char *dso_name, char *device,
+			     enum event_type event_types);
+int (*dm_unregister_for_event)(char *dso_name, char *device,
+			       enum event_type event_types);
+int (*dm_get_registered_device)(char **dso_name, char **device,
+				enum event_type *event_types, int next);
+int (*dm_set_event_timeout)(char *device, uint32_t time);
+int (*dm_get_event_timeout)(char *device, uint32_t *time);
+};
 
 /* Display help. */
 static void print_usage(char *name)
@@ -45,6 +58,7 @@ static void print_usage(char *name)
 	       "  -h                 Print this usage.\n"
 	       "  -l                 List registered devices.\n"
 	       "  -r                 Register for event (default).\n"
+	       "  -t <timeout>       (un)register for timeout event.\n"
 	       "  -u                 Unregister for event.\n"
 	       "\n", cmd);
 }
@@ -54,7 +68,7 @@ static int parse_argv(int argc, char **argv, char **dso_name_arg,
 		      char **device_arg, int *reg, int *list)
 {
 	int c;
-	const char *options = "d:hlru";
+	const char *options = "d:hlrt:u";
 
 	while ((c = getopt(argc, argv, options)) != -1) {
 		switch (c) {
@@ -70,6 +84,14 @@ static int parse_argv(int argc, char **argv, char **dso_name_arg,
 		case 'r':
 			*reg = 1;
 			break;
+		case 't':
+			events = TIMEOUT;
+			if (sscanf(optarg, "%"SCNu32, &timeout) != 1){
+				fprintf(stderr, "invalid timeout '%s'\n",
+					optarg);
+				timeout = 0;
+			}
+			break;
 		case 'u':
 			*reg = 0;
 			break;
@@ -92,21 +114,48 @@ static int parse_argv(int argc, char **argv, char **dso_name_arg,
 	return 1;
 }
 
+
+static int lookup_symbol(void *dl, void **symbol, const char *name)
+{
+	if ((*symbol = dlsym(dl, name)))
+		return 1;
+
+	fprintf(stderr, "error looking up %s symbol: %s\n", name, dlerror());
+
+	return 0;
+}
+
+static int lookup_symbols(void *dl, struct event_ops *e)
+{
+	return lookup_symbol(dl, (void *) &e->dm_register_for_event,
+			     "dm_register_for_event") &&
+	       lookup_symbol(dl, (void *) &e->dm_unregister_for_event,
+			     "dm_unregister_for_event") &&
+	       lookup_symbol(dl, (void *) &e->dm_get_registered_device,
+			     "dm_get_registered_device") &&
+	       lookup_symbol(dl, (void *) &e->dm_set_event_timeout,
+			     "dm_set_event_timeout") &&
+	       lookup_symbol(dl, (void *) &e->dm_get_event_timeout,
+			     "dm_get_event_timeout");
+}
+
 int main(int argc, char **argv)
 {
+	void *dl;
+	struct event_ops e;
 	int list = 0, next = 0, ret, reg = default_reg;
 	char *device, *device_arg = NULL, *dso_name, *dso_name_arg = NULL;
 
 	if (!parse_argv(argc, argv, &dso_name_arg, &device_arg, &reg, &list))
 		exit(EXIT_FAILURE);
 
-	if (device_arg){
+	if (device_arg) {
 		if (!(device = strdup(device_arg)))
 			exit(EXIT_FAILURE);
 	} else
 		device = NULL;
 
-	if (dso_name_arg){
+	if (dso_name_arg) {
 		if (!(dso_name = strdup(dso_name_arg)))
 			exit(EXIT_FAILURE);
 	} else {
@@ -118,34 +167,54 @@ int main(int argc, char **argv)
 	multilog_add_type(standard, NULL);
 	multilog_init_verbose(standard, _LOG_DEBUG);
 
+	if (!(dl = dlopen("libdmevent.so", RTLD_NOW))){
+		fprintf(stderr, "Cannot dlopen libdmevent.so: %s\n", dlerror());
+		goto out;
+	}
+	if (!(lookup_symbols(dl, &e)))
+		goto out;
 	if (list) {
-		do {
-			if (!(ret= dm_get_registered_device(&dso_name,
-							    &device,
-							    &events, next))) {
-				printf("%s %s 0x%x\n",
-				       dso_name, device, events);
+		while (1) {
+			if ((ret= e.dm_get_registered_device(&dso_name,
+							     &device,
+							     &events, next)))
+				break;
+			printf("%s %s 0x%x", dso_name, device, events);
+			if (events & TIMEOUT){
+				if ((ret = e.dm_get_event_timeout(device,
+							  	  &timeout))) {
+					ret = EXIT_FAILURE;
+					goto out;
+				}
+				printf(" %"PRIu32"\n", timeout);
+			} else
+				printf("\n");
+			if (device_arg)
+				break;
 
-				if (device_arg)
-					break;
-
-				next = 1;
-			}
-		} while (!ret);
+			next = 1;
+		}
 
 		ret = (ret && device_arg) ? EXIT_FAILURE : EXIT_SUCCESS;
 		goto out;
 	}
 
-	if ((ret = reg ? dm_register_for_event(dso_name, device, events) :
-			 dm_unregister_for_event(dso_name, device, events))) {
+	if ((ret = reg ? e.dm_register_for_event(dso_name, device, events) :
+			 e.dm_unregister_for_event(dso_name, device, events))) {
 		fprintf(stderr, "Failed to %sregister %s: %s\n",
 			reg ? "": "un", device, strerror(-ret));
 		ret = EXIT_FAILURE;
 	} else {
-		printf("%s %sregistered successfully.\n",
-		       device, reg ? "" : "un");
-		ret = EXIT_SUCCESS;
+		if (reg && (events & TIMEOUT) &&
+		    ((ret = e.dm_set_event_timeout(device, timeout)))){
+			fprintf(stderr, "Failed to set timeout for %s: %s\n",
+				device, strerror(-ret));
+			ret = EXIT_FAILURE;
+		} else {
+			printf("%s %sregistered successfully.\n",
+			       device, reg ? "" : "un");
+			ret = EXIT_SUCCESS;
+		}
 	}
 
    out:

daemons/dmeventd/dmeventd.c

@@ -33,6 +33,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <syslog.h>
 #include <sys/file.h>
 #include <sys/mman.h>
 #include <sys/types.h>
@@ -56,6 +57,7 @@
 #define	UNLINK_DSO(x)		UNLINK(x)
 #define	UNLINK_THREAD(x)	UNLINK(x)
 
+#define DAEMON_NAME  "dmeventd"
 
 /* Global mutex for list accesses. */
 static pthread_mutex_t mutex;
@@ -321,14 +323,9 @@ static void unlock(void)
 /* Check, if a device exists. */
 static int device_exists(char *device)
 {
-	int f;
+	struct stat st_buf;
 
-	if ((f = open(device, O_RDONLY)) == -1)
-		return 0;
-
-	close(f);
-
-	return 1;
+	return !stat(device, &st_buf) && S_ISBLK(st_buf.st_mode);
 }
 
 /*
@@ -963,9 +960,10 @@ static void comm_thread(struct fifos *fifos)
 		return;
 	}
 	
-	/* Loop forever and handle client requests sequentially. */
-	while (1)
+	/* Exit after last unregister. */
+	do {
 		process_request(fifos, &msg);
+	} while (!list_empty(&thread_registry));
 }
 
 /* Fork into the background and detach from our parent process. */
@@ -1020,7 +1018,7 @@ static void init_thread_signals(int hup)
 int main(void)
 {
 	struct fifos fifos;
-
+	struct sys_log logdata = {DAEMON_NAME, LOG_DAEMON};
 	/* Make sure, parent accepts HANGUP signal. */
 	init_thread_signals(1);
 
@@ -1036,8 +1034,9 @@ int main(void)
 		kill(getppid(), HANGUP);
 
 		multilog_clear_logging();
-		multilog_add_type(threaded_syslog, NULL);
-		multilog_init_verbose(threaded_syslog, _LOG_DEBUG);
+		multilog_add_type(std_syslog, &logdata);
+		multilog_init_verbose(std_syslog, _LOG_DEBUG);
+		multilog_async(1);
 
 		init_fifos(&fifos);
 		pthread_mutex_init(&mutex, NULL);

doc/example.conf

@@ -33,8 +33,12 @@ devices {
     # pattern, the device is accepted; otherwise if any name matches any 'r'
     # pattern it is rejected; otherwise it is accepted.
 
-    # Remember to run vgscan after you change this parameter to ensure 
-    # that the cache file gets regenerated (see below).
+    # Don't have more than one filter line active at once: only one gets used.
+
+    # Run vgscan after you change this parameter to ensure that
+    # the cache file gets regenerated (see below).
+    # If it doesn't do what you expect, check the output of 'vgscan -vvvv'.
+
 
     # By default we accept every block device:
     filter = [ "a/.*/" ]

lib/activate/activate.c

@@ -130,11 +130,11 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
 {
 	return 1;
 }
-int lv_activate(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
 	return 1;
 }
-int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
 	return 1;
 }
@@ -517,17 +517,15 @@ static int _lv_suspend_lv(struct logical_volume *lv)
  */
 int lvs_in_vg_activated(struct volume_group *vg)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 	int count = 0;
 
 	if (!activation())
 		return 0;
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & VISIBLE_LV)
-			count += (_lv_active(lv) == 1);
+	list_iterate_items(lvl, &vg->lvs) {
+		if (lvl->lv->status & VISIBLE_LV)
+			count += (_lv_active(lvl->lv) == 1);
 	}
 
 	return count;
@@ -535,17 +533,15 @@ int lvs_in_vg_activated(struct volume_group *vg)
 
 int lvs_in_vg_opened(struct volume_group *vg)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 	int count = 0;
 
 	if (!activation())
 		return 0;
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & VISIBLE_LV)
-			count += (_lv_open_count(lv) > 0);
+	list_iterate_items(lvl, &vg->lvs) {
+		if (lvl->lv->status & VISIBLE_LV)
+			count += (_lv_open_count(lvl->lv) > 0);
 	}
 
 	return count;
@@ -705,7 +701,8 @@ int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
 	return 1;
 }
 
-static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
+static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
+			int exclusive, int filter)
 {
 	struct logical_volume *lv;
 	struct lvinfo info;
@@ -736,6 +733,9 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
 	if (info.exists && !info.suspended)
 		return 1;
 
+	if (exclusive)
+		lv->status |= ACTIVATE_EXCL;
+
 	memlock_inc();
 	r = _lv_activate_lv(lv);
 	memlock_dec();
@@ -745,15 +745,15 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s, int filter)
 }
 
 /* Activate LV */
-int lv_activate(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
-	return _lv_activate(cmd, lvid_s, 0);
+	return _lv_activate(cmd, lvid_s, exclusive, 0);
 }
 
 /* Activate LV only if it passes filter */
-int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s)
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive)
 {
-	return _lv_activate(cmd, lvid_s, 1);
+	return _lv_activate(cmd, lvid_s, exclusive, 1);
 }
 
 int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)

lib/activate/activate.h

@@ -46,8 +46,9 @@ int lv_suspend(struct cmd_context *cmd, const char *lvid_s);
 int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s);
 int lv_resume(struct cmd_context *cmd, const char *lvid_s);
 int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s);
-int lv_activate(struct cmd_context *cmd, const char *lvid_s);
-int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s);
+int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive);
+int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s,
+			    int exclusive);
 int lv_deactivate(struct cmd_context *cmd, const char *lvid_s);
 
 int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv);

lib/activate/dev_manager.c

@@ -727,21 +727,24 @@ static int _emit_target_line(struct dev_manager *dm, struct dm_task *dmt,
 	return 1;
 }
 
-int compose_log_line(struct dev_manager *dm, struct lv_segment *seg,
-		     char *params, size_t paramsize, int *pos, int areas,
-		     uint32_t region_size)
+int build_dev_string(struct dev_manager *dm, char *dlid, char *devbuf,
+		     size_t bufsize, const char *desc)
 {
-	int tw;
+	struct dev_layer *dl;
 
-	tw = lvm_snprintf(params, paramsize, "core 1 %u %u ",
-			  region_size, areas);
-
-	if (tw < 0) {
-		stack;
-		return -1;
+	if (!(dl = hash_lookup(dm->layers, dlid))) {
+		log_error("%s device layer %s missing from hash",
+			  desc, dlid);
+		return 0;
 	}
 
-	*pos += tw;
+	if (!dm_format_dev(devbuf, bufsize, dl->info.major,
+			   dl->info.minor)) {
+		log_error("Failed to format %s device number for %s as dm "
+			  "target (%u,%u)",
+			  desc, dlid, dl->info.major, dl->info.minor);
+		return 0;
+	}
 
 	return 1;
 }
@@ -754,48 +757,39 @@ int compose_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 	int tw = 0;
 	const char *trailing_space;
 	uint64_t esize = seg->lv->vg->extent_size;
-	struct dev_layer *dl;
 	char devbuf[10];
 
 	for (s = start_area; s < areas; s++, *pos += tw) {
 		trailing_space = (areas - s - 1) ? " " : "";
-		if ((seg->area[s].type == AREA_PV &&
-		     (!seg->area[s].u.pv.pvseg ||
-		      !seg->area[s].u.pv.pvseg->pv ||
-		      !seg->area[s].u.pv.pvseg->pv->dev)) ||
-		    (seg->area[s].type == AREA_LV && !seg->area[s].u.lv.lv))
+		if ((seg_type(seg, s) == AREA_PV &&
+		     (!seg_pvseg(seg, s) ||
+		      !seg_pv(seg, s) ||
+		      !seg_dev(seg, s))) ||
+		    (seg_type(seg, s) == AREA_LV && !seg_lv(seg, s)))
 			tw = lvm_snprintf(params + *pos, paramsize - *pos,
 					  "%s 0%s", dm->stripe_filler,
 					  trailing_space);
-		else if (seg->area[s].type == AREA_PV)
+		else if (seg_type(seg, s) == AREA_PV)
 			tw = lvm_snprintf(params + *pos, paramsize - *pos,
 					  "%s %" PRIu64 "%s",
-					  dev_name(seg->area[s].u.pv.pvseg->
-						   pv->dev),
-					  (seg->area[s].u.pv.pvseg->pv->
-					   pe_start +
-					   (esize * seg->area[s].u.pv.pvseg->
-					    pe)),
+					  dev_name(seg_dev(seg, s)),
+					  (seg_pv(seg, s)->pe_start +
+					   (esize * seg_pe(seg, s))),
 					  trailing_space);
-		else {
-			if (!(dl = hash_lookup(dm->layers,
-					       seg->area[s].u.lv.lv->lvid.s))) {
-				log_error("device layer %s missing from hash",
-					  seg->area[s].u.lv.lv->lvid.s);
-				return 0;
-			}
-			if (!dm_format_dev
-			    (devbuf, sizeof(devbuf), dl->info.major,
-			     dl->info.minor)) {
-				log_error
-				    ("Failed to format device number as dm target (%u,%u)",
-				     dl->info.major, dl->info.minor);
+		else if (seg_type(seg, s) == AREA_LV) {
+			if (!build_dev_string(dm, seg_lv(seg, s)->lvid.s, devbuf,
+					      sizeof(devbuf), "LV")) {
+				stack;
 				return 0;
 			}
 			tw = lvm_snprintf(params + *pos, paramsize - *pos,
 					  "%s %" PRIu64 "%s", devbuf,
-					  esize * seg->area[s].u.lv.le,
+					  esize * seg_le(seg, s),
 					  trailing_space);
+		} else {
+			log_error("Internal error: Unassigned area found in LV %s.",
+				  seg->lv->name);
+			return 0;
 		}
 
 		if (tw < 0) {
@@ -842,14 +836,12 @@ static int _emit_target(struct dev_manager *dm, struct dm_task *dmt,
 static int _populate_vanilla(struct dev_manager *dm,
 			     struct dm_task *dmt, struct dev_layer *dl)
 {
-	struct list *segh;
 	struct lv_segment *seg;
 	struct logical_volume *lv = dl->lv;
 
 	dm->pvmove_mirror_count = 0u;
 
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv->segments) {
 		if (!_emit_target(dm, dmt, seg)) {
 			log_error("Unable to build table for '%s'", lv->name);
 			return 0;
@@ -864,22 +856,14 @@ static int _populate_origin(struct dev_manager *dm,
 {
 	char *real;
 	char params[PATH_MAX + 32];
-	struct dev_layer *dlr;
 
 	if (!(real = _build_dlid(dm->mem, dl->lv->lvid.s, "real"))) {
 		stack;
 		return 0;
 	}
 
-	if (!(dlr = hash_lookup(dm->layers, real))) {
-		log_error("Couldn't find real device layer %s in hash", real);
-		return 0;
-	}
-
-	if (!dm_format_dev(params, sizeof(params), dlr->info.major,
-			   dlr->info.minor)) {
-		log_error("Couldn't create origin device parameters for '%s'.",
-			  real);
+	if (!build_dev_string(dm, real, params, sizeof(params), "origin")) {
+		stack;
 		return 0;
 	}
 
@@ -900,7 +884,6 @@ static int _populate_snapshot(struct dev_manager *dm,
 	char *origin, *cow;
 	char params[PATH_MAX * 2 + 32];
 	struct lv_segment *snap_seg;
-	struct dev_layer *dlo, *dlc;
 	char devbufo[10], devbufc[10];
 	uint64_t size;
 
@@ -920,28 +903,13 @@ static int _populate_snapshot(struct dev_manager *dm,
 		return 0;
 	}
 
-	if (!(dlo = hash_lookup(dm->layers, origin))) {
-		log_error("Couldn't find origin device layer %s in hash",
-			  origin);
+	if (!build_dev_string(dm, origin, devbufo, sizeof(devbufo), "origin")) {
+		stack;
 		return 0;
 	}
 
-	if (!(dlc = hash_lookup(dm->layers, cow))) {
-		log_error("Couldn't find cow device layer %s in hash", cow);
-		return 0;
-	}
-
-	if (!dm_format_dev(devbufo, sizeof(devbufo), dlo->info.major,
-			   dlo->info.minor)) {
-		log_error("Couldn't create origin device parameters for '%s'.",
-			  snap_seg->origin->name);
-		return 0;
-	}
-
-	if (!dm_format_dev(devbufc, sizeof(devbufc), dlc->info.major,
-			   dlc->info.minor)) {
-		log_error("Couldn't create cow device parameters for '%s'.",
-			  snap_seg->cow->name);
+	if (!build_dev_string(dm, cow, devbufc, sizeof(devbufc), "cow")) {
+		stack;
 		return 0;
 	}
 
@@ -1201,7 +1169,6 @@ static int _expand_vanilla(struct dev_manager *dm, struct logical_volume *lv,
 	 * only one layer.
 	 */
 	struct dev_layer *dl, *dlr;
-	struct list *segh;
 	struct lv_segment *seg;
 	uint32_t s;
 
@@ -1219,19 +1186,30 @@ static int _expand_vanilla(struct dev_manager *dm, struct logical_volume *lv,
 		_set_flag(dl, TOPLEVEL);
 
 	/* Add dependencies for any LVs that segments refer to */
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv->segments) {
+		// When do we need? _set_flag(dl, REMOVE) on the log?
+		if (seg->log_lv &&
+		    !str_list_add(dm->mem, &dl->pre_create,
+				  _build_dlid(dm->mem, seg->log_lv->lvid.s,
+					      NULL))) {
+			stack;
+			return 0;
+		}
+
 		for (s = 0; s < seg->area_count; s++) {
-			if (seg->area[s].type != AREA_LV)
+			if (seg_type(seg, s) != AREA_LV)
 				continue;
 			if (!str_list_add(dm->mem, &dl->pre_create,
 					  _build_dlid(dm->mem,
-						      seg->area[s].u.lv.lv->
+						      seg_lv(seg, s)->
 						      lvid.s, NULL))) {
 				stack;
 				return 0;
 			}
+
+			// ? if (seg_lv(seg, s)->status & PVMOVE)
 			_set_flag(dl, NOPROPAGATE);
+			// When do we need? _set_flag(dl, REMOVE) 
 		}
 	}
 
@@ -1300,14 +1278,14 @@ static int _expand_origin(struct dev_manager *dm, struct logical_volume *lv)
 {
 	struct logical_volume *active;
 	struct lv_segment *snap_seg;
-	struct list *sh;
+	struct lv_list *lvl;
 
 	/*
 	 * We only need to create an origin layer if one of our
 	 * snapshots is in the active list
 	 */
-	list_iterate(sh, &dm->active_list) {
-		active = list_item(sh, struct lv_list)->lv;
+	list_iterate_items(lvl, &dm->active_list) {
+		active = lvl->lv;
 		if ((snap_seg = find_cow(active)) && (snap_seg->origin == lv))
 			return _expand_origin_real(dm, lv);
 	}
@@ -1382,11 +1360,19 @@ static int _expand_lv(struct dev_manager *dm, struct logical_volume *lv)
 	/*
 	 * FIXME: this doesn't cope with recursive snapshots yet.
 	 */
-	if ((snap_seg = find_cow(lv)))
+	if ((snap_seg = find_cow(lv))) {
+		if (lv->vg->status & CLUSTERED) {
+			log_error("Clustered snapshots are not yet supported");
+			return 0;
+		}
 		return _expand_snapshot(dm, lv, snap_seg);
-
-	else if (lv_is_origin(lv))
+	} else if (lv_is_origin(lv)) {
+		if (lv->vg->status & CLUSTERED) {
+			log_error("Clustered snapshots are not yet supported");
+			return 0;
+		}
 		return _expand_origin(dm, lv);
+	}
 
 	return _expand_vanilla(dm, lv, 0);
 }
@@ -1411,12 +1397,12 @@ static void _clear_marks(struct dev_manager *dm, int flag)
 static int _trace_layer_marks(struct dev_manager *dm, struct dev_layer *dl,
 			      int flag)
 {
-	struct list *sh;
+	struct str_list *strl;
 	const char *dlid;
 	struct dev_layer *dep;
 
-	list_iterate(sh, &dl->pre_create) {
-		dlid = list_item(sh, struct str_list)->str;
+	list_iterate_items(strl, &dl->pre_create) {
+		dlid = strl->str;
 
 		if (!(dep = hash_lookup(dm->layers, dlid))) {
 			log_error("Couldn't find device layer '%s'.", dlid);
@@ -1466,16 +1452,14 @@ static int _trace_all_marks(struct dev_manager *dm, int flag)
  */
 static int _mark_lvs(struct dev_manager *dm, struct list *lvs, int flag)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 	struct dev_layer *dl;
 
-	list_iterate(lvh, lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & SNAPSHOT)
+	list_iterate_items(lvl, lvs) {
+		if (lvl->lv->status & SNAPSHOT)
 			continue;
 
-		if (!(dl = _lookup(dm, lv->lvid.s, NULL))) {
+		if (!(dl = _lookup(dm, lvl->lv->lvid.s, NULL))) {
 			stack;
 			return 0;
 		}
@@ -1493,12 +1477,12 @@ static int _mark_lvs(struct dev_manager *dm, struct list *lvs, int flag)
 
 static int _suspend_parents(struct dev_manager *dm, struct dev_layer *dl)
 {
-	struct list *sh;
+	struct str_list *strl;
 	struct dev_layer *dep;
 	const char *dlid;
 
-	list_iterate(sh, &dl->pre_suspend) {
-		dlid = list_item(sh, struct str_list)->str;
+	list_iterate_items(strl, &dl->pre_suspend) {
+		dlid = strl->str;
 
 		if (!(dep = hash_lookup(dm->layers, dlid))) {
 			log_debug("_suspend_parents couldn't find device "
@@ -1527,12 +1511,12 @@ static int _suspend_parents(struct dev_manager *dm, struct dev_layer *dl)
 
 static int _resume_with_deps(struct dev_manager *dm, struct dev_layer *dl)
 {
-	struct list *sh;
+	struct str_list *strl;
 	struct dev_layer *dep;
 	const char *dlid;
 
-	list_iterate(sh, &dl->pre_create) {
-		dlid = list_item(sh, struct str_list)->str;
+	list_iterate_items(strl, &dl->pre_create) {
+		dlid = strl->str;
 
 		if (!(dep = hash_lookup(dm->layers, dlid))) {
 			log_debug("_resume_with_deps couldn't find device "
@@ -1565,7 +1549,7 @@ static int _resume_with_deps(struct dev_manager *dm, struct dev_layer *dl)
  */
 static int _create_rec(struct dev_manager *dm, struct dev_layer *dl)
 {
-	struct list *sh;
+	struct str_list *strl;
 	struct dev_layer *dep;
 	const char *dlid;
 	char *newname, *suffix;
@@ -1577,8 +1561,8 @@ static int _create_rec(struct dev_manager *dm, struct dev_layer *dl)
 		return 0;
 	}
 
-	list_iterate(sh, &dl->pre_create) {
-		dlid = list_item(sh, struct str_list)->str;
+	list_iterate_items(strl, &dl->pre_create) {
+		dlid = strl->str;
 
 		if (!(dep = hash_lookup(dm->layers, dlid))) {
 			log_error("Couldn't find device layer '%s'.", dlid);
@@ -1634,17 +1618,15 @@ static int _create_rec(struct dev_manager *dm, struct dev_layer *dl)
 
 static int _build_all_layers(struct dev_manager *dm, struct volume_group *vg)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 
 	/*
 	 * Build layers for complete vg.
 	 */
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & SNAPSHOT)
+	list_iterate_items(lvl, &vg->lvs) {
+		if (lvl->lv->status & SNAPSHOT)
 			continue;
-		if (!_expand_lv(dm, lv)) {
+		if (!_expand_lv(dm, lvl->lv)) {
 			stack;
 			return 0;
 		}
@@ -1684,15 +1666,15 @@ static int _populate_pre_suspend_lists(struct dev_manager *dm)
 {
 	struct hash_node *hn;
 	struct dev_layer *dl;
-	struct list *sh;
+	struct str_list *strl;
 	const char *dlid;
 	struct dev_layer *dep;
 
 	hash_iterate(hn, dm->layers) {
 		dl = hash_get_data(dm->layers, hn);
 
-		list_iterate(sh, &dl->pre_suspend) {
-			dlid = list_item(sh, struct str_list)->str;
+		list_iterate_items(strl, &dl->pre_suspend) {
+			dlid = strl->str;
 
 			if (!(dep = hash_lookup(dm->layers, dlid))) {
 				log_debug("_populate_pre_suspend_lists: "
@@ -1707,8 +1689,8 @@ static int _populate_pre_suspend_lists(struct dev_manager *dm)
 			}
 		}
 
-		list_iterate(sh, &dl->pre_create) {
-			dlid = list_item(sh, struct str_list)->str;
+		list_iterate_items(strl, &dl->pre_create) {
+			dlid = strl->str;
 
 			if (!(dep = hash_lookup(dm->layers, dlid))) {
 				log_debug("_populate_pre_suspend_lists: "
@@ -1733,6 +1715,7 @@ static int _populate_pre_suspend_lists(struct dev_manager *dm)
 static int _remove_old_layers(struct dev_manager *dm)
 {
 	int change;
+	struct dl_list *dll;
 	struct list *rh, *n;
 	struct dev_layer *dl;
 
@@ -1755,10 +1738,8 @@ static int _remove_old_layers(struct dev_manager *dm)
 	} while (change);
 
 	if (!list_empty(&dm->remove_list)) {
-		list_iterate(rh, &dm->remove_list) {
-			dl = list_item(rh, struct dl_list)->dl;
-			log_error("Couldn't deactivate device %s", dl->name);
-		}
+		list_iterate_items(dll, &dm->remove_list)
+			log_error("Couldn't deactivate device %s", dll->dl->name);
 		return 0;
 	}
 
@@ -1945,16 +1926,14 @@ static int _add_lv(struct pool *mem,
 static int _add_lvs(struct pool *mem,
 		    struct list *head, struct logical_volume *origin)
 {
-	struct logical_volume *lv;
 	struct lv_segment *snap_seg;
-	struct list *lvh;
+	struct lv_list *lvl;
 
-	list_iterate(lvh, &origin->vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & SNAPSHOT)
+	list_iterate_items(lvl, &origin->vg->lvs) {
+		if (lvl->lv->status & SNAPSHOT)
 			continue;
-		if ((snap_seg = find_cow(lv)) && snap_seg->origin == origin)
-			if (!_add_lv(mem, head, lv))
+		if ((snap_seg = find_cow(lvl->lv)) && snap_seg->origin == origin)
+			if (!_add_lv(mem, head, lvl->lv))
 				return 0;
 	}
 
@@ -1963,13 +1942,11 @@ static int _add_lvs(struct pool *mem,
 
 static void _remove_lv(struct list *head, struct logical_volume *lv)
 {
-	struct list *lvh;
 	struct lv_list *lvl;
 
-	list_iterate(lvh, head) {
-		lvl = list_item(lvh, struct lv_list);
+	list_iterate_items(lvl, head) {
 		if (lvl->lv == lv) {
-			list_del(lvh);
+			list_del(&lvl->list);
 			break;
 		}
 	}
@@ -1979,13 +1956,14 @@ static int _remove_lvs(struct dev_manager *dm, struct logical_volume *lv)
 {
 	struct logical_volume *active, *old_origin;
 	struct lv_segment *snap_seg;
-	struct list *sh, *active_head;
+	struct list *active_head;
+	struct lv_list *lvl;
 
 	active_head = &dm->active_list;
 
 	/* Remove any snapshots with given origin */
-	list_iterate(sh, active_head) {
-		active = list_item(sh, struct lv_list)->lv;
+	list_iterate_items(lvl, active_head) {
+		active = lvl->lv;
 		if ((snap_seg = find_cow(active)) && snap_seg->origin == lv) {
 			_remove_lv(active_head, active);
 		}
@@ -1999,8 +1977,8 @@ static int _remove_lvs(struct dev_manager *dm, struct logical_volume *lv)
 	old_origin = snap_seg->origin;
 
 	/* Was this the last active snapshot with this origin? */
-	list_iterate(sh, active_head) {
-		active = list_item(sh, struct lv_list)->lv;
+	list_iterate_items(lvl, active_head) {
+		active = lvl->lv;
 		if ((snap_seg = find_cow(active)) &&
 		    snap_seg->origin == old_origin) {
 			return 1;
@@ -2015,13 +1993,14 @@ static int _remove_suspended_lvs(struct dev_manager *dm,
 {
 	struct logical_volume *suspended;
 	struct lv_segment *snap_seg;
-	struct list *sh, *suspend_head;
+	struct list *suspend_head;
+	struct lv_list *lvl;
 
 	suspend_head = &dm->suspend_list;
 
 	/* Remove from list any snapshots with given origin */
-	list_iterate(sh, suspend_head) {
-		suspended = list_item(sh, struct lv_list)->lv;
+	list_iterate_items(lvl, suspend_head) {
+		suspended = lvl->lv;
 		if ((snap_seg = find_cow(suspended)) &&
 		    snap_seg->origin == lv) {
 			_remove_lv(suspend_head, suspended);
@@ -2036,13 +2015,13 @@ static int _remove_suspended_lvs(struct dev_manager *dm,
 static int _targets_present(struct dev_manager *dm, struct list *lvs)
 {
 	struct logical_volume *lv;
-	struct list *lvh, *segh;
+	struct lv_list *lvl;
 	struct segment_type *segtype;
 	struct lv_segment *seg;
 	int snapshots = 0, mirrors = 0;
 
-	list_iterate(lvh, lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
+	list_iterate_items(lvl, lvs) {
+		lv = lvl->lv;
 
 		if (!snapshots)
 			if (lv_is_cow(lv) || lv_is_origin(lv))
@@ -2053,8 +2032,7 @@ static int _targets_present(struct dev_manager *dm, struct list *lvs)
 				mirrors = 1;
 
 		if (lv->status & VIRTUAL) {
-			list_iterate(segh, &lv->segments) {
-				seg = list_item(segh, struct lv_segment);
+			list_iterate_items(seg, &lv->segments) {
 				if (seg->segtype->ops->target_present &&
 				    !seg->segtype->ops->target_present()) {
 					log_error("Can't expand LV: %s target "
@@ -2103,16 +2081,14 @@ static int _targets_present(struct dev_manager *dm, struct list *lvs)
 static int _fill_in_active_list(struct dev_manager *dm, struct volume_group *vg)
 {
 	char *dlid;
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 	struct dev_layer *dl;
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (lv->status & SNAPSHOT)
+	list_iterate_items(lvl, &vg->lvs) {
+		if (lvl->lv->status & SNAPSHOT)
 			continue;
 
-		if (!(dlid = _build_dlid(dm->mem, lv->lvid.s, NULL))) {
+		if (!(dlid = _build_dlid(dm->mem, lvl->lv->lvid.s, NULL))) {
 			stack;
 			return 0;
 		}
@@ -2121,16 +2097,16 @@ static int _fill_in_active_list(struct dev_manager *dm, struct volume_group *vg)
 		pool_free(dm->mem, dlid);
 
 		if (dl) {
-			log_debug("Found active lv %s%s", lv->name,
+			log_debug("Found active lv %s%s", lvl->lv->name,
 				  dl->info.suspended ? " (suspended)" : "");
 
-			if (!_add_lv(dm->mem, &dm->active_list, lv)) {
+			if (!_add_lv(dm->mem, &dm->active_list, lvl->lv)) {
 				stack;
 				return 0;
 			}
 
 			if (dl->info.suspended) {
-				if (!_add_lv(dm->mem, &dm->suspend_list, lv)) {
+				if (!_add_lv(dm->mem, &dm->suspend_list, lvl->lv)) {
 					stack;
 					return 0;
 				}

lib/activate/fs.c

@@ -180,7 +180,7 @@ static int _mk_link(const char *dev_dir, const char *vg_name,
 	}
 
 #ifdef HAVE_SELINUX
-        if (!set_selinux_context(lv_path)) {
+        if (!set_selinux_context(lv_path, S_IFLNK)) {
                 stack;
                 return 0;
         }

lib/activate/targets.h

@@ -23,8 +23,7 @@ int compose_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 		       char *params, size_t paramsize, int *pos,
 		       int start_area, int areas);
 
-int compose_log_line(struct dev_manager *dm, struct lv_segment *seg,
-		     char *params, size_t paramsize, int *pos, int areas,
-		     uint32_t region_size);
+int build_dev_string(struct dev_manager *dm, char *dlid, char *devbuf,
+		     size_t bufsize, const char *desc);
 
 #endif

lib/cache/lvmcache.c

@@ -104,8 +104,9 @@ struct lvmcache_vginfo *vginfo_from_vgname(const char *vgname)
 const struct format_type *fmt_from_vgname(const char *vgname)
 {
 	struct lvmcache_vginfo *vginfo;
+	struct lvmcache_info *info;
 	struct label *label;
-	struct list *ih, *devh, *tmp;
+	struct list *devh, *tmp;
 	struct list devs;
 	struct device_list *devl;
 
@@ -115,9 +116,9 @@ const struct format_type *fmt_from_vgname(const char *vgname)
 	/* This function is normally called before reading metadata so
  	 * we check cached labels here. Unfortunately vginfo is volatile. */
 	list_init(&devs);
-	list_iterate(ih, &vginfo->infos) {
-		devl = malloc(sizeof(*devl));
-		devl->dev = list_item(ih, struct lvmcache_info)->dev;
+	list_iterate_items(info, &vginfo->infos) {
+		devl = dbg_malloc(sizeof(*devl));
+		devl->dev = info->dev;
 		list_add(&devs, &devl->list);
 	}
 
@@ -125,7 +126,7 @@ const struct format_type *fmt_from_vgname(const char *vgname)
 		devl = list_item(devh, struct device_list);
 		label_read(devl->dev, &label);
 		list_del(&devl->list);
-		free(devl);
+		dbg_free(devl);
 	}
 
 	return vginfo->fmt;
@@ -186,7 +187,6 @@ int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)
 	struct label *label;
 	struct dev_iter *iter;
 	struct device *dev;
-	struct list *fmth;
 	struct format_type *fmt;
 
 	static int _scanning_in_progress = 0;
@@ -221,8 +221,7 @@ int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)
 	_has_scanned = 1;
 
 	/* Perform any format-specific scanning e.g. text files */
-	list_iterate(fmth, &cmd->formats) {
-		fmt = list_item(fmth, struct format_type);
+	list_iterate_items(fmt, &cmd->formats) {
 		if (fmt->ops->scan && !fmt->ops->scan(fmt))
 			goto out;
 	}
@@ -431,18 +430,16 @@ int lvmcache_update_vgname(struct lvmcache_info *info, const char *vgname)
 
 int lvmcache_update_vg(struct volume_group *vg)
 {
-	struct list *pvh;
-	struct physical_volume *pv;
+	struct pv_list *pvl;
 	struct lvmcache_info *info;
 	char pvid_s[ID_LEN + 1];
 	int vgid_updated = 0;
 
 	pvid_s[sizeof(pvid_s) - 1] = '\0';
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
-		strncpy(pvid_s, (char *) &pv->id, sizeof(pvid_s) - 1);
-		/* FIXME Could pv->dev->pvid ever be different? */
+	list_iterate_items(pvl, &vg->pvs) {
+		strncpy(pvid_s, (char *) &pvl->pv->id, sizeof(pvid_s) - 1);
+		/* FIXME Could pvl->pv->dev->pvid ever be different? */
 		if ((info = info_from_pvid(pvid_s))) {
 			lvmcache_update_vgname(info, vg->name);
 			if (!vgid_updated) {
@@ -498,17 +495,32 @@ struct lvmcache_info *lvmcache_add(struct labeller *labeller, const char *pvid,
 						 pvid, dev_name(dev),
 						 dev_name(existing->dev));
 				return NULL;
+			} else if (is_dm_major(MAJOR(existing->dev->dev)) &&
+				   !is_dm_major(MAJOR(dev->dev))) {
+				log_very_verbose("Ignoring duplicate PV %s on "
+						 "%s - using dm %s",
+						 pvid, dev_name(dev),
+						 dev_name(existing->dev));
+				return NULL;
 			} else if (MAJOR(existing->dev->dev) != md_major() &&
 				   MAJOR(dev->dev) == md_major())
 				log_very_verbose("Duplicate PV %s on %s - "
 						 "using md %s", pvid,
 						 dev_name(existing->dev),
 						 dev_name(dev));
+			else if (!is_dm_major(MAJOR(existing->dev->dev)) &&
+				 is_dm_major(MAJOR(dev->dev)))
+				log_very_verbose("Duplicate PV %s on %s - "
+						 "using dm %s", pvid,
+						 dev_name(existing->dev),
+						 dev_name(dev));
 			else
 				log_error("Found duplicate PV %s: using %s not "
 					  "%s", pvid, dev_name(dev),
 					  dev_name(existing->dev));
 		}
+		/* Switch over to new preferred device */
+		existing->dev = dev;
 		info = existing;
 		/* Has labeller changed? */
 		if (info->label->labeller != labeller) {

lib/commands/toolcontext.c

@@ -622,7 +622,6 @@ static int _init_formats(struct cmd_context *cmd)
 	const char *format;
 
 	struct format_type *fmt;
-	struct list *fmth;
 
 #ifdef HAVE_LIBDL
 	const struct config_node *cn;
@@ -689,8 +688,7 @@ static int _init_formats(struct cmd_context *cmd)
 	format = find_config_str(cmd->cft->root, "global/format",
 				 DEFAULT_FORMAT);
 
-	list_iterate(fmth, &cmd->formats) {
-		fmt = list_item(fmth, struct format_type);
+	list_iterate_items(fmt, &cmd->formats) {
 		if (!strcasecmp(fmt->name, format) ||
 		    (fmt->alias && !strcasecmp(fmt->alias, format))) {
 			cmd->default_settings.fmt = fmt;

lib/config/defaults.h

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

lib/datastruct/bitset.c

@@ -23,12 +23,21 @@ bitset_t bitset_create(struct pool *mem, unsigned num_bits)
 {
 	unsigned n = (num_bits / BITS_PER_INT) + 2;
 	size_t size = sizeof(int) * n;
-	unsigned *bs = pool_zalloc(mem, size);
+	bitset_t bs;
+	
+	if (mem)
+		bs = pool_zalloc(mem, size);
+	else
+		bs = dbg_malloc(size);
 
 	if (!bs)
 		return NULL;
 
 	*bs = num_bits;
+
+	if (!mem)
+		bit_clear_all(bs);
+
 	return bs;
 }
 

lib/datastruct/list.h

@@ -103,6 +103,14 @@ static inline int list_end(struct list *head, struct list *elem)
 	return elem->n == head;
 }
 
+/*
+ * Return first element of the list or NULL if empty
+ */
+static inline struct list *list_first(struct list *head)
+{
+	return (list_empty(head) ? NULL : head->n);
+}
+
 /*
  * Return last element of the list or NULL if empty
  */
@@ -194,6 +202,25 @@ static inline struct list *list_next(struct list *head, struct list *elem)
  */
 #define list_iterate_items(v, head) list_iterate_items_gen(v, (head), list)
 
+/*
+ * Walk a list backwards, setting 'v' in turn to the containing structure 
+ * of each item.
+ * The containing structure should be the same type as 'v'.
+ * The 'struct list' variable within the containing structure is 'field'.
+ */
+#define list_iterate_back_items_gen(v, head, field) \
+	for (v = list_struct_base((head)->p, typeof(*v), field); \
+	     &v->field != (head); \
+	     v = list_struct_base(v->field.p, typeof(*v), field))
+
+/*
+ * Walk a list backwards, setting 'v' in turn to the containing structure 
+ * of each item.
+ * The containing structure should be the same type as 'v'.
+ * The list should be 'struct list list' within the containing structure.
+ */
+#define list_iterate_back_items(v, head) list_iterate_back_items_gen(v, (head), list)
+
 /*
  * Return the number of elements in a list by walking it.
  */

lib/device/dev-cache.c

@@ -196,7 +196,7 @@ static int _compare_paths(const char *path0, const char *path1)
 static int _add_alias(struct device *dev, const char *path)
 {
 	struct str_list *sl = _alloc(sizeof(*sl));
-	struct list *ah;
+	struct str_list *strl;
 	const char *oldpath;
 	int prefer_old = 1;
 
@@ -206,8 +206,8 @@ static int _add_alias(struct device *dev, const char *path)
 	}
 
 	/* Is name already there? */
-	list_iterate(ah, &dev->aliases) {
-		if (!strcmp(list_item(ah, struct str_list)->str, path)) {
+	list_iterate_items(strl, &dev->aliases) {
+		if (!strcmp(strl->str, path)) {
 			log_debug("%s: Already in device cache", path);
 			return 1;
 		}
@@ -247,6 +247,8 @@ static int _insert_dev(const char *path, dev_t d)
 
 	/* Generate pretend device numbers for loopfiles */
 	if (!d) {
+		if (hash_lookup(_cache.names, path))
+			return 1;
 		d = ++loopfile_count;
 		loopfile = 1;
 	}
@@ -414,20 +416,16 @@ static int _insert(const char *path, int rec)
 
 static void _full_scan(int dev_scan)
 {
-	struct list *dh;
+	struct dir_list *dl;
 
 	if (_cache.has_scanned && !dev_scan)
 		return;
 
-	list_iterate(dh, &_cache.dirs) {
-		struct dir_list *dl = list_item(dh, struct dir_list);
+	list_iterate_items(dl, &_cache.dirs)
 		_insert_dir(dl->dir);
-	};
 
-	list_iterate(dh, &_cache.files) {
-		struct dir_list *dl = list_item(dh, struct dir_list);
+	list_iterate_items(dl, &_cache.files)
 		_insert_file(dl->dir);
-	};
 
 	_cache.has_scanned = 1;
 	init_full_scan_done(1);
@@ -631,6 +629,10 @@ struct device *dev_cache_get(const char *name, struct dev_filter *f)
 	if (!d) {
 		_insert(name, 0);
 		d = (struct device *) hash_lookup(_cache.names, name);
+		if (!d) {
+			_full_scan(0);
+			d = (struct device *) hash_lookup(_cache.names, name);
+		}
 	}
 
 	return (d && (!f || (d->flags & DEV_REGULAR) ||

lib/device/dev-io.c

@@ -320,15 +320,22 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 {
 	struct stat buf;
 	const char *name;
+	int need_excl = 0, need_rw = 0;
+
+	if ((flags & O_ACCMODE) == O_RDWR)
+		need_rw = 1;
+
+	if ((flags & O_EXCL))
+		need_excl = 1;
 
 	if (dev->fd >= 0) {
-		if ((dev->flags & DEV_OPENED_RW) ||
-		    ((flags & O_ACCMODE) != O_RDWR)) {
+		if (((dev->flags & DEV_OPENED_RW) || !need_rw) &&
+		    ((dev->flags & DEV_OPENED_EXCL) || !need_excl)) {
 			dev->open_count++;
 			return 1;
 		}
 
-		if (dev->open_count) {
+		if (dev->open_count && !need_excl) {
 			/* FIXME Ensure we never get here */
 			log_debug("WARNING: %s already opened read-only", 
 				  dev_name(dev));
@@ -397,11 +404,16 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 	dev->open_count++;
 	dev->flags &= ~DEV_ACCESSED_W;
 
-	if ((flags & O_ACCMODE) == O_RDWR)
+	if (need_rw)
 		dev->flags |= DEV_OPENED_RW;
 	else
 		dev->flags &= ~DEV_OPENED_RW;
 
+	if (need_excl)
+		dev->flags |= DEV_OPENED_EXCL;
+	else
+		dev->flags &= ~DEV_OPENED_EXCL;
+
 	if (!(dev->flags & DEV_REGULAR) &&
 	    ((fstat(dev->fd, &buf) < 0) || (buf.st_rdev != dev->dev))) {
 		log_error("%s: fstat failed: Has device name changed?", name);
@@ -420,8 +432,9 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 
 	list_add(&_open_devices, &dev->open_list);
 
-	log_debug("Opened %s %s%s", dev_name(dev),
+	log_debug("Opened %s %s%s%s", dev_name(dev),
 		  dev->flags & DEV_OPENED_RW ? "RW" : "RO",
+		  dev->flags & DEV_OPENED_EXCL ? " O_EXCL" : "",
 		  dev->flags & DEV_O_DIRECT ? " O_DIRECT" : "");
 
 	return 1;
@@ -445,6 +458,21 @@ int dev_open(struct device *dev)
 	return dev_open_flags(dev, flags, 1, 0);
 }
 
+int dev_test_excl(struct device *dev)
+{
+	int flags;
+	int r;
+
+	flags = vg_write_lock_held() ? O_RDWR : O_RDONLY;
+	flags |= O_EXCL;
+
+	r = dev_open_flags(dev, flags, 1, 1);
+	if (r)
+		dev_close_immediate(dev);
+
+	return r;
+}
+
 static void _close(struct device *dev)
 {
 	if (close(dev->fd))
@@ -479,6 +507,11 @@ static int _dev_close(struct device *dev, int immediate)
 	if (dev->open_count > 0)
 		dev->open_count--;
 
+	if (immediate && dev->open_count) {
+		log_debug("%s: Immediate close attempt while still referenced");
+		dev->open_count = 0;
+	}
+
 	/* FIXME lookup device in cache to get vgname and see if it's locked? */
 	if (immediate || (dev->open_count < 1 && !vgs_locked()))
 		_close(dev);

lib/device/device.h

@@ -23,8 +23,9 @@
 #define DEV_REGULAR		0x00000002	/* Regular file? */
 #define DEV_ALLOCED		0x00000004	/* dbg_malloc used */
 #define DEV_OPENED_RW		0x00000008	/* Opened RW */
-#define DEV_O_DIRECT		0x00000010	/* Use O_DIRECT */
-#define DEV_O_DIRECT_TESTED	0x00000020	/* DEV_O_DIRECT is reliable */
+#define DEV_OPENED_EXCL		0x00000010	/* Opened EXCL */
+#define DEV_O_DIRECT		0x00000020	/* Use O_DIRECT */
+#define DEV_O_DIRECT_TESTED	0x00000040	/* DEV_O_DIRECT is reliable */
 
 /*
  * All devices in LVM will be represented by one of these.
@@ -70,6 +71,7 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet);
 int dev_close(struct device *dev);
 int dev_close_immediate(struct device *dev);
 void dev_close_all(void);
+int dev_test_excl(struct device *dev);
 
 static inline int dev_fd(struct device *dev)
 {

lib/display/display.c

@@ -449,30 +449,31 @@ int lvdisplay_full(struct cmd_context *cmd, struct logical_volume *lv,
 
 void display_stripe(const struct lv_segment *seg, uint32_t s, const char *pre)
 {
-	switch (seg->area[s].type) {
+	switch (seg_type(seg, s)) {
 	case AREA_PV:
 		/* FIXME Re-check the conditions for 'Missing' */
 		log_print("%sPhysical volume\t%s", pre,
-			  seg->area[s].u.pv.pvseg->pv ?
-			  dev_name(seg->area[s].u.pv.pvseg->pv->dev) :
+			  seg_pv(seg, s) ?
+			  dev_name(seg_dev(seg, s)) :
 			    "Missing");
 
-		if (seg->area[s].u.pv.pvseg->pv)
+		if (seg_pv(seg, s))
 			log_print("%sPhysical extents\t%d to %d", pre,
-				  seg->area[s].u.pv.pvseg->pe,
-				  seg->area[s].u.pv.pvseg->pe +
-				      seg->area_len - 1);
+				  seg_pe(seg, s),
+				  seg_pe(seg, s) + seg->area_len - 1);
 		break;
 	case AREA_LV:
 		log_print("%sLogical volume\t%s", pre,
-			  seg->area[s].u.lv.lv ?
-			  seg->area[s].u.lv.lv->name : "Missing");
+			  seg_lv(seg, s) ?
+			  seg_lv(seg, s)->name : "Missing");
 
-		if (seg->area[s].u.lv.lv)
+		if (seg_lv(seg, s))
 			log_print("%sLogical extents\t%d to %d", pre,
-				  seg->area[s].u.lv.le,
-				  seg->area[s].u.lv.le + seg->area_len - 1);
-
+				  seg_le(seg, s),
+				  seg_le(seg, s) + seg->area_len - 1);
+		break;
+	case AREA_UNASSIGNED:
+		log_print("%sUnassigned area", pre);
 	}
 }
 

lib/filters/filter-persistent.c

@@ -204,16 +204,14 @@ static int _lookup_p(struct dev_filter *f, struct device *dev)
 	struct pfilter *pf = (struct pfilter *) f->private;
 	void *l = hash_lookup(pf->devices, dev_name(dev));
 	struct str_list *sl;
-	struct list *ah;
 
 	if (!l) {
 		l = pf->real->passes_filter(pf->real, dev) ?
 		    PF_GOOD_DEVICE : PF_BAD_DEVICE;
 
-		list_iterate(ah, &dev->aliases) {
-			sl = list_item(ah, struct str_list);
+		list_iterate_items(sl, &dev->aliases)
 			hash_insert(pf->devices, sl->str, l);
-		}
+
 	} else if (l == PF_BAD_DEVICE)
 			log_debug("%s: Skipping (cached)", dev_name(dev));
 

lib/filters/filter-regex.c

@@ -158,13 +158,11 @@ static int _build_matcher(struct rfilter *rf, struct config_value *val)
 
 static int _accept_p(struct dev_filter *f, struct device *dev)
 {
-	struct list *ah;
 	int m, first = 1, rejected = 0;
 	struct rfilter *rf = (struct rfilter *) f->private;
 	struct str_list *sl;
 
-	list_iterate(ah, &dev->aliases) {
-		sl = list_item(ah, struct str_list);
+	list_iterate_items(sl, &dev->aliases) {
 		m = matcher_run(rf->engine, sl->str);
 
 		if (m >= 0) {

lib/filters/filter.c

@@ -19,6 +19,7 @@
 #include "lvm-string.h"
 #include "config.h"
 #include "metadata.h"
+#include "bitset.h"
 
 #include <dirent.h>
 #include <unistd.h>
@@ -38,12 +39,18 @@ typedef struct {
 } device_info_t;
 
 static int _md_major = -1;
+static bitset_t _dm_bitset;
 
 int md_major(void)
 {
 	return _md_major;
 }
 
+int is_dm_major(int major)
+{
+	return bit(_dm_bitset, major) ? 1 : 0;
+}
+
 /*
  * Devices are only checked for partition tables if their minor number
  * is a multiple of the number corresponding to their type below
@@ -71,6 +78,7 @@ static const device_info_t device_info[] = {
 	{"iseries/vd", 8},	/* iSeries disks */
 	{"gnbd", 1},		/* Network block device */
 	{"ramdisk", 1},		/* RAM disk */
+	{"aoe", 16},		/* ATA over Ethernet */
 	{NULL, 0}
 };
 
@@ -180,6 +188,11 @@ static int _scan_proc_dev(const char *proc, const struct config_node *cn)
 		if (!strncmp("md", line + i, 2) && isspace(*(line + i + 2)))
 			_md_major = line_maj;
 
+		/* Look for dm devices */
+		if (!strncmp("device-mapper", line + i, 13) &&
+		    isspace(*(line + i + 13)))
+			bit_set(_dm_bitset, line_maj);
+
 		/* Go through the valid device names and if there is a
 		   match store max number of partitions */
 		for (j = 0; device_info[j].name != NULL; j++) {
@@ -250,6 +263,12 @@ struct dev_filter *lvm_type_filter_create(const char *proc,
 	f->destroy = lvm_type_filter_destroy;
 	f->private = NULL;
 
+	if (!(_dm_bitset = bitset_create(NULL, NUMBER_OF_MAJORS))) {
+		stack;
+		dbg_free(f);
+		return NULL;
+	}
+
 	if (!_scan_proc_dev(proc, cn)) {
 		stack;
 		return NULL;
@@ -260,6 +279,7 @@ struct dev_filter *lvm_type_filter_create(const char *proc,
 
 void lvm_type_filter_destroy(struct dev_filter *f)
 {
+	bitset_destroy(_dm_bitset);
 	dbg_free(f);
 	return;
 }

lib/filters/filter.h

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

lib/format1/disk-rep.c

@@ -424,11 +424,11 @@ struct disk_list *read_disk(const struct format_type *fmt, struct device *dev,
 
 static void _add_pv_to_list(struct list *head, struct disk_list *data)
 {
-	struct list *pvdh;
 	struct pv_disk *pvd;
+	struct disk_list *diskl;
 
-	list_iterate(pvdh, head) {
-		pvd = &list_item(pvdh, struct disk_list)->pvd;
+	list_iterate_items(diskl, head) {
+		pvd = &diskl->pvd;
 		if (!strncmp(data->pvd.pv_uuid, pvd->pv_uuid,
 			     sizeof(pvd->pv_uuid))) {
 			if (MAJOR(data->dev->dev) != md_major()) {
@@ -439,7 +439,7 @@ static void _add_pv_to_list(struct list *head, struct disk_list *data)
 			}
 			log_very_verbose("Duplicate PV %s - using md %s",
 					 pvd->pv_uuid, dev_name(data->dev));
-			list_del(pvdh);
+			list_del(&diskl->list);
 			break;
 		}
 	}
@@ -458,14 +458,14 @@ int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 	struct dev_iter *iter;
 	struct device *dev;
 	struct disk_list *data = NULL;
-	struct list *vgih;
 	struct lvmcache_vginfo *vginfo;
+	struct lvmcache_info *info;
 
 	/* Fast path if we already saw this VG and cached the list of PVs */
 	if (vg_name && (vginfo = vginfo_from_vgname(vg_name)) &&
 	    vginfo->infos.n) {
-		list_iterate(vgih, &vginfo->infos) {
-			dev = list_item(vgih, struct lvmcache_info)->dev;
+		list_iterate_items(info, &vginfo->infos) {
+			dev = info->dev;
 			if (dev && !(data = read_disk(fmt, dev, mem, vg_name)))
 				break;
 			_add_pv_to_list(head, data);
@@ -506,6 +506,9 @@ static int _write_vgd(struct disk_list *data)
 	struct vg_disk *vgd = &data->vgd;
 	uint64_t pos = data->pvd.vg_on_disk.base;
 
+	log_debug("Writing %s VG metadata to %s at %" PRIu64 " len %" PRIsize_t,
+		  data->pvd.vg_name, dev_name(data->dev), pos, sizeof(*vgd));
+
 	_xlate_vgd(vgd);
 	if (!dev_write(data->dev, pos, sizeof(*vgd), vgd))
 		fail;
@@ -518,18 +521,20 @@ static int _write_vgd(struct disk_list *data)
 static int _write_uuids(struct disk_list *data)
 {
 	struct uuid_list *ul;
-	struct list *uh;
 	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;
 	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;
 
-	list_iterate(uh, &data->uuids) {
+	list_iterate_items(ul, &data->uuids) {
 		if (pos >= end) {
 			log_error("Too many uuids to fit on %s",
 				  dev_name(data->dev));
 			return 0;
 		}
 
-		ul = list_item(uh, struct uuid_list);
+		log_debug("Writing %s uuidlist to %s at %" PRIu64 " len %"
+			  PRIsize_t, data->pvd.vg_name, dev_name(data->dev),
+			  pos, NAME_LEN);
+
 		if (!dev_write(data->dev, pos, NAME_LEN, ul->uuid))
 			fail;
 
@@ -541,6 +546,10 @@ static int _write_uuids(struct disk_list *data)
 
 static int _write_lvd(struct device *dev, uint64_t pos, struct lv_disk *disk)
 {
+	log_debug("Writing %s LV %s metadata to %s at %" PRIu64 " len %"
+		  PRIsize_t, disk->vg_name, disk->lv_name, dev_name(dev),
+		  pos, sizeof(*disk));
+
 	_xlate_lvd(disk);
 	if (!dev_write(dev, pos, sizeof(*disk), disk))
 		fail;
@@ -552,7 +561,7 @@ static int _write_lvd(struct device *dev, uint64_t pos, struct lv_disk *disk)
 
 static int _write_lvs(struct disk_list *data)
 {
-	struct list *lvh;
+	struct lvd_list *ll;
 	uint64_t pos, offset;
 
 	pos = data->pvd.lv_on_disk.base;
@@ -563,9 +572,7 @@ static int _write_lvs(struct disk_list *data)
 		return 0;
 	}
 
-	list_iterate(lvh, &data->lvds) {
-		struct lvd_list *ll = list_item(lvh, struct lvd_list);
-
+	list_iterate_items(ll, &data->lvds) {
 		offset = sizeof(struct lv_disk) * ll->lvd.lv_number;
 		if (offset + sizeof(struct lv_disk) > data->pvd.lv_on_disk.size) {
 			log_error("lv_number %d too large", ll->lvd.lv_number);
@@ -585,6 +592,10 @@ static int _write_extents(struct disk_list *data)
 	struct pe_disk *extents = data->extents;
 	uint64_t pos = data->pvd.pe_on_disk.base;
 
+	log_debug("Writing %s extents metadata to %s at %" PRIu64 " len %"
+		  PRIsize_t, data->pvd.vg_name, dev_name(data->dev),
+		  pos, len);
+
 	_xlate_extents(extents, data->pvd.pe_total);
 	if (!dev_write(data->dev, pos, len, extents))
 		fail;
@@ -617,6 +628,10 @@ static int _write_pvd(struct disk_list *data)
 	memset(buf, 0, size);
 	memcpy(buf, &data->pvd, sizeof(struct pv_disk));
 
+	log_debug("Writing %s PV metadata to %s at %" PRIu64 " len %"
+		  PRIsize_t, data->pvd.vg_name, dev_name(data->dev),
+		  pos, size);
+
 	_xlate_pvd((struct pv_disk *) buf);
 	if (!dev_write(data->dev, pos, size, buf)) {
 		dbg_free(buf);
@@ -704,11 +719,9 @@ static int _write_all_pvd(const struct format_type *fmt, struct disk_list *data)
  */
 int write_disks(const struct format_type *fmt, struct list *pvs)
 {
-	struct list *pvh;
 	struct disk_list *dl;
 
-	list_iterate(pvh, pvs) {
-		dl = list_item(pvh, struct disk_list);
+	list_iterate_items(dl, pvs) {
 		if (!(_write_all_pvd(fmt, dl)))
 			fail;
 

lib/format1/format1.c

@@ -46,9 +46,7 @@ static int _check_vgs(struct list *pvs, int *partial)
 	 * This means an active VG won't be affected if disks are inserted
 	 * bearing an exported VG with the same name.
 	 */
-	list_iterate(pvh, pvs) {
-		dl = list_item(pvh, struct disk_list);
-
+	list_iterate_items(dl, pvs) {
 		if (first_time) {
 			exported = dl->pvd.pv_status & VG_EXPORTED;
 			first_time = 0;
@@ -246,13 +244,10 @@ static int _flatten_vg(struct format_instance *fid, struct pool *mem,
 		       struct list *pvds, const char *dev_dir,
 		       struct dev_filter *filter)
 {
-	struct list *pvh;
 	struct pv_list *pvl;
 	struct disk_list *data;
 
-	list_iterate(pvh, &vg->pvs) {
-		pvl = list_item(pvh, struct pv_list);
-
+	list_iterate_items(pvl, &vg->pvs) {
 		if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir))) {
 			stack;
 			return 0;

lib/format1/import-export.c

@@ -87,7 +87,7 @@ int import_pv(struct pool *mem, struct device *dev,
 	pv->pe_size = pvd->pe_size;
 	pv->pe_start = pvd->pe_start;
 	pv->pe_count = pvd->pe_total;
-	pv->pe_alloc_count = pvd->pe_allocated;
+	pv->pe_alloc_count = 0;
 
 	list_init(&pv->tags);
 	list_init(&pv->segments);
@@ -241,7 +241,7 @@ int import_vg(struct pool *mem,
 
 	vg->extent_size = vgd->pe_size;
 	vg->extent_count = vgd->pe_total;
-	vg->free_count = vgd->pe_total - vgd->pe_allocated;
+	vg->free_count = vgd->pe_total;
 	vg->max_lv = vgd->lv_max;
 	vg->max_pv = vgd->pv_max;
 	vg->alloc = ALLOC_NORMAL;
@@ -382,14 +382,11 @@ static void _export_lv(struct lv_disk *lvd, struct volume_group *vg,
 int export_extents(struct disk_list *dl, uint32_t lv_num,
 		   struct logical_volume *lv, struct physical_volume *pv)
 {
-	struct list *segh;
 	struct pe_disk *ped;
 	struct lv_segment *seg;
 	uint32_t pe, s;
 
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
-
+	list_iterate_items(seg, &lv->segments) {
 		for (s = 0; s < seg->area_count; s++) {
 			if (!(seg->segtype->flags & SEG_FORMAT1_SUPPORT)) {
 				log_error("Segment type %s in LV %s: "
@@ -397,17 +394,16 @@ int export_extents(struct disk_list *dl, uint32_t lv_num,
 					  seg->segtype->name, lv->name);
 				return 0;
 			}
-			if (seg->area[s].type != AREA_PV) {
-				log_error("LV stripe found in LV %s: "
+			if (seg_type(seg, s) != AREA_PV) {
+				log_error("Non-PV stripe found in LV %s: "
 					  "unsupported by format1", lv->name);
 				return 0;
 			}
-			if (seg->area[s].u.pv.pvseg->pv != pv)
+			if (seg_pv(seg, s) != pv)
 				continue;	/* not our pv */
 
 			for (pe = 0; pe < (seg->len / seg->area_count); pe++) {
-				ped = &dl->extents[pe +
-						   seg->area[s].u.pv.pvseg->pe];
+				ped = &dl->extents[pe + seg_pe(seg, s)];
 				ped->lv_num = lv_num;
 				ped->le_num = (seg->le / seg->area_count) + pe +
 				    s * (lv->le_count / seg->area_count);
@@ -422,15 +418,11 @@ int import_pvs(const struct format_type *fmt, struct pool *mem,
 	       struct volume_group *vg,
 	       struct list *pvds, struct list *results, int *count)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	struct pv_list *pvl;
 
 	*count = 0;
-	list_iterate(pvdh, pvds) {
-
-		dl = list_item(pvdh, struct disk_list);
-
+	list_iterate_items(dl, pvds) {
 		if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) ||
 		    !(pvl->pv = pool_alloc(mem, sizeof(*pvl->pv)))) {
 			stack;
@@ -481,12 +473,9 @@ int import_lvs(struct pool *mem, struct volume_group *vg, struct list *pvds)
 	struct disk_list *dl;
 	struct lvd_list *ll;
 	struct lv_disk *lvd;
-	struct list *pvdh, *lvdh;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
-		list_iterate(lvdh, &dl->lvds) {
-			ll = list_item(lvdh, struct lvd_list);
+	list_iterate_items(dl, pvds) {
+		list_iterate_items(ll, &dl->lvds) {
 			lvd = &ll->lvd;
 
 			if (!find_lv(vg, lvd->lv_name) &&
@@ -505,7 +494,6 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 	       struct physical_volume *pv, const char *dev_dir)
 {
 	int r = 0;
-	struct list *lvh;
 	struct lv_list *ll;
 	struct lvd_list *lvdl;
 	size_t len;
@@ -532,8 +520,7 @@ int export_lvs(struct disk_list *dl, struct volume_group *vg,
 	}
 	memset(dl->extents, 0, len);
 
-	list_iterate(lvh, &vg->lvs) {
-		ll = list_item(lvh, struct lv_list);
+	list_iterate_items(ll, &vg->lvs) {
 		if (ll->lv->status & SNAPSHOT)
 			continue;
 
@@ -585,19 +572,17 @@ int import_snapshots(struct pool *mem, struct volume_group *vg,
 		     struct list *pvds)
 {
 	struct logical_volume *lvs[MAX_LV];
-	struct list *pvdh, *lvdh;
 	struct disk_list *dl;
+	struct lvd_list *ll;
 	struct lv_disk *lvd;
 	int lvnum;
 	struct logical_volume *org, *cow;
 
 	/* build an index of lv numbers */
 	memset(lvs, 0, sizeof(lvs));
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
-
-		list_iterate(lvdh, &dl->lvds) {
-			lvd = &(list_item(lvdh, struct lvd_list)->lvd);
+	list_iterate_items(dl, pvds) {
+		list_iterate_items(ll, &dl->lvds) {
+			lvd = &ll->lvd;
 
 			lvnum = lvd->lv_number;
 
@@ -619,11 +604,9 @@ int import_snapshots(struct pool *mem, struct volume_group *vg,
 	/*
 	 * Now iterate through yet again adding the snapshots.
 	 */
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
-
-		list_iterate(lvdh, &dl->lvds) {
-			lvd = &(list_item(lvdh, struct lvd_list)->lvd);
+	list_iterate_items(dl, pvds) {
+		list_iterate_items(ll, &dl->lvds) {
+			lvd = &ll->lvd;
 
 			if (!(lvd->lv_access & LV_SNAPSHOT))
 				continue;
@@ -657,10 +640,8 @@ int export_uuids(struct disk_list *dl, struct volume_group *vg)
 {
 	struct uuid_list *ul;
 	struct pv_list *pvl;
-	struct list *pvh;
 
-	list_iterate(pvh, &vg->pvs) {
-		pvl = list_item(pvh, struct pv_list);
+	list_iterate_items(pvl, &vg->pvs) {
 		if (!(ul = pool_alloc(dl->mem, sizeof(*ul)))) {
 			stack;
 			return 0;
@@ -680,14 +661,11 @@ int export_uuids(struct disk_list *dl, struct volume_group *vg)
  */
 void export_numbers(struct list *pvds, struct volume_group *vg)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	int pv_num = 1;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		dl->pvd.pv_number = pv_num++;
-	}
 }
 
 /*
@@ -695,26 +673,20 @@ void export_numbers(struct list *pvds, struct volume_group *vg)
  */
 void export_pv_act(struct list *pvds)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	int act = 0;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		if (dl->pvd.pv_status & PV_ACTIVE)
 			act++;
-	}
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		dl->vgd.pv_act = act;
-	}
 }
 
 int export_vg_number(struct format_instance *fid, struct list *pvds,
 		     const char *vg_name, struct dev_filter *filter)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	int vg_num;
 
@@ -723,10 +695,8 @@ int export_vg_number(struct format_instance *fid, struct list *pvds,
 		return 0;
 	}
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds)
 		dl->vgd.vg_number = vg_num;
-	}
 
 	return 1;
 }

lib/format1/import-extents.c

@@ -48,7 +48,6 @@ static struct hash_table *_create_lv_maps(struct pool *mem,
 					  struct volume_group *vg)
 {
 	struct hash_table *maps = hash_create(32);
-	struct list *llh;
 	struct lv_list *ll;
 	struct lv_map *lvm;
 
@@ -58,8 +57,7 @@ static struct hash_table *_create_lv_maps(struct pool *mem,
 		return NULL;
 	}
 
-	list_iterate(llh, &vg->lvs) {
-		ll = list_item(llh, struct lv_list);
+	list_iterate_items(ll, &vg->lvs) {
 		if (ll->lv->status & SNAPSHOT)
 			continue;
 
@@ -91,13 +89,12 @@ static struct hash_table *_create_lv_maps(struct pool *mem,
 static int _fill_lv_array(struct lv_map **lvs,
 			  struct hash_table *maps, struct disk_list *dl)
 {
-	struct list *lvh;
+	struct lvd_list *ll;
 	struct lv_map *lvm;
 
 	memset(lvs, 0, sizeof(*lvs) * MAX_LV);
-	list_iterate(lvh, &dl->lvds) {
-		struct lvd_list *ll = list_item(lvh, struct lvd_list);
 
+	list_iterate_items(ll, &dl->lvds) {
 		if (!(lvm = hash_lookup(maps, strrchr(ll->lvd.lv_name, '/')
 					+ 1))) {
 			log_err("Physical volume (%s) contains an "
@@ -118,15 +115,13 @@ static int _fill_lv_array(struct lv_map **lvs,
 static int _fill_maps(struct hash_table *maps, struct volume_group *vg,
 		      struct list *pvds)
 {
-	struct list *pvdh;
 	struct disk_list *dl;
 	struct physical_volume *pv;
 	struct lv_map *lvms[MAX_LV], *lvm;
 	struct pe_disk *e;
 	uint32_t i, lv_num, le;
 
-	list_iterate(pvdh, pvds) {
-		dl = list_item(pvdh, struct disk_list);
+	list_iterate_items(dl, pvds) {
 		pv = find_pv(vg, dl->dev);
 		e = dl->extents;
 
@@ -226,7 +221,7 @@ static int _read_linear(struct cmd_context *cmd, struct lv_map *lvm)
 			  lvm->map[le + len].pe == lvm->map[le].pe + len));
 
 		if (!(seg = alloc_lv_segment(cmd->mem, segtype, lvm->lv, le,
-					     len, 0, 0, 1, len, 0, 0))) {
+					     len, 0, 0, NULL, 1, len, 0, 0, 0))) {
 			log_error("Failed to allocate linear segment.");
 			return 0;
 		}
@@ -300,8 +295,9 @@ static int _read_stripes(struct cmd_context *cmd, struct lv_map *lvm)
 		if (!(seg = alloc_lv_segment(cmd->mem, segtype, lvm->lv,
 					     lvm->stripes * le,
 					     lvm->stripes * area_len,
-					     0, lvm->stripe_size, lvm->stripes,
-					     area_len, 0, 0))) {
+					     0, lvm->stripe_size, NULL,
+					     lvm->stripes,
+					     area_len, 0, 0, 0))) {
 			log_error("Failed to allocate striped segment.");
 			return 0;
 		}

lib/format1/vg_number.c

@@ -27,7 +27,6 @@
 int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 		       const char *candidate_vg, int *result)
 {
-	struct list *pvh;
 	struct list all_pvs;
 	struct disk_list *dl;
 	struct pool *mem = pool_create("lvm1 vg_number", 10 * 1024);
@@ -47,8 +46,7 @@ int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
 
 	memset(numbers, 0, sizeof(numbers));
 
-	list_iterate(pvh, &all_pvs) {
-		dl = list_item(pvh, struct disk_list);
+	list_iterate_items(dl, &all_pvs) {
 		if (!*dl->pvd.vg_name || !strcmp(dl->pvd.vg_name, candidate_vg))
 			continue;
 

lib/format_pool/disk_rep.c

@@ -57,12 +57,9 @@ static int __read_pool_disk(const struct format_type *fmt, struct device *dev,
 
 static void _add_pl_to_list(struct list *head, struct pool_list *data)
 {
-	struct list *pvdh;
 	struct pool_list *pl;
 
-	list_iterate(pvdh, head) {
-		pl = list_item(pvdh, struct pool_list);
-
+	list_iterate_items(pl, head) {
 		if (id_equal(&data->pv_uuid, &pl->pv_uuid)) {
 			char uuid[ID_LEN + 7];
 
@@ -76,7 +73,7 @@ static void _add_pl_to_list(struct list *head, struct pool_list *data)
 			}
 			log_very_verbose("Duplicate PV %s - using md %s",
 					 uuid, dev_name(data->dev));
-			list_del(pvdh);
+			list_del(&pl->list);
 			break;
 		}
 	}
@@ -247,11 +244,9 @@ 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 lvmcache_info *info;
 	struct pool_list *pl = NULL;
-	struct pool *tmpmem = NULL;
+	struct pool *tmpmem;
 
 	uint32_t sp_count = 0;
 	uint32_t *sp_devs = NULL;
@@ -264,16 +259,16 @@ static int _read_vg_pds(const struct format_type *fmt, struct pool *mem,
 		return 0;
 	}
 
-	list_iterate(vgih, &vginfo->infos) {
-		dev = list_item(vgih, struct lvmcache_info)->dev;
-		if (dev &&
-		    !(pl = read_pool_disk(fmt, dev, mem, vginfo->vgname)))
+	list_iterate_items(info, &vginfo->infos) {
+		if (info->dev &&
+		    !(pl = read_pool_disk(fmt, info->dev, mem, vginfo->vgname)))
 			    break;
 		/*
 		 * We need to keep track of the total expected number
 		 * of devices per subpool
 		 */
 		if (!sp_count) {
+			/* FIXME pl left uninitialised if !info->dev */
 			sp_count = pl->pd.pl_subpools;
 			if (!(sp_devs =
 			      pool_zalloc(tmpmem,
@@ -298,9 +293,8 @@ static int _read_vg_pds(const struct format_type *fmt, struct pool *mem,
 	}
 
 	*devcount = 0;
-	for (i = 0; i < sp_count; i++) {
+	for (i = 0; i < sp_count; i++)
 		*devcount += sp_devs[i];
-	}
 
 	pool_destroy(tmpmem);
 

lib/format_pool/format_pool.c

@@ -33,8 +33,6 @@
 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;
@@ -43,9 +41,7 @@ static struct user_subpool *_build_usp(struct list *pls, struct pool *mem,
 	 * FIXME: Need to do some checks here - I'm tempted to add a
 	 * user_pool structure and build the entire thing to check against.
 	 */
-	list_iterate(plhs, pls) {
-		pl = list_item(plhs, struct pool_list);
-
+	list_iterate_items(pl, pls) {
 		*sps = pl->pd.pl_subpools;
 		if (!usp && (!(usp = pool_zalloc(mem, sizeof(*usp) * (*sps))))) {
 			log_error("Unable to allocate %d subpool structures",
@@ -72,13 +68,13 @@ static struct user_subpool *_build_usp(struct list *pls, struct pool *mem,
 				  "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;

lib/format_pool/import_export.c

@@ -30,12 +30,9 @@
 
 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);
-
+	list_iterate_items(pl, pls) {
 		vg->extent_count +=
 		    ((pl->pd.pl_blocks) / POOL_PE_SIZE);
 
@@ -48,7 +45,7 @@ int import_pool_vg(struct volume_group *vg, struct pool *mem, struct list *pls)
 		get_pool_vg_uuid(&vg->id, &pl->pd);
 		vg->extent_size = POOL_PE_SIZE;
 		vg->status |= LVM_READ | LVM_WRITE | CLUSTERED | SHARED;
-		vg->free_count = 0;
+		vg->free_count = vg->extent_count;
 		vg->max_lv = 1;
 		vg->max_pv = POOL_MAX_DEVICES;
 		vg->alloc = ALLOC_NORMAL;
@@ -61,7 +58,6 @@ 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)
 {
 	struct pool_list *pl;
-	struct list *plhs;
 	struct lv_list *lvl = pool_zalloc(mem, sizeof(*lvl));
 	struct logical_volume *lv;
 
@@ -88,9 +84,7 @@ int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
 	list_init(&lv->segments);
 	list_init(&lv->tags);
 
-	list_iterate(plhs, pls) {
-		pl = list_item(plhs, struct pool_list);
-
+	list_iterate_items(pl, pls) {
 		lv->size += pl->pd.pl_blocks;
 
 		if (lv->name)
@@ -134,11 +128,8 @@ int import_pool_pvs(const struct format_type *fmt, struct volume_group *vg,
 {
 	struct pv_list *pvl;
 	struct pool_list *pl;
-	struct list *plhs;
-
-	list_iterate(plhs, pls) {
-		pl = list_item(plhs, struct pool_list);
 
+	list_iterate_items(pl, pls) {
 		if (!(pvl = pool_zalloc(mem, sizeof(*pvl)))) {
 			log_error("Unable to allocate pv list structure");
 			return 0;
@@ -180,7 +171,7 @@ int import_pool_pv(const struct format_type *fmt, struct pool *mem,
 	pv->pe_size = POOL_PE_SIZE;
 	pv->pe_start = POOL_PE_START;
 	pv->pe_count = pv->size / POOL_PE_SIZE;
-	pv->pe_alloc_count = pv->pe_count;
+	pv->pe_alloc_count = 0;
 
 	list_init(&pv->tags);
 	list_init(&pv->segments);
@@ -230,8 +221,8 @@ static int _add_stripe_seg(struct pool *mem,
 
 	if (!(seg = alloc_lv_segment(mem, segtype, lv, *le_cur, 
 				     area_len * usp->num_devs, 0,
-				     usp->striping, usp->num_devs, area_len,
-				     0, 0))) {
+				     usp->striping, NULL, usp->num_devs,
+				     area_len, 0, 0, 0))) {
 		log_error("Unable to allocate striped lv_segment structure");
 		return 0;
 	}
@@ -271,7 +262,8 @@ static int _add_linear_seg(struct pool *mem,
 
 		if (!(seg = alloc_lv_segment(mem, segtype, lv, *le_cur,
 					     area_len, 0, usp->striping,
-					     1, area_len, POOL_PE_SIZE, 0))) {
+					     NULL, 1, area_len,
+					     POOL_PE_SIZE, 0, 0))) {
 			log_error("Unable to allocate linear lv_segment "
 				  "structure");
 			return 0;
@@ -295,15 +287,12 @@ static int _add_linear_seg(struct pool *mem,
 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);
+	list_iterate_items(lvl, lvs) {
 		lv = lvl->lv;
 
 		if (lv->status & SNAPSHOT)
@@ -325,5 +314,4 @@ int import_pool_segments(struct list *lvs, struct pool *mem,
 	}
 
 	return 1;
-
 }

lib/format_text/archive.c

@@ -91,7 +91,6 @@ static int _split_vg(const char *filename, char *vgname, size_t vg_size,
 
 static void _insert_file(struct list *head, struct archive_file *b)
 {
-	struct list *bh;
 	struct archive_file *bf = NULL;
 
 	if (list_empty(head)) {
@@ -99,11 +98,9 @@ static void _insert_file(struct list *head, struct archive_file *b)
 		return;
 	}
 
-	/* index increases through list */
-	list_iterate(bh, head) {
-		bf = list_item(bh, struct archive_file);
-
-		if (bf->index > b->index) {
+	/* index reduces through list */
+	list_iterate_items(bf, head) {
+		if (b->index > bf->index) {
 			list_add(&bf->list, &b->list);
 			return;
 		}
@@ -153,8 +150,8 @@ static struct list *_scan_archive(struct pool *mem,
 	}
 
 	for (i = 0; i < count; i++) {
-		/* ignore dot files */
-		if (dirent[i]->d_name[0] == '.')
+		if (!strcmp(dirent[i]->d_name, ".") ||
+		    !strcmp(dirent[i]->d_name, ".."))
 			continue;
 
 		/* check the name is the correct format */
@@ -200,7 +197,6 @@ static struct list *_scan_archive(struct pool *mem,
 static void _remove_expired(struct list *archives, uint32_t archives_size,
 			    uint32_t retain_days, uint32_t min_archive)
 {
-	struct list *bh;
 	struct archive_file *bf;
 	struct stat sb;
 	time_t retain_time;
@@ -214,9 +210,7 @@ static void _remove_expired(struct list *archives, uint32_t archives_size,
 	retain_time = time(NULL) - (time_t) retain_days *SECS_PER_DAY;
 
 	/* Assume list is ordered oldest first (by index) */
-	list_iterate(bh, archives) {
-		bf = list_item(bh, struct archive_file);
-
+	list_iterate_items(bf, archives) {
 		/* Get the mtime of the file and unlink if too old */
 		if (stat(bf->path, &sb)) {
 			log_sys_error("stat", bf->path);
@@ -280,7 +274,7 @@ int archive_vg(struct volume_group *vg,
 	if (list_empty(archives))
 		ix = 0;
 	else {
-		last = list_item(archives->p, struct archive_file);
+		last = list_item(list_first(archives), struct archive_file);
 		ix = last->index + 1;
 	}
 
@@ -345,7 +339,7 @@ static void _display_archive(struct cmd_context *cmd, struct archive_file *af)
 
 int archive_list(struct cmd_context *cmd, const char *dir, const char *vgname)
 {
-	struct list *archives, *ah;
+	struct list *archives;
 	struct archive_file *af;
 
 	if (!(archives = _scan_archive(cmd->mem, vgname, dir))) {
@@ -356,11 +350,8 @@ int archive_list(struct cmd_context *cmd, const char *dir, const char *vgname)
 	if (list_empty(archives))
 		log_print("No archives found in %s.", dir);
 
-	list_iterate(ah, archives) {
-		af = list_item(ah, struct archive_file);
-
+	list_iterate_back_items(af, archives)
 		_display_archive(cmd, af);
-	}
 
 	pool_free(cmd->mem, archives);
 

lib/format_text/archiver.c

@@ -38,7 +38,8 @@ struct backup_params {
 int archive_init(struct cmd_context *cmd, const char *dir,
 		 unsigned int keep_days, unsigned int keep_min)
 {
-	if (!(cmd->archive_params = pool_zalloc(cmd->mem, sizeof(*cmd->archive_params)))) {
+	if (!(cmd->archive_params = pool_zalloc(cmd->libmem,
+						sizeof(*cmd->archive_params)))) {
 		log_error("archive_params alloc failed");
 		return 0;
 	}
@@ -149,7 +150,8 @@ int archive_display(struct cmd_context *cmd, const char *vg_name)
 
 int backup_init(struct cmd_context *cmd, const char *dir)
 {
-	if (!(cmd->backup_params = pool_zalloc(cmd->mem, sizeof(*cmd->archive_params)))) {
+	if (!(cmd->backup_params = pool_zalloc(cmd->libmem,
+					       sizeof(*cmd->archive_params)))) {
 		log_error("archive_params alloc failed");
 		return 0;
 	}

lib/format_text/export.c

@@ -30,7 +30,7 @@
 struct formatter;
 typedef int (*out_with_comment_fn) (struct formatter * f, const char *comment,
 				    const char *fmt, va_list ap);
-typedef void (*nl_fn) (struct formatter * f);
+typedef int (*nl_fn) (struct formatter * f);
 /*
  * The first half of this file deals with
  * exporting the vg, ie. writing it to a file.
@@ -42,7 +42,7 @@ struct formatter {
 	union {
 		FILE *fp;	/* where we're writing to */
 		struct {
-			char *buf;
+			char *start;
 			uint32_t size;
 			uint32_t used;
 		} buf;
@@ -95,22 +95,34 @@ static void _dec_indent(struct formatter *f)
 /*
  * Newline function for prettier layout.
  */
-static void _nl_file(struct formatter *f)
+static int _nl_file(struct formatter *f)
 {
 	fprintf(f->data.fp, "\n");
+
+	return 1;
 }
 
-static void _nl_raw(struct formatter *f)
+static int _nl_raw(struct formatter *f)
 {
-	if (f->data.buf.used >= f->data.buf.size - 1)
-		return;
+	char *newbuf;
 
-	*f->data.buf.buf = '\n';
-	f->data.buf.buf += 1;
+	/* If metadata doesn't fit, double the buffer size */
+	if (f->data.buf.used + 2 > f->data.buf.size) {
+		if (!(newbuf = dbg_realloc(f->data.buf.start,
+					   f->data.buf.size * 2))) {
+			stack;
+			return 0;
+		}
+		f->data.buf.start = newbuf;
+		f->data.buf.size *= 2;
+	}
+
+	*(f->data.buf.start + f->data.buf.used) = '\n';
 	f->data.buf.used += 1;
-	*f->data.buf.buf = '\0';
 
-	return;
+	*(f->data.buf.start + f->data.buf.used) = '\0';
+
+	return 1;
 }
 
 #define COMMENT_TAB 6
@@ -153,17 +165,27 @@ static int _out_with_comment_raw(struct formatter *f, const char *comment,
 				 const char *fmt, va_list ap)
 {
 	int n;
+	char *newbuf;
 
-	n = vsnprintf(f->data.buf.buf, f->data.buf.size - f->data.buf.used,
-		      fmt, ap);
+      retry:
+	n = vsnprintf(f->data.buf.start + f->data.buf.used,
+		      f->data.buf.size - f->data.buf.used, fmt, ap);
 
-	if (n < 0 || (n > f->data.buf.size - f->data.buf.used - 1))
-		return 0;
+	/* If metadata doesn't fit, double the buffer size */
+	if (n < 0 || (n + f->data.buf.used + 2 > f->data.buf.size)) {
+		if (!(newbuf = dbg_realloc(f->data.buf.start,
+					   f->data.buf.size * 2))) {
+			stack;
+			return 0;
+		}
+		f->data.buf.start = newbuf;
+		f->data.buf.size *= 2;
+		goto retry;
+	}
 
-	f->data.buf.buf += n;
 	f->data.buf.used += n;
 
-	f->nl(f);
+	outnl(f);
 
 	return 1;
 }
@@ -257,10 +279,10 @@ static int _print_header(struct formatter *f,
 	outf(f, "# Generated by LVM2: %s", ctime(&t));
 	outf(f, CONTENTS_FIELD " = \"" CONTENTS_VALUE "\"");
 	outf(f, FORMAT_VERSION_FIELD " = %d", FORMAT_VERSION_VALUE);
-	f->nl(f);
+	outnl(f);
 
 	outf(f, "description = \"%s\"", desc);
-	f->nl(f);
+	outnl(f);
 	outf(f, "creation_host = \"%s\"\t# %s %s %s %s %s", _utsname.nodename,
 	     _utsname.sysname, _utsname.nodename, _utsname.release,
 	     _utsname.version, _utsname.machine);
@@ -309,7 +331,7 @@ static int _print_vg(struct formatter *f, struct volume_group *vg)
 
 	/* Default policy is NORMAL; INHERIT is meaningless */
 	if (vg->alloc != ALLOC_NORMAL && vg->alloc != ALLOC_INHERIT) {
-		f->nl(f);
+		outnl(f);
 		outf(f, "allocation_policy = \"%s\"",
 		     get_alloc_string(vg->alloc));
 	}
@@ -330,7 +352,7 @@ static inline const char *_get_pv_name(struct formatter *f,
 
 static int _print_pvs(struct formatter *f, struct volume_group *vg)
 {
-	struct list *pvh;
+	struct pv_list *pvl;
 	struct physical_volume *pv;
 	char buffer[4096];
 	const char *name;
@@ -338,15 +360,15 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 	outf(f, "physical_volumes {");
 	_inc_indent(f);
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
+	list_iterate_items(pvl, &vg->pvs) {
+		pv = pvl->pv;
 
 		if (!(name = _get_pv_name(f, pv))) {
 			stack;
 			return 0;
 		}
 
-		f->nl(f);
+		outnl(f);
 		outf(f, "%s {", name);
 		_inc_indent(f);
 
@@ -360,7 +382,7 @@ static int _print_pvs(struct formatter *f, struct volume_group *vg)
 			stack;
 			return 0;
 		}
-		f->nl(f);
+		outnl(f);
 
 		if (!print_flags(pv->status, PV_FLAGS, buffer, sizeof(buffer))) {
 			stack;
@@ -407,7 +429,7 @@ static int _print_segment(struct formatter *f, struct volume_group *vg,
 		return 0;
 	}
 
-	f->nl(f);
+	outnl(f);
 	outf(f, "type = \"%s\"", seg->segtype->name);
 
 	if (!list_empty(&seg->tags)) {
@@ -436,29 +458,31 @@ int out_areas(struct formatter *f, const struct lv_segment *seg,
 	const char *name;
 	unsigned int s;
 
-	f->nl(f);
+	outnl(f);
 
 	outf(f, "%ss = [", type);
 	_inc_indent(f);
 
 	for (s = 0; s < seg->area_count; s++) {
-		switch (seg->area[s].type) {
+		switch (seg_type(seg, s)) {
 		case AREA_PV:
-			if (!(name = _get_pv_name(f, seg->area[s].u.pv.pvseg->
-						     pv))) {
+			if (!(name = _get_pv_name(f, seg_pv(seg, s)))) {
 				stack;
 				return 0;
 			}
 
 			outf(f, "\"%s\", %u%s", name,
-			     seg->area[s].u.pv.pvseg->pe,
+			     seg_pe(seg, s),
 			     (s == seg->area_count - 1) ? "" : ",");
 			break;
 		case AREA_LV:
 			outf(f, "\"%s\", %u%s",
-			     seg->area[s].u.lv.lv->name,
-			     seg->area[s].u.lv.le,
+			     seg_lv(seg, s)->name,
+			     seg_le(seg, s),
 			     (s == seg->area_count - 1) ? "" : ",");
+			break;
+		case AREA_UNASSIGNED:
+			return 0;
 		}
 	}
 
@@ -467,24 +491,68 @@ int out_areas(struct formatter *f, const struct lv_segment *seg,
 	return 1;
 }
 
-static int _count_segments(struct logical_volume *lv)
+static int _print_lv(struct formatter *f, struct logical_volume *lv)
 {
-	int r = 0;
-	struct list *segh;
+	struct lv_segment *seg;
+	char buffer[4096];
+	int seg_count;
 
-	list_iterate(segh, &lv->segments)
-	    r++;
+	outnl(f);
+	outf(f, "%s {", lv->name);
+	_inc_indent(f);
 
-	return r;
+	/* 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", list_size(&lv->segments));
+	outnl(f);
+
+	seg_count = 1;
+	list_iterate_items(seg, &lv->segments) {
+		if (!_print_segment(f, lv->vg, seg_count++, seg)) {
+			stack;
+			return 0;
+		}
+	}
+
+	_dec_indent(f);
+	outf(f, "}");
+
+	return 1;
 }
 
 static int _print_lvs(struct formatter *f, struct volume_group *vg)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
-	struct lv_segment *seg;
-	char buffer[4096];
-	int seg_count;
+	struct lv_list *lvl;
 
 	/*
 	 * Don't bother with an lv section if there are no lvs.
@@ -495,58 +563,25 @@ static int _print_lvs(struct formatter *f, struct volume_group *vg)
 	outf(f, "logical_volumes {");
 	_inc_indent(f);
 
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-
-		f->nl(f);
-		outf(f, "%s {", lv->name);
-		_inc_indent(f);
-
-		/* FIXME: Write full lvid */
-		if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {
+	/*
+	 * Write visible LVs first
+	 */
+	list_iterate_items(lvl, &vg->lvs) {
+		if (!(lvl->lv->status & VISIBLE_LV))
+			continue;
+		if (!_print_lv(f, lvl->lv)) {
 			stack;
 			return 0;
 		}
+	}
 
-		outf(f, "id = \"%s\"", buffer);
-
-		if (!print_flags(lv->status, LV_FLAGS, buffer, sizeof(buffer))) {
+	list_iterate_items(lvl, &vg->lvs) {
+		if ((lvl->lv->status & VISIBLE_LV))
+			continue;
+		if (!_print_lv(f, lvl->lv)) {
 			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, "}");
 	}
 
 	_dec_indent(f);
@@ -563,7 +598,7 @@ static int _print_lvs(struct formatter *f, struct volume_group *vg)
 static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 {
 	int count = 0;
-	struct list *pvh;
+	struct pv_list *pvl;
 	struct physical_volume *pv;
 	char buffer[32], *name;
 
@@ -577,8 +612,8 @@ static int _build_pv_names(struct formatter *f, struct volume_group *vg)
 		goto bad;
 	}
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
+	list_iterate_items(pvl, &vg->pvs) {
+		pv = pvl->pv;
 
 		/* FIXME But skip if there's already an LV called pv%d ! */
 		if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0) {
@@ -631,11 +666,11 @@ static int _text_vg_export(struct formatter *f,
 	if (!_print_vg(f, vg))
 		fail;
 
-	f->nl(f);
+	outnl(f);
 	if (!_print_pvs(f, vg))
 		fail;
 
-	f->nl(f);
+	outnl(f);
 	if (!_print_lvs(f, vg))
 		fail;
 
@@ -686,11 +721,10 @@ int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp)
 }
 
 /* Returns amount of buffer used incl. terminating NUL */
-int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
-		       uint32_t size)
+int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf)
 {
 	struct formatter *f;
-	int r;
+	int r = 0;
 
 	_init();
 
@@ -700,8 +734,13 @@ int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
 	}
 
 	memset(f, 0, sizeof(*f));
-	f->data.buf.buf = buf;
-	f->data.buf.size = size;
+
+	f->data.buf.size = 65536;	/* Initial metadata limit */
+	if (!(f->data.buf.start = dbg_malloc(f->data.buf.size))) {
+		log_error("text_export buffer allocation failed");
+		goto out;
+	}
+
 	f->indent = 0;
 	f->header = 0;
 	f->out_with_comment = &_out_with_comment_raw;
@@ -709,11 +748,12 @@ int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
 
 	if (!_text_vg_export(f, vg, desc)) {
 		stack;
-		r = 0;
+		dbg_free(f->data.buf.start);
 		goto out;
 	}
 
 	r = f->data.buf.used + 1;
+	*buf = f->data.buf.start;
 
       out:
 	dbg_free(f);
@@ -721,3 +761,4 @@ int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
 }
 
 #undef outf
+#undef outnl

lib/format_text/flags.c

@@ -52,9 +52,12 @@ static struct flag _lv_flags[] = {
 	{VISIBLE_LV, "VISIBLE"},
 	{PVMOVE, "PVMOVE"},
 	{LOCKED, "LOCKED"},
+	{MIRROR_IMAGE, NULL},
+	{MIRROR_LOG, NULL},
 	{MIRRORED, NULL},
 	{VIRTUAL, NULL},
 	{SNAPSHOT, NULL},
+	{ACTIVATE_EXCL, NULL},
 	{0, NULL}
 };
 

lib/format_text/format-text.c

@@ -341,19 +341,15 @@ static int _vg_write_raw(struct format_instance *fid, struct volume_group *vg,
 	struct mda_context *mdac = (struct mda_context *) mda->metadata_locn;
 	struct raw_locn *rlocn;
 	struct mda_header *mdah;
-	struct physical_volume *pv;
-	struct list *pvh;
+	struct pv_list *pvl;
 	int r = 0;
 	uint32_t new_wrap = 0, old_wrap = 0;
-
-	/* FIXME Essential fix! Make dynamic (realloc? pool?) */
-	char buf[65536];
+	char *buf = NULL;
 	int found = 0;
 
 	/* Ignore any mda on a PV outside the VG. vgsplit relies on this */
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
-		if (pv->dev == mdac->area.dev) {
+	list_iterate_items(pvl, &vg->pvs) {
+		if (pvl->pv->dev == mdac->area.dev) {
 			found = 1;
 			break;
 		}
@@ -375,7 +371,7 @@ static int _vg_write_raw(struct format_instance *fid, struct volume_group *vg,
 	rlocn = _find_vg_rlocn(&mdac->area, mdah, vg->name, 0);
 	mdac->rlocn.offset = _next_rlocn_offset(rlocn, mdah);
 
-	if (!(mdac->rlocn.size = text_vg_export_raw(vg, "", buf, sizeof(buf)))) {
+	if (!(mdac->rlocn.size = text_vg_export_raw(vg, "", &buf))) {
 		log_error("VG %s metadata writing failed", vg->name);
 		goto out;
 	}
@@ -435,6 +431,8 @@ static int _vg_write_raw(struct format_instance *fid, struct volume_group *vg,
 	if (!r && !dev_close(mdac->area.dev))
 		stack;
 
+	if (buf)
+		dbg_free(buf);
 	return r;
 }
 
@@ -446,15 +444,13 @@ static int _vg_commit_raw_rlocn(struct format_instance *fid,
 	struct mda_context *mdac = (struct mda_context *) mda->metadata_locn;
 	struct mda_header *mdah;
 	struct raw_locn *rlocn;
-	struct physical_volume *pv;
-	struct list *pvh;
+	struct pv_list *pvl;
 	int r = 0;
 	int found = 0;
 
 	/* Ignore any mda on a PV outside the VG. vgsplit relies on this */
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
-		if (pv->dev == mdac->area.dev) {
+	list_iterate_items(pvl, &vg->pvs) {
+		if (pvl->pv->dev == mdac->area.dev) {
 			found = 1;
 			break;
 		}
@@ -518,14 +514,12 @@ static int _vg_revert_raw(struct format_instance *fid, struct volume_group *vg,
 			  struct metadata_area *mda)
 {
 	struct mda_context *mdac = (struct mda_context *) mda->metadata_locn;
-	struct physical_volume *pv;
-	struct list *pvh;
+	struct pv_list *pvl;
 	int found = 0;
 
 	/* Ignore any mda on a PV outside the VG. vgsplit relies on this */
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
-		if (pv->dev == mdac->area.dev) {
+	list_iterate_items(pvl, &vg->pvs) {
+		if (pvl->pv->dev == mdac->area.dev) {
 			found = 1;
 			break;
 		}
@@ -672,7 +666,7 @@ static int _vg_write_file(struct format_instance *fid, struct volume_group *vg,
 		return 0;
 	}
 
-	if (fsync(fd)) {
+	if (fsync(fd) && (errno != EROFS) && (errno != EINVAL)) {
 		log_sys_error("fsync", tc->path_edit);
 		fclose(fp);
 		return 0;
@@ -784,7 +778,7 @@ static int _scan_file(const struct format_type *fmt)
 {
 	struct dirent *dirent;
 	struct dir_list *dl;
-	struct list *dlh, *dir_list;
+	struct list *dir_list;
 	char *tmp;
 	DIR *d;
 	struct volume_group *vg;
@@ -794,8 +788,7 @@ static int _scan_file(const struct format_type *fmt)
 
 	dir_list = &((struct mda_lists *) fmt->private)->dirs;
 
-	list_iterate(dlh, dir_list) {
-		dl = list_item(dlh, struct dir_list);
+	list_iterate_items(dl, dir_list) {
 		if (!(d = opendir(dl->dir))) {
 			log_sys_error("opendir", dl->dir);
 			continue;
@@ -883,7 +876,7 @@ int vgname_from_mda(const struct format_type *fmt, struct device_area *dev_area,
 static int _scan_raw(const struct format_type *fmt)
 {
 	struct raw_list *rl;
-	struct list *rlh, *raw_list;
+	struct list *raw_list;
 	char vgnamebuf[NAME_LEN + 2];
 	struct volume_group *vg;
 	struct format_instance fid;
@@ -893,9 +886,7 @@ static int _scan_raw(const struct format_type *fmt)
 	fid.fmt = fmt;
 	list_init(&fid.metadata_areas);
 
-	list_iterate(rlh, raw_list) {
-		rl = list_item(rlh, struct raw_list);
-
+	list_iterate_items(rl, raw_list) {
 		/* FIXME We're reading mdah twice here... */
 		if (vgname_from_mda(fmt, &rl->dev_area, vgnamebuf,
 				    sizeof(vgnamebuf))) {
@@ -925,6 +916,7 @@ static int _mda_setup(const struct format_type *fmt,
 	uint64_t start1, mda_size1;	/* First area - start of disk */
 	uint64_t start2, mda_size2;	/* Second area - end of disk */
 	uint64_t wipe_size = 8 << SECTOR_SHIFT;
+	size_t pagesize = getpagesize();
 
 	if (!pvmetadatacopies) {
 		/* Space available for PEs */
@@ -952,10 +944,21 @@ static int _mda_setup(const struct format_type *fmt,
 	/* Place mda straight after label area at start of disk */
 	start1 = LABEL_SCAN_SIZE;
 
+	/* Unless the space available is tiny, round to PAGE_SIZE boundary */
+	if ((!pe_start && !pe_end) ||
+	    ((pe_start > start1) && (pe_start - start1 >= MDA_SIZE_MIN))) {
+		mda_adjustment = start1 % pagesize;
+		if (mda_adjustment) {
+			start1 += (pagesize - mda_adjustment);
+			pv->size -= ((pagesize - mda_adjustment) >>
+				     SECTOR_SHIFT);
+		}
+	}
+
 	/* Ensure it's not going to be bigger than the disk! */
-	if (mda_size1 > disk_size) {
-		log_print("Warning: metadata area fills disk %s",
-			  dev_name(pv->dev));
+	if (start1 + mda_size1 > disk_size) {
+		log_print("Warning: metadata area fills disk leaving no "
+			  "space for data on %s.", dev_name(pv->dev));
 		/* Leave some free space for rounding */
 		/* Avoid empty data area as could cause tools problems */
 		mda_size1 = disk_size - start1 - alignment * 2;
@@ -1048,7 +1051,6 @@ static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 	struct label *label;
 	struct lvmcache_info *info;
 	struct mda_context *mdac;
-	struct list *mdash;
 	struct metadata_area *mda;
 	char buf[MDA_HEADER_SIZE];
 	struct mda_header *mdah = (struct mda_header *) buf;
@@ -1076,8 +1078,7 @@ static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 			del_mdas(&info->mdas);
 		else
 			list_init(&info->mdas);
-		list_iterate(mdash, mdas) {
-			mda = list_item(mdash, struct metadata_area);
+		list_iterate_items(mda, mdas) {
 			mdac = mda->metadata_locn;
 			log_debug("Creating metadata area on %s at sector %"
 				  PRIu64 " size %" PRIu64 " sectors",
@@ -1100,8 +1101,7 @@ static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 	/* Set pe_start to first aligned sector after any metadata 
 	 * areas that begin before pe_start */
 	pv->pe_start = PE_ALIGN;
-	list_iterate(mdash, &info->mdas) {
-		mda = list_item(mdash, struct metadata_area);
+	list_iterate_items(mda, &info->mdas) {
 		mdac = (struct mda_context *) mda->metadata_locn;
 		if (pv->dev == mdac->area.dev &&
 		    (mdac->area.start < (pv->pe_start << SECTOR_SHIFT)) &&
@@ -1125,8 +1125,7 @@ static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 		return 0;
 	}
 
-	list_iterate(mdash, &info->mdas) {
-		mda = list_item(mdash, struct metadata_area);
+	list_iterate_items(mda, &info->mdas) {
 		mdac = mda->metadata_locn;
 		memset(&buf, 0, sizeof(buf));
 		mdah->size = mdac->area.size;
@@ -1152,14 +1151,13 @@ static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
 static int _add_raw(struct list *raw_list, struct device_area *dev_area)
 {
 	struct raw_list *rl;
-	struct list *rlh;
 
 	/* Already present? */
-	list_iterate(rlh, raw_list) {
-		rl = list_item(rlh, struct raw_list);
+	list_iterate_items(rl, raw_list) {
 		/* FIXME Check size/overlap consistency too */
 		if (rl->dev_area.dev == dev_area->dev &&
-		    rl->dev_area.start == dev_area->start) return 1;
+		    rl->dev_area.start == dev_area->start)
+			return 1;
 	}
 
 	if (!(rl = dbg_malloc(sizeof(struct raw_list)))) {
@@ -1180,7 +1178,6 @@ static int _pv_read(const struct format_type *fmt, const char *pv_name,
 	struct lvmcache_info *info;
 	struct metadata_area *mda, *mda_new;
 	struct mda_context *mdac, *mdac_new;
-	struct list *mdah, *dah;
 	struct data_area_list *da;
 
 	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter))) {
@@ -1227,17 +1224,15 @@ static int _pv_read(const struct format_type *fmt, const char *pv_name,
 			  list_size(&info->das), dev_name(dev));
 		return 0;
 	}
-	list_iterate(dah, &info->das) {
-		da = list_item(dah, struct data_area_list);
+
+	list_iterate_items(da, &info->das)
 		pv->pe_start = da->disk_locn.offset >> SECTOR_SHIFT;
-	}
 
 	if (!mdas)
 		return 1;
 
 	/* Add copy of mdas to supplied list */
-	list_iterate(mdah, &info->mdas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &info->mdas) {
 		mdac = (struct mda_context *) mda->metadata_locn;
 		if (!(mda_new = pool_alloc(fmt->cmd->mem, sizeof(*mda_new)))) {
 			log_error("metadata_area allocation failed");
@@ -1327,7 +1322,7 @@ static int _pv_setup(const struct format_type *fmt,
 {
 	struct metadata_area *mda, *mda_new, *mda2;
 	struct mda_context *mdac, *mdac_new, *mdac2;
-	struct list *pvmdas, *pvmdash, *mdash;
+	struct list *pvmdas;
 	struct lvmcache_info *info;
 	int found;
 	uint64_t pe_end = 0;
@@ -1342,8 +1337,7 @@ static int _pv_setup(const struct format_type *fmt,
 		/* Iterate through all mdas on this PV */
 		if ((info = info_from_pvid(pv->dev->pvid))) {
 			pvmdas = &info->mdas;
-			list_iterate(pvmdash, pvmdas) {
-				mda = list_item(pvmdash, struct metadata_area);
+			list_iterate_items(mda, pvmdas) {
 				mdac =
 				    (struct mda_context *) mda->metadata_locn;
 
@@ -1351,10 +1345,7 @@ static int _pv_setup(const struct format_type *fmt,
 
 				/* Ensure it isn't already on list */
 				found = 0;
-				list_iterate(mdash, mdas) {
-					mda2 =
-					    list_item(mdash,
-						      struct metadata_area);
+				list_iterate_items(mda2, mdas) {
 					if (mda2->ops !=
 					    &_metadata_text_raw_ops) continue;
 					mdac2 =
@@ -1416,9 +1407,10 @@ static struct format_instance *_create_text_instance(const struct format_type
 	struct mda_context *mdac, *mdac_new;
 	struct dir_list *dl;
 	struct raw_list *rl;
-	struct list *dlh, *dir_list, *rlh, *raw_list, *mdas, *mdash, *infoh;
+	struct list *dir_list, *raw_list, *mdas;
 	char path[PATH_MAX];
 	struct lvmcache_vginfo *vginfo;
+	struct lvmcache_info *info;
 
 	if (!(fid = pool_alloc(fmt->cmd->mem, sizeof(*fid)))) {
 		log_error("Couldn't allocate format instance object.");
@@ -1440,8 +1432,7 @@ static struct format_instance *_create_text_instance(const struct format_type
 	} else {
 		dir_list = &((struct mda_lists *) fmt->private)->dirs;
 
-		list_iterate(dlh, dir_list) {
-			dl = list_item(dlh, struct dir_list);
+		list_iterate_items(dl, dir_list) {
 			if (lvm_snprintf(path, PATH_MAX, "%s/%s",
 					 dl->dir, vgname) < 0) {
 				log_error("Name too long %s/%s", dl->dir,
@@ -1461,9 +1452,7 @@ static struct format_instance *_create_text_instance(const struct format_type
 
 		raw_list = &((struct mda_lists *) fmt->private)->raws;
 
-		list_iterate(rlh, raw_list) {
-			rl = list_item(rlh, struct raw_list);
-
+		list_iterate_items(rl, raw_list) {
 			/* FIXME Cache this; rescan below if some missing */
 			if (!_raw_holds_vgname(fid, &rl->dev_area, vgname))
 				continue;
@@ -1491,10 +1480,9 @@ static struct format_instance *_create_text_instance(const struct format_type
 			stack;
 			goto out;
 		}
-		list_iterate(infoh, &vginfo->infos) {
-			mdas = &(list_item(infoh, struct lvmcache_info)->mdas);
-			list_iterate(mdash, mdas) {
-				mda = list_item(mdash, struct metadata_area);
+		list_iterate_items(info, &vginfo->infos) {
+			mdas = &info->mdas;
+			list_iterate_items(mda, mdas) {
 				mdac =
 				    (struct mda_context *) mda->metadata_locn;
 

lib/format_text/import-export.h

@@ -59,8 +59,7 @@ int print_tags(struct list *tags, char *buffer, size_t size);
 int read_tags(struct pool *mem, struct list *tags, struct config_value *cv);
 
 int text_vg_export_file(struct volume_group *vg, const char *desc, FILE *fp);
-int text_vg_export_raw(struct volume_group *vg, const char *desc, char *buf,
-		       uint32_t size);
+int text_vg_export_raw(struct volume_group *vg, const char *desc, char **buf);
 struct volume_group *text_vg_import_file(struct format_instance *fid,
 					 const char *file,
 					 time_t *when, char **desc);

lib/format_text/import_vsn1.c

@@ -223,12 +223,9 @@ static int _read_pv(struct format_instance *fid, struct pool *mem,
 
 static void _insert_segment(struct logical_volume *lv, struct lv_segment *seg)
 {
-	struct list *segh;
 	struct lv_segment *comp;
 
-	list_iterate(segh, &lv->segments) {
-		comp = list_item(segh, struct lv_segment);
-
+	list_iterate_items(comp, &lv->segments) {
 		if (comp->le > seg->le) {
 			list_add(&comp->list, &seg->list);
 			return;
@@ -291,8 +288,8 @@ static int _read_segment(struct pool *mem, struct volume_group *vg,
 	}
 
 	if (!(seg = alloc_lv_segment(mem, segtype, lv, start_extent,
-				     extent_count, 0, 0, area_count,
-				     extent_count, 0, 0))) {
+				     extent_count, 0, 0, NULL, area_count,
+				     extent_count, 0, 0, 0))) {
 		log_error("Segment allocation failed");
 		return 0;
 	}
@@ -326,7 +323,8 @@ static int _read_segment(struct pool *mem, struct volume_group *vg,
 }
 
 int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
-		      const struct config_node *cn, struct hash_table *pv_hash)
+		      const struct config_node *cn, struct hash_table *pv_hash,
+		      uint32_t flags)
 {
 	unsigned int s;
 	struct config_value *cv;
@@ -366,13 +364,9 @@ int text_import_areas(struct lv_segment *seg, const struct config_node *sn,
 				stack;
 				return 0;
 			}
-			/*
-			 * Adjust extent counts in the pv and vg.
-			 */
-			pv->pe_alloc_count += seg->area_len;
-			seg->lv->vg->free_count -= seg->area_len;
 		} else if ((lv1 = find_lv(seg->lv->vg, cv->v.str))) {
-			set_lv_segment_area_lv(seg, s, lv1, cv->next->v.i);
+			set_lv_segment_area_lv(seg, s, lv1, cv->next->v.i,
+					       flags);
 		} else {
 			log_error("Couldn't find volume '%s' "
 				  "for segment '%s'.",
@@ -436,7 +430,7 @@ static int _read_segments(struct pool *mem, struct volume_group *vg,
 	/*
 	 * Check there are no gaps or overlaps in the lv.
 	 */
-	if (!lv_check_segments(lv)) {
+	if (!check_lv_segments(lv)) {
 		stack;
 		return 0;
 	}

lib/format_text/layout.h

@@ -81,5 +81,6 @@ struct mda_context {
 #define FMTT_VERSION 1
 #define MDA_HEADER_SIZE 512
 #define LVM2_LABEL "LVM2 001"
+#define MDA_SIZE_MIN (8 * getpagesize())
 
 #endif

lib/format_text/text_export.h

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

lib/format_text/text_import.h

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

lib/format_text/text_label.c

@@ -39,7 +39,6 @@ static int _write(struct label *label, char *buf)
 	struct pv_header *pvhdr;
 	struct lvmcache_info *info;
 	struct disk_locn *pvh_dlocn_xl;
-	struct list *mdash, *dash;
 	struct metadata_area *mda;
 	struct mda_context *mdac;
 	struct data_area_list *da;
@@ -57,9 +56,7 @@ static int _write(struct label *label, char *buf)
 	pvh_dlocn_xl = &pvhdr->disk_areas_xl[0];
 
 	/* List of data areas (holding PEs) */
-	list_iterate(dash, &info->das) {
-		da = list_item(dash, struct data_area_list);
-
+	list_iterate_items(da, &info->das) {
 		pvh_dlocn_xl->offset = xlate64(da->disk_locn.offset);
 		pvh_dlocn_xl->size = xlate64(da->disk_locn.size);
 		pvh_dlocn_xl++;
@@ -71,8 +68,7 @@ static int _write(struct label *label, char *buf)
 	pvh_dlocn_xl++;
 
 	/* List of metadata area header locations */
-	list_iterate(mdash, &info->mdas) {
-		mda = list_item(mdash, struct metadata_area);
+	list_iterate_items(mda, &info->mdas) {
 		mdac = (struct mda_context *) mda->metadata_locn;
 
 		if (mdac->area.dev != info->dev)
@@ -198,7 +194,6 @@ static int _read(struct labeller *l, struct device *dev, char *buf,
 	struct lvmcache_info *info;
 	struct disk_locn *dlocn_xl;
 	uint64_t offset;
-	struct list *mdah;
 	struct metadata_area *mda;
 	char vgnamebuf[NAME_LEN + 2];
 	struct mda_context *mdac;
@@ -235,8 +230,7 @@ static int _read(struct labeller *l, struct device *dev, char *buf,
 		dlocn_xl++;
 	}
 
-	list_iterate(mdah, &info->mdas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &info->mdas) {
 		mdac = (struct mda_context *) mda->metadata_locn;
 		if (vgname_from_mda(info->fmt, &mdac->area, vgnamebuf,
 				    sizeof(vgnamebuf))) {

lib/label/label.c

@@ -98,14 +98,11 @@ int label_register_handler(const char *name, struct labeller *handler)
 
 struct labeller *label_get_handler(const char *name)
 {
-	struct list *lih;
 	struct labeller_i *li;
 
-	list_iterate(lih, &_labellers) {
-		li = list_item(lih, struct labeller_i);
+	list_iterate_items(li, &_labellers)
 		if (!strcmp(li->name, name))
 			return li->l;
-	}
 
 	return NULL;
 }
@@ -113,7 +110,6 @@ struct labeller *label_get_handler(const char *name)
 static struct labeller *_find_labeller(struct device *dev, char *buf,
 				       uint64_t *label_sector)
 {
-	struct list *lih;
 	struct labeller_i *li;
 	struct labeller *r = NULL;
 	struct label_header *lh;
@@ -166,8 +162,7 @@ static struct labeller *_find_labeller(struct device *dev, char *buf,
 				continue;
 		}
 
-		list_iterate(lih, &_labellers) {
-			li = list_item(lih, struct labeller_i);
+		list_iterate_items(li, &_labellers) {
 			if (li->l->ops->can_handle(li->l, (char *) lh, sector)) {
 				log_very_verbose("%s: %s label detected",
 						 dev_name(dev), li->name);
@@ -208,7 +203,6 @@ int label_remove(struct device *dev)
 	int r = 1;
 	uint64_t sector;
 	int wipe;
-	struct list *lih;
 	struct labeller_i *li;
 	struct label_header *lh;
 
@@ -244,8 +238,7 @@ int label_remove(struct device *dev)
 			if (xlate64(lh->sector_xl) == sector)
 				wipe = 1;
 		} else {
-			list_iterate(lih, &_labellers) {
-				li = list_item(lih, struct labeller_i);
+			list_iterate_items(li, &_labellers) {
 				if (li->l->ops->can_handle(li->l, (char *) lh,
 							   sector)) {
 					wipe = 1;

lib/locking/cluster_locking.c

@@ -327,8 +327,8 @@ static int _lock_for_cluster(unsigned char cmd, unsigned int flags, char *name)
 	args = alloca(len);
 	strcpy(args + 2, name);
 
-	args[0] = flags & 0xBF; /* Maskoff LOCAL flag */
-	args[1] = 0;		/* Not used now */
+	args[0] = flags & 0x7F; /* Maskoff lock flags */
+	args[1] = flags & 0xC0; /* Bitmap flags */
 
 	/*
 	 * VG locks are just that: locks, and have no side effects
@@ -339,7 +339,8 @@ static int _lock_for_cluster(unsigned char cmd, unsigned int flags, char *name)
 	 */
 	if (cmd == CLVMD_CMD_LOCK_VG ||
 	    (flags & LCK_TYPE_MASK) == LCK_EXCL ||
-	    (flags & LCK_LOCAL))
+	    (flags & LCK_LOCAL) ||
+	    !(flags & LCK_CLUSTER_VG))
 		node = ".";
 
 	status = _cluster_request(cmd, node, args, len,

lib/locking/file_locking.c

@@ -243,7 +243,7 @@ static int _file_lock_resource(struct cmd_context *cmd, const char *resource,
 			break;
 		case LCK_READ:
 			log_debug("Locking LV %s (R)", resource);
-			if (!lv_activate_with_filter(cmd, resource))
+			if (!lv_activate_with_filter(cmd, resource, 0))
 				return 0;
 			break;
 		case LCK_WRITE:
@@ -253,7 +253,7 @@ static int _file_lock_resource(struct cmd_context *cmd, const char *resource,
 			break;
 		case LCK_EXCL:
 			log_debug("Locking LV %s (EX)", resource);
-			if (!lv_activate_with_filter(cmd, resource))
+			if (!lv_activate_with_filter(cmd, resource, 1))
 				return 0;
 			break;
 		default:

lib/locking/locking.c

@@ -265,13 +265,10 @@ int lock_vol(struct cmd_context *cmd, const char *vol, int flags)
 /* Unlock list of LVs */
 int resume_lvs(struct cmd_context *cmd, struct list *lvs)
 {
-	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 
-	list_iterate(lvh, lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		resume_lv(cmd, lv->lvid.s);
-	}
+	list_iterate_items(lvl, lvs)
+		resume_lv(cmd, lvl->lv);
 
 	return 1;
 }
@@ -280,15 +277,14 @@ int resume_lvs(struct cmd_context *cmd, struct list *lvs)
 int suspend_lvs(struct cmd_context *cmd, struct list *lvs)
 {
 	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 
-	list_iterate(lvh, lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (!suspend_lv(cmd, lv->lvid.s)) {
-			log_error("Failed to suspend %s", lv->name);
-			list_uniterate(lvh, lvs, lvh) {
-				lv = list_item(lvh, struct lv_list)->lv;
-				resume_lv(cmd, lv->lvid.s);
+	list_iterate_items(lvl, lvs) {
+		if (!suspend_lv(cmd, lvl->lv)) {
+			log_error("Failed to suspend %s", lvl->lv->name);
+			list_uniterate(lvh, lvs, &lvl->list) {
+				lvl = list_item(lvh, struct lv_list);
+				resume_lv(cmd, lvl->lv);
 			}
 
 			return 0;
@@ -302,15 +298,14 @@ int suspend_lvs(struct cmd_context *cmd, struct list *lvs)
 int activate_lvs_excl(struct cmd_context *cmd, struct list *lvs)
 {
 	struct list *lvh;
-	struct logical_volume *lv;
+	struct lv_list *lvl;
 
-	list_iterate(lvh, lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
-		if (!activate_lv_excl(cmd, lv->lvid.s)) {
-			log_error("Failed to activate %s", lv->name);
-			list_uniterate(lvh, lvs, lvh) {
-				lv = list_item(lvh, struct lv_list)->lv;
-				activate_lv(cmd, lv->lvid.s);
+	list_iterate_items(lvl, lvs) {
+		if (!activate_lv_excl(cmd, lvl->lv)) {
+			log_error("Failed to activate %s", lvl->lv->name);
+			list_uniterate(lvh, lvs, &lvl->list) {
+				lvl = list_item(lvh, struct lv_list);
+				activate_lv(cmd, lvl->lv);
 			}
 
 			return 0;

lib/locking/locking.h

@@ -65,6 +65,7 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
 #define LCK_NONBLOCK	0x00000010	/* Don't block waiting for lock? */
 #define LCK_HOLD	0x00000020	/* Hold lock when lock_vol returns? */
 #define LCK_LOCAL	0x00000040	/* Don't propagate to other nodes */
+#define LCK_CLUSTER_VG	0x00000080	/* VG is clustered */
 
 /*
  * Common combinations
@@ -79,22 +80,27 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
 #define LCK_LV_ACTIVATE		(LCK_LV | LCK_READ | LCK_NONBLOCK)
 #define LCK_LV_DEACTIVATE	(LCK_LV | LCK_NULL | LCK_NONBLOCK)
 
+#define LCK_LV_CLUSTERED(lv)	\
+	(((lv)->vg->status & CLUSTERED) ? LCK_CLUSTER_VG : 0)
+
+#define lock_lv_vol(cmd, lv, flags)	\
+	lock_vol(cmd, (lv)->lvid.s, flags | LCK_LV_CLUSTERED(lv))
+
 #define unlock_vg(cmd, vol)	lock_vol(cmd, vol, LCK_VG_UNLOCK)
 
-#define resume_lv(cmd, vol)	lock_vol(cmd, vol, LCK_LV_RESUME)
-#define suspend_lv(cmd, vol)	lock_vol(cmd, vol, LCK_LV_SUSPEND | LCK_HOLD)
-#define deactivate_lv(cmd, vol)	lock_vol(cmd, vol, LCK_LV_DEACTIVATE)
-#define activate_lv(cmd, vol)	lock_vol(cmd, vol, LCK_LV_ACTIVATE | LCK_HOLD)
-#define activate_lv_excl(cmd, vol)	\
-				lock_vol(cmd, vol, LCK_LV_EXCLUSIVE | LCK_HOLD)
-#define activate_lv_local(cmd, vol)	\
-	lock_vol(cmd, vol, LCK_LV_ACTIVATE | LCK_HOLD | LCK_LOCAL)
-#define deactivate_lv_local(cmd, vol)	\
-	lock_vol(cmd, vol, LCK_LV_DEACTIVATE | LCK_LOCAL)
+#define resume_lv(cmd, lv)	lock_lv_vol(cmd, lv, LCK_LV_RESUME)
+#define suspend_lv(cmd, lv)	lock_lv_vol(cmd, lv, LCK_LV_SUSPEND | LCK_HOLD)
+#define deactivate_lv(cmd, lv)	lock_lv_vol(cmd, lv, LCK_LV_DEACTIVATE)
+#define activate_lv(cmd, lv)	lock_lv_vol(cmd, lv, LCK_LV_ACTIVATE | LCK_HOLD)
+#define activate_lv_excl(cmd, lv)	\
+				lock_lv_vol(cmd, lv, LCK_LV_EXCLUSIVE | LCK_HOLD)
+#define activate_lv_local(cmd, lv)	\
+	lock_lv_vol(cmd, lv, LCK_LV_ACTIVATE | LCK_HOLD | LCK_LOCAL)
+#define deactivate_lv_local(cmd, lv)	\
+	lock_lv_vol(cmd, lv, LCK_LV_DEACTIVATE | LCK_LOCAL)
 
 /* Process list of LVs */
 int suspend_lvs(struct cmd_context *cmd, struct list *lvs);
 int resume_lvs(struct cmd_context *cmd, struct list *lvs);
 int activate_lvs_excl(struct cmd_context *cmd, struct list *lvs);
 
-

lib/locking/locking_types.h

@@ -41,4 +41,5 @@ int init_no_locking(struct locking_type *locking, struct config_tree *cf);
 int init_file_locking(struct locking_type *locking, struct config_tree *cf);
 
 int init_external_locking(struct locking_type *locking, struct config_tree *cf);
+
 int init_cluster_locking(struct locking_type *locking, struct config_tree *cf);

lib/locking/no_locking.c

@@ -58,11 +58,11 @@ static int _no_lock_resource(struct cmd_context *cmd, const char *resource,
 		case LCK_UNLOCK:
 			return lv_resume_if_active(cmd, resource);
 		case LCK_READ:
-			return lv_activate_with_filter(cmd, resource);
+			return lv_activate_with_filter(cmd, resource, 0);
 		case LCK_WRITE:
 			return lv_suspend_if_active(cmd, resource);
 		case LCK_EXCL:
-			return lv_activate_with_filter(cmd, resource);
+			return lv_activate_with_filter(cmd, resource, 1);
 		default:
 			break;
 		}

lib/metadata/lv_alloc.h

@@ -22,17 +22,62 @@ struct lv_segment *alloc_lv_segment(struct pool *mem,
 				    uint32_t le, uint32_t len,
 				    uint32_t status,
 				    uint32_t stripe_size,
+				    struct logical_volume *log_lv,
 				    uint32_t area_count,
 				    uint32_t area_len,
 				    uint32_t chunk_size,
+				    uint32_t region_size,
 				    uint32_t extents_copied);
 
 struct lv_segment *alloc_snapshot_seg(struct logical_volume *lv,
-				      uint32_t allocated);
+				      uint32_t status, uint32_t old_le_count);
 
 int set_lv_segment_area_pv(struct lv_segment *seg, uint32_t area_num,
 			   struct physical_volume *pv, uint32_t pe);
 void set_lv_segment_area_lv(struct lv_segment *seg, uint32_t area_num,
-			    struct logical_volume *lv, uint32_t le);
+			    struct logical_volume *lv, uint32_t le,
+			    uint32_t flags);
+int move_lv_segment_area(struct lv_segment *seg_to, uint32_t area_to,
+			 struct lv_segment *seg_from, uint32_t area_from);
+void release_lv_segment_area(struct lv_segment *seg, uint32_t s,
+			     uint32_t area_reduction);
+
+struct alloc_handle;
+struct alloc_handle *allocate_extents(struct volume_group *vg,
+				      struct logical_volume *lv,
+                                      struct segment_type *segtype,
+                                      uint32_t stripes,
+                                      uint32_t mirrors, uint32_t log_count,
+				      uint32_t extents,
+                                      struct physical_volume *mirrored_pv,
+                                      uint32_t mirrored_pe,
+                                      uint32_t status,
+                                      struct list *allocatable_pvs,
+                                      alloc_policy_t alloc);
+
+int lv_add_segment(struct alloc_handle *ah,
+		   uint32_t first_area, uint32_t num_areas,
+		   struct logical_volume *lv,
+                   struct segment_type *segtype,
+                   uint32_t stripe_size,
+                   struct physical_volume *mirrored_pv,
+                   uint32_t mirrored_pe,
+                   uint32_t status,   
+		   uint32_t region_size,
+                   struct logical_volume *log_lv);
+
+int lv_add_log_segment(struct alloc_handle *ah, struct logical_volume *log_lv);
+int lv_add_virtual_segment(struct logical_volume *lv, uint32_t status,
+                           uint32_t extents, struct segment_type *segtype);
+int lv_add_mirror_segment(struct alloc_handle *ah,
+			  struct logical_volume *lv,
+			  struct logical_volume **sub_lvs,
+			  uint32_t mirrors,
+			  struct segment_type *segtype,
+			  uint32_t status,
+			  uint32_t region_size,
+			  struct logical_volume *log_lv);
+
+void alloc_destroy(struct alloc_handle *ah);
 
 #endif

lib/metadata/merge.c

@@ -58,11 +58,13 @@ int lv_merge_segments(struct logical_volume *lv)
 /*
  * Verify that an LV's segments are consecutive, complete and don't overlap.
  */
-int lv_check_segments(struct logical_volume *lv)
+int check_lv_segments(struct logical_volume *lv)
 {
 	struct lv_segment *seg;
 	uint32_t le = 0;
 	unsigned seg_count = 0;
+	int r = 1;
+	uint32_t area_multiplier, s;
 
 	list_iterate_items(seg, &lv->segments) {
 		seg_count++;
@@ -70,13 +72,65 @@ int lv_check_segments(struct logical_volume *lv)
 			log_error("LV %s invalid: segment %u should begin at "
 				  "LE %" PRIu32 " (found %" PRIu32 ").",
 				  lv->name, seg_count, le, seg->le);
-			return 0;
+			r = 0;
+		}
+
+		area_multiplier = segtype_is_striped(seg->segtype) ? 
+					seg->area_count : 1;
+
+		if (seg->area_len * area_multiplier != seg->len) {
+			log_error("LV %s: segment %u has inconsistent "
+				  "area_len %u",
+				  lv->name, seg_count, seg->area_len);
+			r = 0;
+		}
+
+		for (s = 0; s < seg->area_count; s++) {
+			if (seg_type(seg, s) == AREA_UNASSIGNED) {
+				log_error("LV %s: segment %u has unassigned "
+					  "area %u.",
+					  lv->name, seg_count, s);
+				r = 0;
+			} else if (seg_type(seg, s) == AREA_PV) {
+				if (!seg_pvseg(seg, s) ||
+				    seg_pvseg(seg, s)->lvseg != seg ||
+				    seg_pvseg(seg, s)->lv_area != s) {
+					log_error("LV %s: segment %u has "
+						  "inconsistent PV area %u",
+						  lv->name, seg_count, s);
+					r = 0;
+				}
+			} else {
+				if (!seg_lv(seg, s) ||
+				    seg_lv(seg, s)->vg != lv->vg ||
+				    seg_lv(seg, s) == lv) {
+					log_error("LV %s: segment %u has "
+						  "inconsistent LV area %u",
+						  lv->name, seg_count, s);
+					r = 0;
+				}
+/* FIXME I don't think this ever holds?
+				if (seg_le(seg, s) != le) {
+					log_error("LV %s: segment %u has "
+						  "inconsistent LV area %u "
+						  "size",
+						  lv->name, seg_count, s);
+					r = 0;
+				}
+ */
+			}
 		}
 
 		le += seg->len;
 	}
 
-	return 1;
+	if (le != lv->le_count) {
+		log_error("LV %s: inconsistent LE count %u != %u",
+			  lv->name, le, lv->le_count);
+		r = 0;
+	}
+
+	return r;
 }
 
 /*
@@ -101,8 +155,9 @@ static int _lv_split_segment(struct logical_volume *lv, struct lv_segment *seg,
 	if (!(split_seg = alloc_lv_segment(lv->vg->cmd->mem, seg->segtype,
 					   seg->lv, seg->le, seg->len,
 					   seg->status, seg->stripe_size,
+					   seg->log_lv,
 					   seg->area_count, seg->area_len,
-					   seg->chunk_size,
+					   seg->chunk_size, seg->region_size,
 					   seg->extents_copied))) {
 		log_error("Couldn't allocate cloned LV segment.");
 		return 0;
@@ -128,38 +183,38 @@ static int _lv_split_segment(struct logical_volume *lv, struct lv_segment *seg,
 
 	/* Adjust the PV mapping */
 	for (s = 0; s < seg->area_count; s++) {
-		split_seg->area[s].type = seg->area[s].type;
+		seg_type(split_seg, s) = seg_type(seg, s);
 
 		/* Split area at the offset */
-		switch (seg->area[s].type) {
+		switch (seg_type(seg, s)) {
 		case AREA_LV:
-			split_seg->area[s].u.lv.lv = seg->area[s].u.lv.lv;
-			split_seg->area[s].u.lv.le =
-			    seg->area[s].u.lv.le + seg->area_len;
+			seg_lv(split_seg, s) = seg_lv(seg, s);
+			seg_le(split_seg, s) =
+			    seg_le(seg, s) + seg->area_len;
 			log_debug("Split %s:%u[%u] at %u: %s LE %u", lv->name,
-				  seg->le, s, le, seg->area[s].u.lv.lv->name,
-				  split_seg->area[s].u.lv.le);
+				  seg->le, s, le, seg_lv(seg, s)->name,
+				  seg_le(split_seg, s));
 			break;
 
 		case AREA_PV:
-			if (!assign_peg_to_lvseg(seg->area[s].u.pv.pvseg->pv,
-						 seg->area[s].u.pv.pvseg->pe +
+			if (!(seg_pvseg(split_seg, s) =
+			     assign_peg_to_lvseg(seg_pv(seg, s),
+						 seg_pe(seg, s) +
 						     seg->area_len,
-						 seg->area[s].u.pv.pvseg->len -
+						 seg_pvseg(seg, s)->len -
 						     seg->area_len,
-						 split_seg, s)) {
+						 split_seg, s))) {
 				stack;
 				return 0;
 			}
 			log_debug("Split %s:%u[%u] at %u: %s PE %u", lv->name,
 				  seg->le, s, le,
-				  dev_name(seg->area[s].u.pv.pvseg->pv->dev),
-				  split_seg->area[s].u.pv.pvseg->pe);
+				  dev_name(seg_dev(seg, s)),
+				  seg_pe(split_seg, s));
 			break;
 
-		default:
-			log_error("Unrecognised segment type %u",
-				  seg->area[s].type);
+		case AREA_UNASSIGNED:
+			log_error("Unassigned area %u found in segment", s);
 			return 0;
 		}
 	}
@@ -192,5 +247,10 @@ int lv_split_segment(struct logical_volume *lv, uint32_t le)
 		return 0;
 	}
 
+	if (!vg_validate(lv->vg)) {
+		stack;
+		return 0;
+	}
+
 	return 1;
 }

lib/metadata/metadata.c

@@ -139,7 +139,6 @@ int get_pv_from_vg_by_id(const struct format_type *fmt, const char *vg_name,
 			 const char *id, struct physical_volume *pv)
 {
 	struct volume_group *vg;
-	struct list *pvh;
 	struct pv_list *pvl;
 	int consistent = 0;
 
@@ -153,8 +152,7 @@ int get_pv_from_vg_by_id(const struct format_type *fmt, const char *vg_name,
 		log_error("Warning: Volume group %s is not consistent",
 			  vg_name);
 
-	list_iterate(pvh, &vg->pvs) {
-		pvl = list_item(pvh, struct pv_list);
+	list_iterate_items(pvl, &vg->pvs) {
 		if (id_equal(&pvl->pv->id, (const struct id *) id)) {
 			if (!_copy_pv(pv, pvl->pv)) {
 				stack;
@@ -171,19 +169,17 @@ int vg_rename(struct cmd_context *cmd, struct volume_group *vg,
 	      const char *new_name)
 {
 	struct pool *mem = cmd->mem;
-	struct physical_volume *pv;
-	struct list *pvh;
+	struct pv_list *pvl;
 
 	if (!(vg->name = pool_strdup(mem, new_name))) {
 		log_error("vg->name allocation failed for '%s'", new_name);
 		return 0;
 	}
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
-		if (!(pv->vg_name = pool_strdup(mem, new_name))) {
+	list_iterate_items(pvl, &vg->pvs) {
+		if (!(pvl->pv->vg_name = pool_strdup(mem, new_name))) {
 			log_error("pv->vg_name allocation failed for '%s'",
-				  dev_name(pv->dev));
+				  dev_name(pvl->pv->dev));
 			return 0;
 		}
 	}
@@ -441,10 +437,10 @@ int vg_change_pesize(struct cmd_context *cmd, struct volume_group *vg,
 
 			/* foreach area */
 			for (s = 0; s < seg->area_count; s++) {
-				switch (seg->area[s].type) {
+				switch (seg_type(seg, s)) {
 				case AREA_PV:
 					if (!_recalc_extents
-					    (&seg->area[s].u.pv.pvseg->pe,
+					    (&seg_pe(seg, s),
 					     lv->name,
 					     " pvseg start", old_size,
 					     new_size)) {
@@ -452,7 +448,7 @@ int vg_change_pesize(struct cmd_context *cmd, struct volume_group *vg,
 						return 0;
 					}
 					if (!_recalc_extents
-					    (&seg->area[s].u.pv.pvseg->len,
+					    (&seg_pvseg(seg, s)->len,
 					     lv->name,
 					     " pvseg length", old_size,
 					     new_size)) {
@@ -462,16 +458,16 @@ int vg_change_pesize(struct cmd_context *cmd, struct volume_group *vg,
 					break;
 				case AREA_LV:
 					if (!_recalc_extents
-					    (&seg->area[s].u.lv.le, lv->name,
+					    (&seg_le(seg, s), lv->name,
 					     " area start", old_size,
 					     new_size)) {
 						stack;
 						return 0;
 					}
 					break;
-				default:
-					log_error("Unrecognised segment type "
-						  "%u", seg->area[s].type);
+				case AREA_UNASSIGNED:
+					log_error("Unassigned area %u found in "
+						  "segment", s);
 					return 0;
 				}
 			}
@@ -563,26 +559,22 @@ struct physical_volume *pv_create(const struct format_type *fmt,
 
 struct pv_list *find_pv_in_vg(struct volume_group *vg, const char *pv_name)
 {
-	struct list *pvh;
 	struct pv_list *pvl;
 
-	list_iterate(pvh, &vg->pvs) {
-		pvl = list_item(pvh, struct pv_list);
+	list_iterate_items(pvl, &vg->pvs)
 		if (pvl->pv->dev == dev_cache_get(pv_name, vg->cmd->filter))
 			return pvl;
-	}
 
 	return NULL;
 }
 
 int pv_is_in_vg(struct volume_group *vg, struct physical_volume *pv)
 {
-	struct list *pvh;
+	struct pv_list *pvl;
 
-	list_iterate(pvh, &vg->pvs) {
-		if (pv == list_item(pvh, struct pv_list)->pv)
+	list_iterate_items(pvl, &vg->pvs)
+		if (pv == pvl->pv)
 			 return 1;
-	}
 
 	return 0;
 }
@@ -590,21 +582,17 @@ int pv_is_in_vg(struct volume_group *vg, struct physical_volume *pv)
 struct physical_volume *find_pv_in_vg_by_uuid(struct volume_group *vg,
 					      struct id *id)
 {
-	struct list *pvh;
 	struct pv_list *pvl;
 
-	list_iterate(pvh, &vg->pvs) {
-		pvl = list_item(pvh, struct pv_list);
+	list_iterate_items(pvl, &vg->pvs)
 		if (id_equal(&pvl->pv->id, id))
 			return pvl->pv;
-	}
 
 	return NULL;
 }
 
 struct lv_list *find_lv_in_vg(struct volume_group *vg, const char *lv_name)
 {
-	struct list *lvh;
 	struct lv_list *lvl;
 	const char *ptr;
 
@@ -614,11 +602,9 @@ struct lv_list *find_lv_in_vg(struct volume_group *vg, const char *lv_name)
 	else
 		ptr = lv_name;
 
-	list_iterate(lvh, &vg->lvs) {
-		lvl = list_item(lvh, struct lv_list);
+	list_iterate_items(lvl, &vg->lvs)
 		if (!strcmp(lvl->lv->name, ptr))
 			return lvl;
-	}
 
 	return NULL;
 }
@@ -626,14 +612,11 @@ struct lv_list *find_lv_in_vg(struct volume_group *vg, const char *lv_name)
 struct lv_list *find_lv_in_vg_by_lvid(struct volume_group *vg,
 				      const union lvid *lvid)
 {
-	struct list *lvh;
 	struct lv_list *lvl;
 
-	list_iterate(lvh, &vg->lvs) {
-		lvl = list_item(lvh, struct lv_list);
+	list_iterate_items(lvl, &vg->lvs)
 		if (!strncmp(lvl->lv->lvid.s, lvid->s, sizeof(*lvid)))
 			return lvl;
-	}
 
 	return NULL;
 }
@@ -646,15 +629,12 @@ struct logical_volume *find_lv(struct volume_group *vg, const char *lv_name)
 
 struct physical_volume *find_pv(struct volume_group *vg, struct device *dev)
 {
-	struct list *pvh;
-	struct physical_volume *pv;
+	struct pv_list *pvl;
 
-	list_iterate(pvh, &vg->pvs) {
-		pv = list_item(pvh, struct pv_list)->pv;
+	list_iterate_items(pvl, &vg->pvs)
+		if (dev == pvl->pv->dev)
+			return pvl->pv;
 
-		if (dev == pv->dev)
-			return pv;
-	}
 	return NULL;
 }
 
@@ -679,14 +659,11 @@ struct physical_volume *find_pv_by_name(struct cmd_context *cmd,
 /* Find segment at a given logical extent in an LV */
 struct lv_segment *find_seg_by_le(struct logical_volume *lv, uint32_t le)
 {
-	struct list *segh;
 	struct lv_segment *seg;
 
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv->segments)
 		if (le >= seg->le && le < seg->le + seg->len)
 			return seg;
-	}
 
 	return NULL;
 }
@@ -696,23 +673,20 @@ struct pv_segment *find_peg_by_pe(struct physical_volume *pv, uint32_t pe)
 {
 	struct pv_segment *peg;
 
-	list_iterate_items(peg, &pv->segments) {
+	list_iterate_items(peg, &pv->segments)
 		if (pe >= peg->pe && pe < peg->pe + peg->len)
 			return peg;
-	}
 
 	return NULL;
 }
 
 int vg_remove(struct volume_group *vg)
 {
-	struct list *mdah;
 	struct metadata_area *mda;
 
 	/* FIXME Improve recovery situation? */
 	/* Remove each copy of the metadata */
-	list_iterate(mdah, &vg->fid->metadata_areas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &vg->fid->metadata_areas) {
 		if (mda->ops->vg_remove &&
 		    !mda->ops->vg_remove(vg->fid, vg, mda)) {
 			stack;
@@ -723,18 +697,38 @@ int vg_remove(struct volume_group *vg)
 	return 1;
 }
 
+int vg_validate(struct volume_group *vg)
+{
+	struct lv_list *lvl;
+
+	if (!check_pv_segments(vg)) {
+		log_error("Internal error: PV segments corrupted in %s.",
+			  vg->name);
+		return 0;
+	}
+
+	list_iterate_items(lvl, &vg->lvs) {
+		if (!check_lv_segments(lvl->lv)) {
+			log_error("Internal error: LV segments corrupted in %s.",
+				  lvl->lv->name);
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
 /*
  * After vg_write() returns success,
  * caller MUST call either vg_commit() or vg_revert()
  */
 int vg_write(struct volume_group *vg)
 {
-	struct list *mdah, *mdah2;
+	struct list *mdah;
 	struct metadata_area *mda;
 
-	if (!check_pv_segments(vg)) {
-		log_error("Internal error: PV segments corrupted in %s.",
-			  vg->name);
+	if (!vg_validate(vg)) {
+		stack;
 		return 0;
 	}
 
@@ -752,14 +746,13 @@ int vg_write(struct volume_group *vg)
 	vg->seqno++;
 
 	/* Write to each copy of the metadata area */
-	list_iterate(mdah, &vg->fid->metadata_areas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &vg->fid->metadata_areas) {
 		if (!mda->ops->vg_write) {
 			log_error("Format does not support writing volume"
 				  "group metadata areas");
 			/* Revert */
-			list_uniterate(mdah2, &vg->fid->metadata_areas, mdah) {
-				mda = list_item(mdah2, struct metadata_area);
+			list_uniterate(mdah, &vg->fid->metadata_areas, &mda->list) {
+				mda = list_item(mdah, struct metadata_area);
 
 				if (mda->ops->vg_revert &&
 				    !mda->ops->vg_revert(vg->fid, vg, mda)) {
@@ -771,8 +764,9 @@ int vg_write(struct volume_group *vg)
 		if (!mda->ops->vg_write(vg->fid, vg, mda)) {
 			stack;
 			/* Revert */
-			list_uniterate(mdah2, &vg->fid->metadata_areas, mdah) {
-				mda = list_item(mdah2, struct metadata_area);
+			list_uniterate(mdah, &vg->fid->metadata_areas, &mda->list) {
+				mda = list_item(mdah, struct metadata_area);
+
 				if (mda->ops->vg_revert &&
 				    !mda->ops->vg_revert(vg->fid, vg, mda)) {
 					stack;
@@ -783,14 +777,12 @@ int vg_write(struct volume_group *vg)
 	}
 
 	/* Now pre-commit each copy of the new metadata */
-	list_iterate(mdah, &vg->fid->metadata_areas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &vg->fid->metadata_areas) {
 		if (mda->ops->vg_precommit &&
 		    !mda->ops->vg_precommit(vg->fid, vg, mda)) {
 			stack;
 			/* Revert */
-			list_iterate(mdah2, &vg->fid->metadata_areas) {
-				mda = list_item(mdah2, struct metadata_area);
+			list_iterate_items(mda, &vg->fid->metadata_areas) {
 				if (mda->ops->vg_revert &&
 				    !mda->ops->vg_revert(vg->fid, vg, mda)) {
 					stack;
@@ -806,14 +798,12 @@ int vg_write(struct volume_group *vg)
 /* Commit pending changes */
 int vg_commit(struct volume_group *vg)
 {
-	struct list *mdah;
 	struct metadata_area *mda;
 	int cache_updated = 0;
 	int failed = 0;
 
 	/* Commit to each copy of the metadata area */
-	list_iterate(mdah, &vg->fid->metadata_areas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &vg->fid->metadata_areas) {
 		failed = 0;
 		if (mda->ops->vg_commit &&
 		    !mda->ops->vg_commit(vg->fid, vg, mda)) {
@@ -825,7 +815,6 @@ int vg_commit(struct volume_group *vg)
 			lvmcache_update_vg(vg);
 			cache_updated = 1;
 		}
-
 	}
 
 	/* If at least one mda commit succeeded, it was committed */
@@ -835,11 +824,9 @@ int vg_commit(struct volume_group *vg)
 /* Don't commit any pending changes */
 int vg_revert(struct volume_group *vg)
 {
-	struct list *mdah;
 	struct metadata_area *mda;
 
-	list_iterate(mdah, &vg->fid->metadata_areas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &vg->fid->metadata_areas) {
 		if (mda->ops->vg_revert &&
 		    !mda->ops->vg_revert(vg->fid, vg, mda)) {
 			stack;
@@ -853,8 +840,7 @@ int vg_revert(struct volume_group *vg)
 static struct volume_group *_vg_read_orphans(struct cmd_context *cmd)
 {
 	struct lvmcache_vginfo *vginfo;
-	struct list *ih;
-	struct device *dev;
+	struct lvmcache_info *info;
 	struct pv_list *pvl;
 	struct volume_group *vg;
 	struct physical_volume *pv;
@@ -877,9 +863,8 @@ static struct volume_group *_vg_read_orphans(struct cmd_context *cmd)
 		return NULL;
 	}
 
-	list_iterate(ih, &vginfo->infos) {
-		dev = list_item(ih, struct lvmcache_info)->dev;
-		if (!(pv = pv_read(cmd, dev_name(dev), NULL, NULL, 1))) {
+	list_iterate_items(info, &vginfo->infos) {
+		if (!(pv = pv_read(cmd, dev_name(info->dev), NULL, NULL, 1))) {
 			continue;
 		}
 		if (!(pvl = pool_zalloc(cmd->mem, sizeof(*pvl)))) {
@@ -908,7 +893,6 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
 	struct format_instance *fid;
 	const struct format_type *fmt;
 	struct volume_group *vg, *correct_vg = NULL;
-	struct list *mdah;
 	struct metadata_area *mda;
 	int inconsistent = 0;
 
@@ -952,8 +936,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
 	}
 
 	/* Ensure contents of all metadata areas match - else do recovery */
-	list_iterate(mdah, &fid->metadata_areas) {
-		mda = list_item(mdah, struct metadata_area);
+	list_iterate_items(mda, &fid->metadata_areas) {
 		if ((precommitted &&
 		     !(vg = mda->ops->vg_read_precommit(fid, vgname, mda))) ||
 		    (!precommitted &&
@@ -996,8 +979,7 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
 		}
 
 		/* Ensure contents of all metadata areas match - else recover */
-		list_iterate(mdah, &fid->metadata_areas) {
-			mda = list_item(mdah, struct metadata_area);
+		list_iterate_items(mda, &fid->metadata_areas) {
 			if ((precommitted &&
 			     !(vg = mda->ops->vg_read_precommit(fid, vgname,
 								mda))) ||
@@ -1074,7 +1056,27 @@ static struct volume_group *_vg_read(struct cmd_context *cmd,
 struct volume_group *vg_read(struct cmd_context *cmd, const char *vgname,
 			     int *consistent)
 {
-	return _vg_read(cmd, vgname, consistent, 0);
+	struct volume_group *vg;
+	struct lv_list *lvl;
+
+	if (!(vg = _vg_read(cmd, vgname, consistent, 0)))
+		return NULL;
+
+	if (!check_pv_segments(vg)) {
+		log_error("Internal error: PV segments corrupted in %s.",
+			  vg->name);
+		return NULL;
+	}
+
+	list_iterate_items(lvl, &vg->lvs) {
+		if (!check_lv_segments(lvl->lv)) {
+			log_error("Internal error: LV segments corrupted in %s.",
+				  lvl->lv->name);
+			return NULL;
+		}
+	}
+
+	return vg;
 }
 
 struct volume_group *vg_read_precommitted(struct cmd_context *cmd,
@@ -1091,9 +1093,10 @@ struct volume_group *vg_read_precommitted(struct cmd_context *cmd,
 struct volume_group *vg_read_by_vgid(struct cmd_context *cmd, const char *vgid)
 {
 	const char *vgname;
-	struct list *vgnames, *slh;
+	struct list *vgnames;
 	struct volume_group *vg;
 	struct lvmcache_vginfo *vginfo;
+	struct str_list *strl;
 	int consistent = 0;
 
 	/* Is corresponding vgname already cached? */
@@ -1124,8 +1127,8 @@ struct volume_group *vg_read_by_vgid(struct cmd_context *cmd, const char *vgid)
 		return NULL;
 	}
 
-	list_iterate(slh, vgnames) {
-		vgname = list_item(slh, struct str_list)->str;
+	list_iterate_items(strl, vgnames) {
+		vgname = strl->str;
 		if (!vgname || !*vgname)
 			continue;	// FIXME Unnecessary? 
 		consistent = 0;
@@ -1231,10 +1234,11 @@ struct list *get_vgs(struct cmd_context *cmd, int full_scan)
 
 struct list *get_pvs(struct cmd_context *cmd)
 {
+	struct str_list *strl;
 	struct list *results;
 	const char *vgname;
 	struct list *pvh, *tmp;
-	struct list *vgnames, *slh;
+	struct list *vgnames;
 	struct volume_group *vg;
 	int consistent = 0;
 	int old_partial;
@@ -1261,8 +1265,8 @@ struct list *get_pvs(struct cmd_context *cmd)
 	old_pvmove = pvmove_mode();
 	init_partial(1);
 	init_pvmove(1);
-	list_iterate(slh, vgnames) {
-		vgname = list_item(slh, struct str_list)->str;
+	list_iterate_items(strl, vgnames) {
+		vgname = strl->str;
 		if (!vgname)
 			continue;	/* FIXME Unnecessary? */
 		consistent = 0;

lib/metadata/metadata.h

@@ -55,6 +55,9 @@
 #define LOCKED			0x00004000	/* LV */
 #define MIRRORED		0x00008000	/* LV - internal use only */
 #define VIRTUAL			0x00010000	/* LV - internal use only */
+#define MIRROR_LOG		0x00020000	/* LV */
+#define MIRROR_IMAGE		0x00040000	/* LV */
+#define ACTIVATE_EXCL		0x00080000	/* LV - internal use only */
 
 #define LVM_READ              	0x00000100	/* LV VG */
 #define LVM_WRITE             	0x00000200	/* LV VG */
@@ -79,6 +82,7 @@ typedef enum {
 } alloc_policy_t;
 
 typedef enum {
+	AREA_UNASSIGNED = 0,
 	AREA_PV,
 	AREA_LV
 } area_type_t;
@@ -228,8 +232,10 @@ struct lv_segment {
 	struct logical_volume *origin;
 	struct logical_volume *cow;
 	struct list origin_list;
-	uint32_t chunk_size;	/* In sectors */
+	uint32_t chunk_size;	/* For snapshots - in sectors */
+	uint32_t region_size;	/* For mirrors - in sectors */
 	uint32_t extents_copied;
+	struct logical_volume *log_lv;
 
 	struct list tags;
 
@@ -248,6 +254,14 @@ struct lv_segment {
 	} area[0];
 };
 
+#define seg_type(seg, s)	(seg)->area[(s)].type
+#define seg_pvseg(seg, s)	(seg)->area[(s)].u.pv.pvseg
+#define seg_pv(seg, s)		(seg)->area[(s)].u.pv.pvseg->pv
+#define seg_dev(seg, s)		(seg)->area[(s)].u.pv.pvseg->pv->dev
+#define seg_pe(seg, s)		(seg)->area[(s)].u.pv.pvseg->pe
+#define seg_lv(seg, s)		(seg)->area[(s)].u.lv.lv
+#define seg_le(seg, s)		(seg)->area[(s)].u.lv.le
+
 struct logical_volume {
 	union lvid lvid;
 	char *name;
@@ -378,6 +392,7 @@ struct format_handler {
 /*
  * Utility functions
  */
+int vg_validate(struct volume_group *vg);
 int vg_write(struct volume_group *vg);
 int vg_commit(struct volume_group *vg);
 int vg_revert(struct volume_group *vg);
@@ -425,16 +440,18 @@ int vg_change_pesize(struct cmd_context *cmd, struct volume_group *vg,
 /* Manipulate LVs */
 struct logical_volume *lv_create_empty(struct format_instance *fi,
 				       const char *name,
-				       const char *name_format,
 				       union lvid *lvid,
 				       uint32_t status,
 				       alloc_policy_t alloc,
 				       int import,
 				       struct volume_group *vg);
 
-/* Entry point for all LV extent reductions */
+/* Reduce the size of an LV by extents */
 int lv_reduce(struct logical_volume *lv, uint32_t extents);
 
+/* Empty an LV prior to deleting it */
+int lv_empty(struct logical_volume *lv);
+
 /* Entry point for all LV extent allocations */
 int lv_extend(struct logical_volume *lv,
 	      struct segment_type *segtype,
@@ -492,7 +509,7 @@ const char *strip_dir(const char *vg_name, const char *dir);
 /*
  * Checks that an lv has no gaps or overlapping segments.
  */
-int lv_check_segments(struct logical_volume *lv);
+int check_lv_segments(struct logical_volume *lv);
 
 /*
  * Sometimes (eg, after an lvextend), it is possible to merge two
@@ -526,6 +543,20 @@ int vg_remove_snapshot(struct logical_volume *cow);
 /*
  * Mirroring functions
  */
+struct alloc_handle;
+uint32_t adjusted_mirror_region_size(uint32_t extent_size, uint32_t extents,
+                                     uint32_t region_size);
+int create_mirror_layers(struct alloc_handle *ah,
+			 uint32_t first_area,
+			 uint32_t num_mirrors,
+			 struct logical_volume *lv,
+			 struct segment_type *segtype,
+			 uint32_t status,
+			 uint32_t region_size,
+			 struct logical_volume *log_lv);
+int remove_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors);
+int remove_all_mirror_images(struct logical_volume *lv);
+
 int insert_pvmove_mirrors(struct cmd_context *cmd,
 			  struct logical_volume *lv_mirr,
 			  struct list *source_pvl,
@@ -548,6 +579,8 @@ struct list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
 			  struct logical_volume *lv);
 
 uint32_t find_free_lvnum(struct logical_volume *lv);
+char *generate_lv_name(struct volume_group *vg, const char *format,
+		       char *buffer, size_t len);
 
 static inline int validate_name(const char *n)
 {
@@ -561,6 +594,9 @@ static inline int validate_name(const char *n)
 	if (*n == '-')
 		return 0;
 
+	if (!strcmp(n, ".") || !strcmp(n, ".."))
+		return 0;
+
 	while ((len++, c = *n++))
 		if (!isalnum(c) && c != '.' && c != '_' && c != '-' && c != '+')
 			return 0;

lib/metadata/mirror.c

@@ -20,6 +20,161 @@
 #include "display.h"
 #include "activate.h"
 #include "lv_alloc.h"
+#include "lvm-string.h"
+
+/*
+ * Ensure region size is compatible with volume size.
+ */
+uint32_t adjusted_mirror_region_size(uint32_t extent_size, uint32_t extents,
+				     uint32_t region_size)
+{
+	uint32_t region_max;
+
+	region_max = (1 << (ffs(extents) - 1)) * extent_size;
+
+	if (region_max < region_size) {
+		region_size = region_max;
+		log_print("Using reduced mirror region size of %" PRIu32
+			  " sectors", region_max);
+		return region_max;
+	}
+
+	return region_size;
+}
+
+/*
+ * Reduce mirrored_seg to num_mirrors images.
+ */
+int remove_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors)
+{
+	uint32_t m;
+
+	for (m = num_mirrors; m < mirrored_seg->area_count; m++) {
+		if (!lv_remove(seg_lv(mirrored_seg, m))) {
+			stack;
+			return 0;
+		}
+	}
+
+	mirrored_seg->area_count = num_mirrors;
+
+	return 1;
+}
+
+int remove_all_mirror_images(struct logical_volume *lv)
+{
+	struct lv_segment *first_seg, *seg;
+	struct logical_volume *lv1;
+
+	list_iterate_items(first_seg, &lv->segments)
+		break;
+
+	if (!remove_mirror_images(first_seg, 1)) {
+		stack;
+		return 0;
+	}
+
+	if (!lv_remove(first_seg->log_lv)) {
+		stack;
+		return 0;
+	}
+
+	lv1 = seg_lv(first_seg, 0);
+
+	lv->segments = lv1->segments;
+	lv->segments.n->p = &lv->segments;
+	lv->segments.p->n = &lv->segments;
+
+	list_init(&lv1->segments);
+	lv1->le_count = 0;
+	lv1->size = 0;
+	if (!lv_remove(lv1)) {
+		stack;
+		return 0;
+	}
+
+	lv->status &= ~MIRRORED;
+
+	list_iterate_items(seg, &lv->segments)
+		seg->lv = lv;
+
+	return 1;
+}
+
+/*
+ * Add mirror images to an existing mirror
+ */
+/* FIXME
+int add_mirror_images(struct alloc_handle *ah,
+		      uint32_t first_area,
+		      uint32_t num_areas,
+		      struct logical_volume *lv)
+{
+}
+*/
+
+int create_mirror_layers(struct alloc_handle *ah,
+			 uint32_t first_area,
+			 uint32_t num_mirrors,
+			 struct logical_volume *lv,
+			 struct segment_type *segtype,
+			 uint32_t status,
+			 uint32_t region_size,
+			 struct logical_volume *log_lv)
+{
+	uint32_t m;
+	struct logical_volume **img_lvs;
+	char *img_name;
+	size_t len;
+	
+	if (!(img_lvs = alloca(sizeof(*img_lvs) * num_mirrors))) {
+		log_error("img_lvs allocation failed. "
+			  "Remove new LV and retry.");
+		return 0;
+	}
+
+	len = strlen(lv->name) + 32;
+	if (!(img_name = alloca(len))) {
+		log_error("img_name allocation failed. "
+			  "Remove new LV and retry.");
+		return 0;
+	}
+
+	if (lvm_snprintf(img_name, len, "%s_mimage_%%d", lv->name) < 0) {
+		log_error("img_name allocation failed. "
+			  "Remove new LV and retry.");
+		return 0;
+	}
+
+	for (m = 0; m < num_mirrors; m++) {
+		if (!(img_lvs[m] = lv_create_empty(lv->vg->fid, img_name,
+					     NULL, LVM_READ | LVM_WRITE,
+					     ALLOC_INHERIT, 0, lv->vg))) {\
+			log_error("Aborting. Failed to create submirror LV. "
+				  "Remove new LV and retry.");
+			return 0;
+		}
+
+		if (!lv_add_segment(ah, m, 1, img_lvs[m],
+				    get_segtype_from_string(lv->vg->cmd,
+							    "striped"),
+				    0, NULL, 0, 0, 0, NULL)) {
+			log_error("Aborting. Failed to add submirror segment "
+				  "to %s. Remove new LV and retry.",
+				  img_lvs[m]->name);
+			return 0;
+		}
+	}
+
+	if (!lv_add_mirror_segment(ah, lv, img_lvs, num_mirrors, segtype,
+				   0, region_size, log_lv)) {
+		log_error("Aborting. Failed to add mirror segment. "
+			  "Remove new LV and retry.");
+		return 0;
+	}
+
+	return 1;
+}
 
 /* 
  * Replace any LV segments on given PV with temporary mirror.
@@ -33,10 +188,11 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
 			  alloc_policy_t alloc,
 			  struct list *lvs_changed)
 {
-	struct list *segh;
 	struct lv_segment *seg;
 	struct lv_list *lvl;
 	struct pv_list *pvl;
+	struct physical_volume *pv;
+	uint32_t pe;
 	int lv_used = 0;
 	uint32_t s, start_le, extent_count = 0u;
 	struct segment_type *segtype;
@@ -59,16 +215,15 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
         }
 
 	/* Split LV segments to match PE ranges */
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv->segments) {
 		for (s = 0; s < seg->area_count; s++) {
-			if (seg->area[s].type != AREA_PV ||
-			    seg->area[s].u.pv.pvseg->pv->dev != pvl->pv->dev)
+			if (seg_type(seg, s) != AREA_PV ||
+			    seg_dev(seg, s) != pvl->pv->dev)
 				continue;
 
 			/* Do these PEs need moving? */
 			list_iterate_items(per, pvl->pe_ranges) {
-				pe_start = seg->area[s].u.pv.pvseg->pe;
+				pe_start = seg_pe(seg, s);
 				pe_end = pe_start + seg->area_len - 1;
 				per_end = per->start + per->count - 1;
 
@@ -104,14 +259,13 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
 	}
 
 	/* Work through all segments on the supplied PV */
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv->segments) {
 		for (s = 0; s < seg->area_count; s++) {
-			if (seg->area[s].type != AREA_PV ||
-			    seg->area[s].u.pv.pvseg->pv->dev != pvl->pv->dev)
+			if (seg_type(seg, s) != AREA_PV ||
+			    seg_dev(seg, s) != pvl->pv->dev)
 				continue;
 
-			pe_start = seg->area[s].u.pv.pvseg->pe;
+			pe_start = seg_pe(seg, s);
 
 			/* Do these PEs need moving? */
 			list_iterate_items(per, pvl->pe_ranges) {
@@ -123,9 +277,8 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
 
 				log_debug("Matched PE range %u-%u against "
 					  "%s %u len %u", per->start, per_end,
-					  dev_name(seg->area[s].u.pv.pvseg->
-						   pv->dev),
-					  seg->area[s].u.pv.pvseg->pe,
+					  dev_name(seg_dev(seg, s)),
+					  seg_pe(seg, s),
 					  seg->area_len);
 
 				/* First time, add LV to list of LVs affected */
@@ -139,25 +292,26 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
 					lv_used = 1;
 				}
 	
+				pv = seg_pv(seg, s);
+				pe = seg_pe(seg, s);
 				log_very_verbose("Moving %s:%u-%u of %s/%s",
 						 dev_name(pvl->pv->dev),
-						 seg->area[s].u.pv.pvseg->pe,
-						 seg->area[s].u.pv.pvseg->pe +
-						     seg->area_len - 1,
+						 pe, pe + seg->area_len - 1,
 						 lv->vg->name, lv->name);
 
 				start_le = lv_mirr->le_count;
+				/* FIXME Clean this up */
+				release_lv_segment_area(seg, s, seg->area_len);
 				if (!lv_extend(lv_mirr, segtype, 1,
 				       	seg->area_len, 0u, seg->area_len,
-				       	seg->area[s].u.pv.pvseg->pv,
-				       	seg->area[s].u.pv.pvseg->pe,
+				       	pv, pe,
 				       	PVMOVE, allocatable_pvs,
 				       	alloc)) {
 					log_error("Unable to allocate "
 						  "temporary LV for pvmove.");
 					return 0;
 				}
-				set_lv_segment_area_lv(seg, s, lv_mirr, start_le);
+				set_lv_segment_area_lv(seg, s, lv_mirr, start_le, 0);
 	
 				extent_count += seg->area_len;
 	
@@ -178,29 +332,27 @@ int insert_pvmove_mirrors(struct cmd_context *cmd,
 int remove_pvmove_mirrors(struct volume_group *vg,
 			  struct logical_volume *lv_mirr)
 {
-	struct list *lvh, *segh;
+	struct lv_list *lvl;
 	struct logical_volume *lv1;
 	struct lv_segment *seg, *mir_seg;
 	uint32_t s, c;
 
 	/* Loop through all LVs except the temporary mirror */
-	list_iterate(lvh, &vg->lvs) {
-		lv1 = list_item(lvh, struct lv_list)->lv;
+	list_iterate_items(lvl, &vg->lvs) {
+		lv1 = lvl->lv;
 		if (lv1 == lv_mirr)
 			continue;
 
 		/* Find all segments that point at the temporary mirror */
-		list_iterate(segh, &lv1->segments) {
-			seg = list_item(segh, struct lv_segment);
+		list_iterate_items(seg, &lv1->segments) {
 			for (s = 0; s < seg->area_count; s++) {
-				if (seg->area[s].type != AREA_LV ||
-				    seg->area[s].u.lv.lv != lv_mirr)
+				if (seg_type(seg, s) != AREA_LV ||
+				    seg_lv(seg, s) != lv_mirr)
 					continue;
 
 				/* Find the mirror segment pointed at */
 				if (!(mir_seg = find_seg_by_le(lv_mirr,
-							       seg->area[s].
-							       u.lv.le))) {
+							       seg_le(seg, s)))) {
 					/* FIXME Error message */
 					log_error("No segment found with LE");
 					return 0;
@@ -210,7 +362,7 @@ int remove_pvmove_mirrors(struct volume_group *vg,
 				/* FIXME Improve error mesg & remove restrcn */
 				if (!seg_is_mirrored(mir_seg) ||
 				    !(mir_seg->status & PVMOVE) ||
-				    mir_seg->le != seg->area[s].u.lv.le ||
+				    mir_seg->le != seg_le(seg, s) ||
 				    mir_seg->area_count != 2 ||
 				    mir_seg->area_len != seg->area_len) {
 					log_error("Incompatible segments");
@@ -226,22 +378,22 @@ int remove_pvmove_mirrors(struct volume_group *vg,
 				else
 					c = 0;
 
-				if (!set_lv_segment_area_pv(seg, s,
-					    mir_seg->area[c].u.pv.pvseg->pv,
-					    mir_seg->area[c].u.pv.pvseg->pe)) {
+				if (!move_lv_segment_area(seg, s, mir_seg, c)) {
 					stack;
 					return 0;
 				}
 
-				/* Replace mirror with old area */
+				release_lv_segment_area(mir_seg, !c, mir_seg->area_len);
+
+				/* Replace mirror with error segment */
 				if (!
 				    (mir_seg->segtype =
 				     get_segtype_from_string(vg->cmd,
-							     "striped"))) {
-					log_error("Missing striped segtype");
+							     "error"))) {
+					log_error("Missing error segtype");
 					return 0;
 				}
-				mir_seg->area_count = 1;
+				mir_seg->area_count = 0;
 
 				/* FIXME Assumes only one pvmove at a time! */
 				lv1->status &= ~LOCKED;
@@ -252,22 +404,24 @@ int remove_pvmove_mirrors(struct volume_group *vg,
 
 	}
 
+	if (!lv_empty(lv_mirr)) {
+		stack;
+		return 0;
+	}
 
 	return 1;
 }
 
 const char *get_pvmove_pvname_from_lv_mirr(struct logical_volume *lv_mirr)
 {
-	struct list *segh;
 	struct lv_segment *seg;
 
-	list_iterate(segh, &lv_mirr->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv_mirr->segments) {
 		if (!seg_is_mirrored(seg))
 			continue;
-		if (seg->area[0].type != AREA_PV)
+		if (seg_type(seg, 0) != AREA_PV)
 			continue;
-		return dev_name(seg->area[0].u.pv.pvseg->pv->dev);
+		return dev_name(seg_dev(seg, 0));
 	}
 
 	return NULL;
@@ -275,16 +429,14 @@ const char *get_pvmove_pvname_from_lv_mirr(struct logical_volume *lv_mirr)
 
 const char *get_pvmove_pvname_from_lv(struct logical_volume *lv)
 {
-	struct list *segh;
 	struct lv_segment *seg;
 	uint32_t s;
 
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv->segments) {
 		for (s = 0; s < seg->area_count; s++) {
-			if (seg->area[s].type != AREA_LV)
+			if (seg_type(seg, s) != AREA_LV)
 				continue;
-			return get_pvmove_pvname_from_lv_mirr(seg->area[s].u.lv.lv);
+			return get_pvmove_pvname_from_lv_mirr(seg_lv(seg, s));
 		}
 	}
 
@@ -295,23 +447,22 @@ struct logical_volume *find_pvmove_lv(struct volume_group *vg,
 				      struct device *dev,
 				      uint32_t lv_type)
 {
-	struct list *lvh, *segh;
+	struct lv_list *lvl;
 	struct logical_volume *lv;
 	struct lv_segment *seg;
 
 	/* Loop through all LVs */
-	list_iterate(lvh, &vg->lvs) {
-		lv = list_item(lvh, struct lv_list)->lv;
+	list_iterate_items(lvl, &vg->lvs) {
+		lv = lvl->lv;
 
 		if (!(lv->status & lv_type))
 			continue;
 
 		/* Check segment origins point to pvname */
-		list_iterate(segh, &lv->segments) {
-			seg = list_item(segh, struct lv_segment);
-			if (seg->area[0].type != AREA_PV)
+		list_iterate_items(seg, &lv->segments) {
+			if (seg_type(seg, 0) != AREA_PV)
 				continue;
-			if (seg->area[0].u.pv.pvseg->pv->dev != dev)
+			if (seg_dev(seg, 0) != dev)
 				continue;
 			return lv;
 		}
@@ -338,9 +489,9 @@ struct logical_volume *find_pvmove_lv_from_pvname(struct cmd_context *cmd,
 struct list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
 			  struct logical_volume *lv)
 {
-	struct list *lvh, *segh, *lvs;
+	struct list *lvs;
 	struct logical_volume *lv1;
-	struct lv_list *lvl;
+	struct lv_list *lvl, *lvl1;
 	struct lv_segment *seg;
 	uint32_t s;
 
@@ -352,17 +503,16 @@ struct list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
 	list_init(lvs);
 
 	/* Loop through all LVs except the one supplied */
-	list_iterate(lvh, &vg->lvs) {
-		lv1 = list_item(lvh, struct lv_list)->lv;
+	list_iterate_items(lvl1, &vg->lvs) {
+		lv1 = lvl1->lv;
 		if (lv1 == lv)
 			continue;
 
 		/* Find whether any segment points at the supplied LV */
-		list_iterate(segh, &lv1->segments) {
-			seg = list_item(segh, struct lv_segment);
+		list_iterate_items(seg, &lv1->segments) {
 			for (s = 0; s < seg->area_count; s++) {
-				if (seg->area[s].type != AREA_LV ||
-				    seg->area[s].u.lv.lv != lv)
+				if (seg_type(seg, s) != AREA_LV ||
+				    seg_lv(seg, s) != lv)
 					continue;
 				if (!(lvl = pool_alloc(cmd->mem, sizeof(*lvl)))) {
 					log_error("lv_list alloc failed");
@@ -383,12 +533,9 @@ struct list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
 float copy_percent(struct logical_volume *lv_mirr)
 {
 	uint32_t numerator = 0u, denominator = 0u;
-	struct list *segh;
 	struct lv_segment *seg;
 
-	list_iterate(segh, &lv_mirr->segments) {
-		seg = list_item(segh, struct lv_segment);
-
+	list_iterate_items(seg, &lv_mirr->segments) {
 		denominator += seg->area_len;
 
 		if (seg_is_mirrored(seg))

lib/metadata/pv_alloc.h

@@ -22,7 +22,7 @@ struct pv_segment *assign_peg_to_lvseg(struct physical_volume *pv, uint32_t pe,
 				       struct lv_segment *seg,
 				       uint32_t area_num);
 int pv_split_segment(struct physical_volume *pv, uint32_t pe);
-int release_pv_segment(struct pv_segment *peg, uint32_t new_area_len);
+int release_pv_segment(struct pv_segment *peg, uint32_t area_reduction);
 int check_pv_segments(struct volume_group *vg);
 void merge_pv_segments(struct pv_segment *peg1, struct pv_segment *peg2);
 

lib/metadata/pv_manip.c

@@ -100,6 +100,11 @@ static int _pv_split_segment(struct physical_volume *pv, struct pv_segment *peg,
 
 	list_add_h(&peg->list, &peg_new->list);
 
+	if (peg->lvseg) {
+		peg->pv->pe_alloc_count -= peg_new->len;
+		peg->lvseg->lv->vg->free_count += peg_new->len;
+	}
+
 	return 1;
 }
 
@@ -162,12 +167,24 @@ struct pv_segment *assign_peg_to_lvseg(struct physical_volume *pv,
 	peg->lvseg = seg;
 	peg->lv_area = area_num;
 
+	peg->pv->pe_alloc_count += area_len;
+	peg->lvseg->lv->vg->free_count -= area_len;
+
 	return peg;
 }
 
-int release_pv_segment(struct pv_segment *peg, uint32_t new_area_len)
+int release_pv_segment(struct pv_segment *peg, uint32_t area_reduction)
 {
-	if (new_area_len == 0) {
+	if (!peg->lvseg) {
+		log_error("release_pv_segment with unallocated segment: "
+			  "%s PE %" PRIu32, dev_name(peg->pv->dev), peg->pe);
+		return 0;
+	}
+
+	if (peg->lvseg->area_len == area_reduction) {
+		peg->pv->pe_alloc_count -= area_reduction;
+		peg->lvseg->lv->vg->free_count += area_reduction;
+
 		peg->lvseg = NULL;
 		peg->lv_area = 0;
 
@@ -176,7 +193,8 @@ int release_pv_segment(struct pv_segment *peg, uint32_t new_area_len)
 		return 1;
 	}
 
-	if (!pv_split_segment(peg->pv, peg->pe + new_area_len)) {
+	if (!pv_split_segment(peg->pv, peg->pe + peg->lvseg->area_len -
+				       area_reduction)) {
 		stack;
 		return 0;
 	}
@@ -203,13 +221,16 @@ int check_pv_segments(struct volume_group *vg)
 	struct pv_list *pvl;
 	struct pv_segment *peg;
 	unsigned s, segno;
-	uint32_t start_pe;
+	uint32_t start_pe, alloced;
+	uint32_t pv_count = 0, free_count = 0, extent_count = 0;
 	int ret = 1;
 
 	list_iterate_items(pvl, &vg->pvs) {
 		pv = pvl->pv;
 		segno = 0;
 		start_pe = 0;
+		alloced = 0;
+		pv_count++;
 
 		list_iterate_items(peg, &pv->segments) {
 			s = peg->lv_area;
@@ -221,30 +242,63 @@ int check_pv_segments(struct volume_group *vg)
 				  peg->lvseg ? peg->lvseg->le : 0, s);
 			/* FIXME Add details here on failure instead */
 			if (start_pe != peg->pe) {
-				log_debug("Gap in pvsegs: %u, %u",
+				log_error("Gap in pvsegs: %u, %u",
 					  start_pe, peg->pe);
 				ret = 0;
 			}
 			if (peg->lvseg) {
-				if (peg->lvseg->area[s].type != AREA_PV) {
-					log_debug("Wrong lvseg area type");
+				if (seg_type(peg->lvseg, s) != AREA_PV) {
+					log_error("Wrong lvseg area type");
 					ret = 0;
 				}
-				if (peg->lvseg->area[s].u.pv.pvseg != peg) {
-					log_debug("Inconsistent pvseg pointers");
+				if (seg_pvseg(peg->lvseg, s) != peg) {
+					log_error("Inconsistent pvseg pointers");
 					ret = 0;
 				}
 				if (peg->lvseg->area_len != peg->len) {
-					log_debug("Inconsistent length: %u %u",
+					log_error("Inconsistent length: %u %u",
 						  peg->len,
 						  peg->lvseg->area_len);
 					ret = 0;
 				}
+				alloced += peg->len;
 			}
 			start_pe += peg->len;
 		}
+
+		if (start_pe != pv->pe_count) {
+			log_error("PV segment pe_count mismatch: %u != %u",
+				  start_pe, pv->pe_count);
+			ret = 0;
+		}
+
+		if (alloced != pv->pe_alloc_count) {
+			log_error("PV segment pe_alloc_count mismatch: "
+				  "%u != %u", alloced, pv->pe_alloc_count);
+			ret = 0;
+		}
+
+		extent_count += start_pe;
+		free_count += (start_pe - alloced);
+	}
+
+	if (pv_count != vg->pv_count) {
+		log_error("PV segment VG pv_count mismatch: %u != %u",
+			  pv_count, vg->pv_count);
+		ret = 0;
+	}
+
+	if (free_count != vg->free_count) {
+		log_error("PV segment VG free_count mismatch: %u != %u",
+			  free_count, vg->free_count);
+		ret = 0;
+	}
+
+	if (extent_count != vg->extent_count) {
+		log_error("PV segment VG extent_count mismatch: %u != %u",
+			  extent_count, vg->extent_count);
+		ret = 0;
 	}
 
 	return ret;
 }
-

lib/metadata/segtype.h

@@ -39,6 +39,10 @@ struct dev_manager;
 #define seg_is_virtual(seg)	((seg)->segtype->flags & SEG_VIRTUAL ? 1 : 0)
 #define seg_can_split(seg)	((seg)->segtype->flags & SEG_CAN_SPLIT ? 1 : 0)
 
+#define segtype_is_striped(segtype)	((segtype)->flags & SEG_AREAS_STRIPED ? 1 : 0)
+#define segtype_is_mirrored(segtype)	((segtype)->flags & SEG_AREAS_MIRRORED ? 1 : 0)
+#define segtype_is_virtual(segtype)	((segtype)->flags & SEG_VIRTUAL ? 1 : 0)
+
 struct segment_type {
 	struct list list;
 	struct cmd_context *cmd;

lib/metadata/snapshot_manip.c

@@ -50,7 +50,7 @@ int vg_add_snapshot(struct format_instance *fid, const char *name,
 		return 0;
 	}
 
-	if (!(snap = lv_create_empty(fid, name, name ? NULL : "snapshot%d",
+	if (!(snap = lv_create_empty(fid, name ? name : "snapshot%d",
 				     lvid, LVM_READ | LVM_WRITE | VISIBLE_LV,
 				     ALLOC_INHERIT, 1, origin->vg))) {
 		stack;
@@ -59,7 +59,7 @@ int vg_add_snapshot(struct format_instance *fid, const char *name,
 
 	snap->le_count = extent_count;
 
-	if (!(seg = alloc_snapshot_seg(snap, 0))) {
+	if (!(seg = alloc_snapshot_seg(snap, 0, 0))) {
 		stack;
 		return 0;
 	}

lib/mirror/mirrored.c

@@ -35,7 +35,7 @@ enum {
 };
 
 struct mirror_state {
-	uint32_t region_size;
+	uint32_t default_region_size;
 };
 
 static const char *_name(const struct lv_segment *seg)
@@ -45,14 +45,25 @@ static const char *_name(const struct lv_segment *seg)
 
 static void _display(const struct lv_segment *seg)
 {
+	const char *size;
+
 	log_print("  Mirrors\t\t%u", seg->area_count);
 	log_print("  Mirror size\t\t%u", seg->area_len);
+	if (seg->log_lv)
+		log_print("  Mirror log volume\t%s", seg->log_lv->name);
+
+	if (seg->region_size) {
+		size = display_size(seg->lv->vg->cmd,
+				    (uint64_t) seg->region_size,
+				    SIZE_SHORT);
+		log_print("  Mirror region size\t%s", size);
+	}
+
 	log_print("  Mirror original:");
 	display_stripe(seg, 0, "    ");
 	log_print("  Mirror destination:");
 	display_stripe(seg, 1, "    ");
 	log_print(" ");
-
 }
 
 static int _text_import_area_count(struct config_node *sn, uint32_t *area_count)
@@ -70,6 +81,7 @@ static int _text_import(struct lv_segment *seg, const struct config_node *sn,
 			struct hash_table *pv_hash)
 {
 	const struct config_node *cn;
+	char *logname = NULL;
 
 	if (find_config_node(sn, "extents_moved")) {
 		if (get_config_uint32(sn, "extents_moved",
@@ -82,13 +94,42 @@ static int _text_import(struct lv_segment *seg, const struct config_node *sn,
 		}
 	}
 
+	if (find_config_node(sn, "region_size")) {
+		if (!get_config_uint32(sn, "region_size",
+				      &seg->region_size)) {
+			log_error("Couldn't read 'region_size' for "
+				  "segment '%s'.", sn->key);
+			return 0;
+		}
+	}
+
+        if ((cn = find_config_node(sn, "mirror_log"))) {
+                if (!cn->v || !cn->v->v.str) {
+                        log_error("Mirror log type must be a string.");
+                        return 0;
+                }
+                logname = cn->v->v.str;
+		if (!(seg->log_lv = find_lv(seg->lv->vg, logname))) {
+			log_error("Unrecognised mirror log in segment %s.",
+				  sn->key);
+			return 0;
+		}
+		seg->log_lv->status |= MIRROR_LOG;
+        }
+
+	if (logname && !seg->region_size) {
+		log_error("Missing region size for mirror log for segment "
+			  "'%s'.", sn->key);
+		return 0;
+	}
+
 	if (!(cn = find_config_node(sn, "mirrors"))) {
 		log_error("Couldn't find mirrors array for segment "
 			  "'%s'.", sn->key);
 		return 0;
 	}
 
-	return text_import_areas(seg, sn, cn, pv_hash);
+	return text_import_areas(seg, sn, cn, pv_hash, MIRROR_IMAGE);
 }
 
 static int _text_export(const struct lv_segment *seg, struct formatter *f)
@@ -96,7 +137,11 @@ static int _text_export(const struct lv_segment *seg, struct formatter *f)
 	outf(f, "mirror_count = %u", seg->area_count);
 	if (seg->status & PVMOVE)
 		out_size(f, (uint64_t) seg->extents_copied * seg->lv->vg->extent_size,
-			 "extents_moved = %u", seg->extents_copied);
+			 "extents_moved = %" PRIu32, seg->extents_copied);
+	if (seg->log_lv)
+		outf(f, "mirror_log = \"%s\"", seg->log_lv->name);
+	if (seg->region_size)
+		outf(f, "region_size = %" PRIu32, seg->region_size);
 
 	return out_areas(f, seg, "mirror");
 }
@@ -112,7 +157,7 @@ static struct mirror_state *_init_target(struct pool *mem,
 		return NULL;
 	}
 
-	mirr_state->region_size = 2 *
+	mirr_state->default_region_size = 2 *
 	    find_config_int(cft->root,
 			    "activation/mirror_region_size",
 			    DEFAULT_MIRROR_REGION_SIZE);
@@ -120,6 +165,47 @@ static struct mirror_state *_init_target(struct pool *mem,
 	return mirr_state;
 }
 
+static int _compose_log_line(struct dev_manager *dm, struct lv_segment *seg,
+			     char *params, size_t paramsize, int *pos,
+			     int areas, uint32_t region_size)
+{
+	int tw;
+	char devbuf[10];
+	const char *clustered = "";
+
+	/*
+	 * Use clustered mirror log for non-exclusive activation 
+	 * in clustered VG.
+	 */
+	if ((!(seg->lv->status & ACTIVATE_EXCL) &&
+	      (seg->lv->vg->status & CLUSTERED)))
+		clustered = "cluster ";
+
+	if (!seg->log_lv)
+		tw = lvm_snprintf(params, paramsize, "%score 1 %u %u ",
+				  clustered, region_size, areas);
+	else {
+		if (!build_dev_string(dm, seg->log_lv->lvid.s, devbuf,
+				      sizeof(devbuf), "log")) {
+			stack;
+			return 0;
+		}
+
+		/* FIXME add sync parm? */
+		tw = lvm_snprintf(params, paramsize, "%sdisk 2 %s %u %u ",
+				  clustered, devbuf, region_size, areas);
+	}
+
+	if (tw < 0) {
+		stack;
+		return -1;
+	}
+
+	*pos += tw;
+
+	return 1;
+}
+
 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,
@@ -156,19 +242,27 @@ static int _compose_target_line(struct dev_manager *dm, struct pool *mem,
 	} else {
 		*target = "mirror";
 
-		/* Find largest power of 2 region size unit we can use */
-		region_max = (1 << (ffs(seg->area_len) - 1)) *
+		if (!(seg->status & PVMOVE)) {
+			if (!seg->region_size) {
+				log_error("Missing region size for mirror segment.");
+				return 0;
+			}
+			region_size = seg->region_size;
+		} else {
+			/* Find largest power of 2 region size unit we can use */
+			region_max = (1 << (ffs(seg->area_len) - 1)) *
 			      seg->lv->vg->extent_size;
 
-		region_size = mirr_state->region_size;
-		if (region_max < region_size) {
-			region_size = region_max;
-			log_verbose("Using reduced mirror region size of %u sectors",
-				    region_size);
+			region_size = mirr_state->default_region_size;
+			if (region_max < region_size) {
+				region_size = region_max;
+				log_verbose("Using reduced mirror region size of %u sectors",
+					    region_size);
+			}
 		}
 
-		if ((ret = compose_log_line(dm, seg, params, paramsize, pos,
-					    areas, region_size)) <= 0) {
+		if ((ret = _compose_log_line(dm, seg, params, paramsize, pos,
+					     areas, region_size)) <= 0) {
 			stack;
 			return ret;
 		}
@@ -185,18 +279,41 @@ static int _target_percent(void **target_state, struct pool *mem,
 {
 	struct mirror_state *mirr_state;
 	uint64_t numerator, denominator;
+	unsigned mirror_count, m;
+	int used;
+	char *pos = params;
 
 	if (!*target_state)
 		*target_state = _init_target(mem, cft);
 
 	mirr_state = *target_state;
 
+	/* Status line: <#mirrors> (maj:min)+ <synced>/<total_regions> */
 	log_debug("Mirror status: %s", params);
-	if (sscanf(params, "%*d %*x:%*x %*x:%*x %" PRIu64
-		   "/%" PRIu64, &numerator, &denominator) != 2) {
-		log_error("Failure parsing mirror status: %s", params);
+
+	if (sscanf(pos, "%u %n", mirror_count, used) != 1) {
+		log_error("Failure parsing mirror status mirror count: %s",
+			  params);
 		return 0;
 	}
+	pos += used;
+
+	for (m = 0; m < mirror_count; m++) {
+		if (sscanf(pos, "%*x:%*x %n", &used) != 0) {
+			log_error("Failure parsing mirror status devices: %s",
+				  params);
+			return 0;
+		}
+		pos += used;
+	}
+
+	if (sscanf(pos, "%" PRIu64 "/%" PRIu64 "%n", &numerator, &denominator,
+		   &used) != 2) {
+		log_error("Failure parsing mirror status fraction: %s", params);
+		return 0;
+	}
+	pos += used;
+
 	*total_numerator += numerator;
 	*total_denominator += denominator;
 

lib/misc/lvm-file.c

@@ -236,7 +236,7 @@ void sync_dir(const char *file)
 		goto out;
 	}
 
-	if (fsync(fd) == -1)
+	if (fsync(fd) && (errno != EROFS) && (errno != EINVAL))
 		log_sys_error("fsync", dir);
 
 	close(fd);

lib/misc/selinux.c

@@ -18,25 +18,28 @@
 
 #include <selinux/selinux.h>
 
-int set_selinux_context(const char *path)
+int set_selinux_context(const char *path, mode_t mode)
 {
 	security_context_t scontext;
 
-	log_very_verbose("Setting SELinux context for %s", path);
 	if (is_selinux_enabled() <= 0)
 		return 1;
 
-	if (matchpathcon(path, 0, &scontext) < 0) {
-		log_sys_error("matchpathcon", path);
+	if (matchpathcon(path, mode, &scontext) < 0) {
+		log_error("%s: matchpathcon %07o failed: %s", path, mode,
+			  strerror(errno));
 		return 0;
 	}
 
+	log_very_verbose("Setting SELinux context for %s to %s.",
+			 path, scontext);
+
 	if ((lsetfilecon(path, scontext) < 0) && (errno != ENOTSUP)) {
 		log_sys_error("lsetfilecon", path);
-		free(scontext);
+		freecon(scontext);
 		return 0;
 	}
 
-	free(scontext);
+	freecon(scontext);
 	return 1;
 }

lib/misc/selinux.h

@@ -15,6 +15,8 @@
 #ifndef _LVM_SELINUX_H
 #define _LVM_SELINUX_H
 
-int set_selinux_context(const char * path);
+#include <sys/types.h>
+
+int set_selinux_context(const char * path, mode_t mode);
 
 #endif

lib/misc/sharedlib.c

@@ -22,21 +22,28 @@
 #include <sys/stat.h>
 #include <dlfcn.h>
 
-void *load_shared_library(struct config_tree *cft, const char *libname,
-			  const char *desc)
+static void _get_library_path(struct config_tree *cft, const char *libname,
+			      char *path, int path_len)
 {
-	char path[PATH_MAX];
 	struct stat info;
 	const char *lib_dir;
-	void *library;
 
 	/* If libname doesn't begin with '/' then use lib_dir/libname,
 	 * if present */
 	if (libname[0] == '/' ||
 	    !(lib_dir = find_config_str(cft->root, "global/library_dir", 0)) ||
-	    (lvm_snprintf(path, sizeof(path), "%s/%s", lib_dir,
+	    (lvm_snprintf(path, path_len, "%s/%s", lib_dir,
 			  libname) == -1) || stat(path, &info) == -1)
-		strncpy(path, libname, sizeof(path));
+		strncpy(path, libname, path_len);
+}
+
+void *load_shared_library(struct config_tree *cft, const char *libname,
+			  const char *desc)
+{
+	char path[PATH_MAX];
+	void *library;
+
+	_get_library_path(cft, libname, path, sizeof(path));
 
 	log_very_verbose("Opening shared %s library %s", desc, path);
 

lib/mm/dbg_malloc.c

@@ -112,6 +112,9 @@ void *malloc_aux(size_t s, const char *file, int line)
 	if (_mem_stats.bytes > _mem_stats.mbytes)
 		_mem_stats.mbytes = _mem_stats.bytes;
 
+	/* log_debug("Allocated: %u %u %u", nb->id, _mem_stats.blocks_allocated,
+		  _mem_stats.bytes); */
+
 	return nb + 1;
 }
 

lib/report/columns.h

@@ -19,7 +19,7 @@
 
 /* *INDENT-OFF* */
 FIELD(LVS, lv, STR, "LV UUID", lvid.id[1], 38, uuid, "lv_uuid")
-FIELD(LVS, lv, STR, "LV", name, 4, string, "lv_name")
+FIELD(LVS, lv, STR, "LV", lvid, 4, lvname, "lv_name")
 FIELD(LVS, lv, STR, "Attr", lvid, 4, lvstatus, "lv_attr")
 FIELD(LVS, lv, NUM, "Maj", major, 3, int32, "lv_major")
 FIELD(LVS, lv, NUM, "Min", minor, 3, int32, "lv_minor")
@@ -32,6 +32,7 @@ FIELD(LVS, lv, NUM, "Snap%", lvid, 6, snpercent, "snap_percent")
 FIELD(LVS, lv, NUM, "Copy%", lvid, 6, copypercent, "copy_percent")
 FIELD(LVS, lv, STR, "Move", lvid, 4, movepv, "move_pv")
 FIELD(LVS, lv, STR, "LV Tags", tags, 7, tags, "lv_tags")
+FIELD(LVS, lv, STR, "Log", lvid, 3, loglv, "mirror_log")
 
 FIELD(PVS, pv, STR, "Fmt", id, 3, pvfmt, "pv_fmt")
 FIELD(PVS, pv, STR, "PV UUID", id, 38, uuid, "pv_uuid")
@@ -66,7 +67,8 @@ FIELD(VGS, vg, STR, "VG Tags", tags, 7, tags, "vg_tags")
 FIELD(SEGS, seg, STR, "Type", list, 4, segtype, "segtype")
 FIELD(SEGS, seg, NUM, "#Str", area_count, 4, uint32, "stripes")
 FIELD(SEGS, seg, NUM, "Stripe", stripe_size, 6, size32, "stripesize")
-FIELD(SEGS, seg, NUM, "Chunk", chunk_size, 5, size32, "chunksize")
+FIELD(SEGS, seg, NUM, "Chunk", list, 5, chunksize, "chunksize")
+FIELD(SEGS, seg, NUM, "Region", region_size, 6, size32, "regionsize")
 FIELD(SEGS, seg, NUM, "Start", list, 5, segstart, "seg_start")
 FIELD(SEGS, seg, NUM, "SSize", list, 5, segsize, "seg_size")
 FIELD(SEGS, seg, STR, "Seg Tags", tags, 8, tags, "seg_tags")

lib/report/report.c

@@ -154,17 +154,17 @@ static int _devices_disp(struct report_handle *rh, struct field *field,
 	}
 
 	for (s = 0; s < seg->area_count; s++) {
-		switch (seg->area[s].type) {
+		switch (seg_type(seg, s)) {
 		case AREA_LV:
-			name = seg->area[s].u.lv.lv->name;
-			extent = seg->area[s].u.lv.le;
+			name = seg_lv(seg, s)->name;
+			extent = seg_le(seg, s);
 			break;
 		case AREA_PV:
-			name = dev_name(seg->area[s].u.pv.pvseg->pv->dev);
-			extent = seg->area[s].u.pv.pvseg->pe;
+			name = dev_name(seg_dev(seg, s));
+			extent = seg_pe(seg, s);
 			break;
-		default:
-			name = "unknown";
+		case AREA_UNASSIGNED:
+			name = "unassigned";
 			extent = 0;
 		}
 
@@ -337,6 +337,10 @@ static int _lvstatus_disp(struct report_handle *rh, struct field *field,
 		repstr[0] = 'p';
 	else if (lv->status & MIRRORED)
 		repstr[0] = 'm';
+	else if (lv->status & MIRROR_IMAGE)
+		repstr[0] = 'i';
+	else if (lv->status & MIRROR_LOG)
+		repstr[0] = 'l';
 	else if (lv->status & VIRTUAL)
 		repstr[0] = 'v';
 	else if (lv_is_origin(lv))
@@ -428,7 +432,7 @@ static int _vgstatus_disp(struct report_handle *rh, struct field *field,
 	const struct volume_group *vg = (const struct volume_group *) data;
 	char *repstr;
 
-	if (!(repstr = pool_zalloc(rh->mem, 6))) {
+	if (!(repstr = pool_zalloc(rh->mem, 7))) {
 		log_error("pool_alloc failed");
 		return 0;
 	}
@@ -455,6 +459,11 @@ static int _vgstatus_disp(struct report_handle *rh, struct field *field,
 
 	repstr[4] = _alloc_policy_char(vg->alloc);
 
+	if (vg->status & CLUSTERED)
+		repstr[5] = 'c';
+	else
+		repstr[5] = '-';
+
 	field->report_string = repstr;
 	field->sort_value = (const void *) field->report_string;
 
@@ -490,19 +499,69 @@ static int _origin_disp(struct report_handle *rh, struct field *field,
 	return 1;
 }
 
+static int _loglv_disp(struct report_handle *rh, struct field *field,
+		       const void *data)
+{
+	const struct logical_volume *lv = (const struct logical_volume *) data;
+	struct lv_segment *seg;
+
+	list_iterate_items(seg, &lv->segments) {
+		if (!seg_is_mirrored(seg) || !seg->log_lv)
+			continue;
+		return _string_disp(rh, field, &seg->log_lv->name);
+	}
+
+	field->report_string = "";
+	field->sort_value = (const void *) field->report_string;
+
+	return 1;
+}
+
+static int _lvname_disp(struct report_handle *rh, struct field *field,
+			const void *data)
+{
+	const struct logical_volume *lv = (const struct logical_volume *) data;
+	char *repstr;
+	size_t len;
+
+	/* FIXME Remove need for snapshot special case */
+	if (lv->status & VISIBLE_LV || lv_is_cow(lv)) {
+		repstr = lv->name;
+		return _string_disp(rh, field, &repstr);
+	}
+
+	len = strlen(lv->name) + 3;
+	if (!(repstr = pool_zalloc(rh->mem, len))) {
+		log_error("pool_alloc failed");
+		return 0;
+	}
+
+	if (lvm_snprintf(repstr, len, "[%s]", lv->name) < 0) {
+		log_error("lvname snprintf failed");
+		return 0;
+	}
+
+	field->report_string = repstr;
+
+	if (!(field->sort_value = pool_strdup(rh->mem, lv->name))) {
+		log_error("pool_strdup failed");
+		return 0;
+	}
+
+	return 1;
+}
+
 static int _movepv_disp(struct report_handle *rh, struct field *field,
 			const void *data)
 {
 	const struct logical_volume *lv = (const struct logical_volume *) data;
 	const char *name;
-	struct list *segh;
 	struct lv_segment *seg;
 
-	list_iterate(segh, &lv->segments) {
-		seg = list_item(segh, struct lv_segment);
+	list_iterate_items(seg, &lv->segments) {
 		if (!(seg->status & PVMOVE))
 			continue;
-		name = dev_name(seg->area[0].u.pv.pvseg->pv->dev);
+		name = dev_name(seg_dev(seg, 0));
 		return _string_disp(rh, field, &name);
 	}
 
@@ -601,6 +660,21 @@ static int _segsize_disp(struct report_handle *rh, struct field *field,
 	return _size64_disp(rh, field, &size);
 }
 
+static int _chunksize_disp(struct report_handle *rh, struct field *field,
+			   const void *data)
+{
+	const struct lv_segment *seg = (const struct lv_segment *) data;
+	struct lv_segment *snap_seg;
+	uint64_t size;
+
+	if ((snap_seg = find_cow(seg->lv)))
+		size = (uint64_t) snap_seg->chunk_size;
+	else
+		size = 0;
+
+	return _size64_disp(rh, field, &size);
+}
+
 static int _pvused_disp(struct report_handle *rh, struct field *field,
 			const void *data)
 {
@@ -917,12 +991,9 @@ static int _field_match(struct report_handle *rh, const char *field, size_t len)
 static int _add_sort_key(struct report_handle *rh, uint32_t field_num,
 			 uint32_t flags)
 {
-	struct list *fh;
 	struct field_properties *fp, *found = NULL;
 
-	list_iterate(fh, &rh->field_props) {
-		fp = list_item(fh, struct field_properties);
-
+	list_iterate_items(fp, &rh->field_props) {
 		if (fp->field_num == field_num) {
 			found = fp;
 			break;
@@ -1138,7 +1209,6 @@ int report_object(void *handle, struct volume_group *vg,
 		  struct lv_segment *seg, struct pv_segment *pvseg)
 {
 	struct report_handle *rh = handle;
-	struct list *fh;
 	struct field_properties *fp;
 	struct row *row;
 	struct field *field;
@@ -1168,9 +1238,7 @@ int report_object(void *handle, struct volume_group *vg,
 	list_add(&rh->rows, &row->list);
 
 	/* For each field to be displayed, call its report_fn */
-	list_iterate(fh, &rh->field_props) {
-		fp = list_item(fh, struct field_properties);
-
+	list_iterate_items(fp, &rh->field_props) {
 		skip = 0;
 
 		if (!(field = pool_zalloc(rh->mem, sizeof(*field)))) {
@@ -1231,7 +1299,6 @@ int report_object(void *handle, struct volume_group *vg,
 static int _report_headings(void *handle)
 {
 	struct report_handle *rh = handle;
-	struct list *fh;
 	struct field_properties *fp;
 	const char *heading;
 	char buf[1024];
@@ -1250,8 +1317,7 @@ static int _report_headings(void *handle)
 	}
 
 	/* First heading line */
-	list_iterate(fh, &rh->field_props) {
-		fp = list_item(fh, struct field_properties);
+	list_iterate_items(fp, &rh->field_props) {
 		if (fp->flags & FLD_HIDDEN)
 			continue;
 
@@ -1268,7 +1334,7 @@ static int _report_headings(void *handle)
 		} else if (!pool_grow_object(rh->mem, heading, strlen(heading)))
 			goto bad;
 
-		if (!list_end(&rh->field_props, fh))
+		if (!list_end(&rh->field_props, &fp->list))
 			if (!pool_grow_object(rh->mem, rh->separator,
 					      strlen(rh->separator)))
 				goto bad;
@@ -1336,7 +1402,6 @@ static int _row_compare(const void *a, const void *b)
 static int _sort_rows(struct report_handle *rh)
 {
 	struct row *(*rows)[];
-	struct list *rowh;
 	uint32_t count = 0;
 	struct row *row;
 
@@ -1346,10 +1411,8 @@ static int _sort_rows(struct report_handle *rh)
 		return 0;
 	}
 
-	list_iterate(rowh, &rh->rows) {
-		row = list_item(rowh, struct row);
+	list_iterate_items(row, &rh->rows)
 		(*rows)[count++] = row;
-	}
 
 	qsort(rows, count, sizeof(**rows), _row_compare);
 

lib/striped/striped.c

@@ -82,7 +82,7 @@ static int _text_import(struct lv_segment *seg, const struct config_node *sn,
 
 	seg->area_len /= seg->area_count;
 
-	return text_import_areas(seg, sn, cn, pv_hash);
+	return text_import_areas(seg, sn, cn, pv_hash, 0);
 }
 
 static int _text_export(const struct lv_segment *seg, struct formatter *f)
@@ -115,14 +115,15 @@ static int _segments_compatible(struct lv_segment *first,
 		/* FIXME Relax this to first area type != second area type */
 		/*       plus the additional AREA_LV checks needed */
 		if ((first->area[s].type != AREA_PV) ||
-		    (second->area[s].type != AREA_PV)) return 0;
+		    (second->area[s].type != AREA_PV))
+			return 0;
 
 		width = first->area_len;
 
-		if ((first->area[s].u.pv.pvseg->pv !=
-		     second->area[s].u.pv.pvseg->pv) ||
-		    (first->area[s].u.pv.pvseg->pe + width !=
-		     second->area[s].u.pv.pvseg->pe))
+		if ((seg_pv(first, s) !=
+		     seg_pv(second, s)) ||
+		    (seg_pe(first, s) + width !=
+		     seg_pe(second, s)))
 			return 0;
 	}
 
@@ -144,8 +145,8 @@ static int _merge_segments(struct lv_segment *seg1, struct lv_segment *seg2)
 
 	for (s = 0; s < seg1->area_count; s++)
 		if (seg1->area[s].type == AREA_PV)
-			merge_pv_segments(seg1->area[s].u.pv.pvseg,
-					  seg2->area[s].u.pv.pvseg);
+			merge_pv_segments(seg_pvseg(seg1, s),
+					  seg_pvseg(seg2, s));
 
 	return 1;
 }

libdm/.exported_symbols

@@ -21,6 +21,7 @@ dm_task_set_sector
 dm_task_set_message
 dm_task_add_target
 dm_task_no_open_count
+dm_task_skip_lockfs
 dm_get_next_target
 dm_task_run
 dm_set_dev_dir
@@ -28,3 +29,15 @@ dm_dir
 dm_format_dev
 dm_lib_release
 dm_lib_exit
+dm_deptree_create
+dm_deptree_free
+dm_deptree_add_dev
+dm_deptree_node_get_name
+dm_deptree_node_get_uuid
+dm_deptree_node_get_info
+dm_deptree_node_num_children
+dm_deptree_node_num_parents
+dm_deptree_find_node
+dm_deptree_next_child
+dm_deptree_next_parent
+dm_is_dm_major

libdm/Makefile.in

@@ -25,7 +25,15 @@ ifeq ($(MAKECMDGOALS),distclean)
   SUBDIRS += event
 endif
 
-SOURCES = libdm-common.c libdm-file.c $(interface)/libdm-iface.c
+SOURCES =\
+	datastruct/bitset.c \
+	datastruct/hash.c \
+	libdm-common.c \
+	libdm-file.c \
+	libdm-deptree.c \
+	mm/dbg_malloc.c \
+	mm/pool.c \
+	$(interface)/libdm-iface.c
 
 INCLUDES = -I$(interface)
 

libdm/datastruct/bitset.c

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "bitset.h"
+
+/* FIXME: calculate this. */
+#define INT_SHIFT 5
+
+bitset_t bitset_create(struct pool *mem, unsigned num_bits)
+{
+	unsigned n = (num_bits / BITS_PER_INT) + 2;
+	size_t size = sizeof(int) * n;
+	bitset_t bs;
+	
+	if (mem)
+		bs = pool_zalloc(mem, size);
+	else
+		bs = dbg_malloc(size);
+
+	if (!bs)
+		return NULL;
+
+	*bs = num_bits;
+
+	if (!mem)
+		bit_clear_all(bs);
+
+	return bs;
+}
+
+void bitset_destroy(bitset_t bs)
+{
+	dbg_free(bs);
+}
+
+void bit_union(bitset_t out, bitset_t in1, bitset_t in2)
+{
+	int i;
+	for (i = (in1[0] / BITS_PER_INT) + 1; i; i--)
+		out[i] = in1[i] | in2[i];
+}
+
+/*
+ * FIXME: slow
+ */
+static inline int _test_word(uint32_t test, int bit)
+{
+	while (bit < BITS_PER_INT) {
+		if (test & (0x1 << bit))
+			return bit;
+		bit++;
+	}
+
+	return -1;
+}
+
+int bit_get_next(bitset_t bs, int last_bit)
+{
+	int bit, word;
+	uint32_t test;
+
+	last_bit++;		/* otherwise we'll return the same bit again */
+
+	while (last_bit < bs[0]) {
+		word = last_bit >> INT_SHIFT;
+		test = bs[word + 1];
+		bit = last_bit & (BITS_PER_INT - 1);
+
+		if ((bit = _test_word(test, bit)) >= 0)
+			return (word * BITS_PER_INT) + bit;
+
+		last_bit = last_bit - (last_bit & (BITS_PER_INT - 1)) +
+		    BITS_PER_INT;
+	}
+
+	return -1;
+}
+
+int bit_get_first(bitset_t bs)
+{
+	return bit_get_next(bs, -1);
+}

libdm/datastruct/bitset.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_BITSET_H
+#define _LVM_BITSET_H
+
+#include "pool.h"
+
+#include <limits.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) \
+   (bs[(i / BITS_PER_INT) + 1] & (0x1 << (i & (BITS_PER_INT - 1))))
+
+#define bit_set(bs, i) \
+   (bs[(i / BITS_PER_INT) + 1] |= (0x1 << (i & (BITS_PER_INT - 1))))
+
+#define bit_clear(bs, i) \
+   (bs[(i / BITS_PER_INT) + 1] &= ~(0x1 << (i & (BITS_PER_INT - 1))))
+
+#define bit_set_all(bs) \
+   memset(bs + 1, -1, ((*bs / BITS_PER_INT) + 1) * sizeof(int))
+
+#define bit_clear_all(bs) \
+   memset(bs + 1, 0, ((*bs / BITS_PER_INT) + 1) * sizeof(int))
+
+#define bit_copy(bs1, bs2) \
+   memcpy(bs1 + 1, bs2 + 1, ((*bs1 / BITS_PER_INT) + 1) * sizeof(int))
+
+#endif

libdm/datastruct/hash.c

@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "hash.h"
+
+struct hash_node {
+	struct hash_node *next;
+	void *data;
+	int keylen;
+	char key[0];
+};
+
+struct hash_table {
+	int num_nodes;
+	int num_slots;
+	struct hash_node **slots;
+};
+
+/* Permutation of the Integers 0 through 255 */
+static unsigned char _nums[] = {
+	1, 14, 110, 25, 97, 174, 132, 119, 138, 170, 125, 118, 27, 233, 140, 51,
+	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,
+	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,
+	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,
+	193, 239, 101, 242, 5, 171, 126, 11, 74, 59, 137, 228, 108, 191, 232,
+	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,
+	249, 236, 45, 244, 111, 182, 153, 136, 129, 90, 217, 202, 19, 165, 231,
+	71,
+	230, 142, 96, 227, 62, 179, 246, 114, 162, 53, 160, 215, 205, 180, 47,
+	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
+};
+
+static struct hash_node *_create_node(const char *str, int len)
+{
+	struct hash_node *n = dbg_malloc(sizeof(*n) + len);
+
+	if (n) {
+		memcpy(n->key, str, len);
+		n->keylen = len;
+	}
+
+	return n;
+}
+
+static unsigned _hash(const char *str, uint32_t len)
+{
+	unsigned long h = 0, g, i;
+
+	for (i = 0; i < len; i++) {
+		h <<= 4;
+		h += _nums[(int) *str++];
+		g = h & ((unsigned long) 0xf << 16u);
+		if (g) {
+			h ^= g >> 16u;
+			h ^= g >> 5u;
+		}
+	}
+
+	return h;
+}
+
+struct hash_table *hash_create(unsigned size_hint)
+{
+	size_t len;
+	unsigned new_size = 16u;
+	struct hash_table *hc = dbg_malloc(sizeof(*hc));
+
+	if (!hc) {
+		stack;
+		return 0;
+	}
+
+	memset(hc, 0, sizeof(*hc));
+
+	/* round size hint up to a power of two */
+	while (new_size < size_hint)
+		new_size = new_size << 1;
+
+	hc->num_slots = new_size;
+	len = sizeof(*(hc->slots)) * new_size;
+	if (!(hc->slots = dbg_malloc(len))) {
+		stack;
+		goto bad;
+	}
+	memset(hc->slots, 0, len);
+	return hc;
+
+      bad:
+	dbg_free(hc->slots);
+	dbg_free(hc);
+	return 0;
+}
+
+static void _free_nodes(struct hash_table *t)
+{
+	struct hash_node *c, *n;
+	int i;
+
+	for (i = 0; i < t->num_slots; i++)
+		for (c = t->slots[i]; c; c = n) {
+			n = c->next;
+			dbg_free(c);
+		}
+}
+
+void hash_destroy(struct hash_table *t)
+{
+	_free_nodes(t);
+	dbg_free(t->slots);
+	dbg_free(t);
+}
+
+static inline struct hash_node **_find(struct hash_table *t, const char *key,
+				       uint32_t len)
+{
+	unsigned h = _hash(key, len) & (t->num_slots - 1);
+	struct hash_node **c;
+
+	for (c = &t->slots[h]; *c; c = &((*c)->next))
+		if (!memcmp(key, (*c)->key, len))
+			break;
+
+	return c;
+}
+
+void *hash_lookup_binary(struct hash_table *t, const char *key,
+			 uint32_t len)
+{
+	struct hash_node **c = _find(t, key, len);
+	return *c ? (*c)->data : 0;
+}
+
+int hash_insert_binary(struct hash_table *t, const char *key,
+		       uint32_t len, void *data)
+{
+	struct hash_node **c = _find(t, key, len);
+
+	if (*c)
+		(*c)->data = data;
+	else {
+		struct hash_node *n = _create_node(key, len);
+
+		if (!n)
+			return 0;
+
+		n->data = data;
+		n->next = 0;
+		*c = n;
+		t->num_nodes++;
+	}
+
+	return 1;
+}
+
+void hash_remove_binary(struct hash_table *t, const char *key,
+			uint32_t len)
+{
+	struct hash_node **c = _find(t, key, len);
+
+	if (*c) {
+		struct hash_node *old = *c;
+		*c = (*c)->next;
+		dbg_free(old);
+		t->num_nodes--;
+	}
+}
+
+void *hash_lookup(struct hash_table *t, const char *key)
+{
+	return hash_lookup_binary(t, key, strlen(key) + 1);
+}
+
+int hash_insert(struct hash_table *t, const char *key, void *data)
+{
+	return hash_insert_binary(t, key, strlen(key) + 1, data);
+}
+
+void hash_remove(struct hash_table *t, const char *key)
+{
+	hash_remove_binary(t, key, strlen(key) + 1);
+}
+
+unsigned hash_get_num_entries(struct hash_table *t)
+{
+	return t->num_nodes;
+}
+
+void hash_iter(struct hash_table *t, iterate_fn f)
+{
+	struct hash_node *c;
+	int i;
+
+	for (i = 0; i < t->num_slots; i++)
+		for (c = t->slots[i]; c; c = c->next)
+			f(c->data);
+}
+
+void hash_wipe(struct hash_table *t)
+{
+	_free_nodes(t);
+	memset(t->slots, 0, sizeof(struct hash_node *) * t->num_slots);
+	t->num_nodes = 0;
+}
+
+char *hash_get_key(struct hash_table *t, struct hash_node *n)
+{
+	return n->key;
+}
+
+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 s)
+{
+	struct hash_node *c = NULL;
+	int i;
+
+	for (i = s; i < t->num_slots && !c; i++)
+		c = t->slots[i];
+
+	return c;
+}
+
+struct hash_node *hash_get_first(struct hash_table *t)
+{
+	return _next_slot(t, 0);
+}
+
+struct hash_node *hash_get_next(struct hash_table *t, struct hash_node *n)
+{
+	unsigned h = _hash(n->key, n->keylen) & (t->num_slots - 1);
+	return n->next ? n->next : _next_slot(t, h + 1);
+}

libdm/datastruct/hash.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_HASH_H
+#define _LVM_HASH_H
+
+struct hash_table;
+struct hash_node;
+
+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);
+int hash_insert(struct hash_table *t, const char *key, void *data);
+void hash_remove(struct hash_table *t, const char *key);
+
+void *hash_lookup_binary(struct hash_table *t, const char *key, uint32_t len);
+int hash_insert_binary(struct hash_table *t, const char *key, uint32_t len,
+		       void *data);
+void hash_remove_binary(struct hash_table *t, const char *key, uint32_t len);
+
+unsigned hash_get_num_entries(struct hash_table *t);
+void hash_iter(struct hash_table *t, iterate_fn f);
+
+char *hash_get_key(struct hash_table *t, struct hash_node *n);
+void *hash_get_data(struct hash_table *t, struct hash_node *n);
+struct hash_node *hash_get_first(struct hash_table *t);
+struct hash_node *hash_get_next(struct hash_table *t, struct hash_node *n);
+
+#define hash_iterate(v, h) \
+	for (v = hash_get_first(h); v; \
+	     v = hash_get_next(h, v))
+
+#endif

libdm/datastruct/list.h

@@ -103,6 +103,14 @@ static inline int list_end(struct list *head, struct list *elem)
 	return elem->n == head;
 }
 
+/*
+ * Return first element of the list or NULL if empty
+ */
+static inline struct list *list_first(struct list *head)
+{
+	return (list_empty(head) ? NULL : head->n);
+}
+
 /*
  * Return last element of the list or NULL if empty
  */
@@ -194,6 +202,25 @@ static inline struct list *list_next(struct list *head, struct list *elem)
  */
 #define list_iterate_items(v, head) list_iterate_items_gen(v, (head), list)
 
+/*
+ * Walk a list backwards, setting 'v' in turn to the containing structure 
+ * of each item.
+ * The containing structure should be the same type as 'v'.
+ * The 'struct list' variable within the containing structure is 'field'.
+ */
+#define list_iterate_back_items_gen(v, head, field) \
+	for (v = list_struct_base((head)->p, typeof(*v), field); \
+	     &v->field != (head); \
+	     v = list_struct_base(v->field.p, typeof(*v), field))
+
+/*
+ * Walk a list backwards, setting 'v' in turn to the containing structure 
+ * of each item.
+ * The containing structure should be the same type as 'v'.
+ * The list should be 'struct list list' within the containing structure.
+ */
+#define list_iterate_back_items(v, head) list_iterate_back_items_gen(v, (head), list)
+
 /*
  * Return the number of elements in a list by walking it.
  */

libdm/ioctl/libdm-iface.c

@@ -17,6 +17,7 @@
 #include "libdm-targets.h"
 #include "libdm-common.h"
 #include "libdm-file.h"
+#include "bitset.h"
 
 #ifdef DM_COMPAT
 #  include "libdm-compat.h"
@@ -56,13 +57,17 @@
 #define PROC_DEVICES "/proc/devices"
 #define MISC_NAME "misc"
 
+#define NUMBER_OF_MAJORS 4096
+
 /* dm major version no for running kernel */
 static int _dm_version = DM_VERSION_MAJOR;
 static int _log_suppress = 0;
 
+static bitset_t _dm_bitset = NULL;
 static int _control_fd = -1;
 static int _version_checked = 0;
 static int _version_ok = 1;
+static unsigned _ioctl_buffer_double_factor = 0;
 
 /*
  * Support both old and new major numbers to ease the transition.
@@ -118,12 +123,17 @@ static void *_align(void *ptr, unsigned int a)
 }
 
 #ifdef DM_IOCTLS
+/*
+ * Set number to NULL to populate _dm_bitset - otherwise first
+ * match is returned.
+ */
 static int _get_proc_number(const char *file, const char *name,
 			    uint32_t *number)
 {
 	FILE *fl;
 	char nm[256];
 	int c;
+	uint32_t num;
 
 	if (!(fl = fopen(file, "r"))) {
 		log_error("%s: fopen failed: %s", file, strerror(errno));
@@ -131,10 +141,14 @@ static int _get_proc_number(const char *file, const char *name,
 	}
 
 	while (!feof(fl)) {
-		if (fscanf(fl, "%d %255s\n", number, &nm[0]) == 2) {
+		if (fscanf(fl, "%d %255s\n", &num, &nm[0]) == 2) {
 			if (!strcmp(name, nm)) {
-				fclose(fl);
-				return 1;
+				if (number) {
+					*number = num;
+					fclose(fl);
+					return 1;
+				}
+				bit_set(_dm_bitset, num);
 			}
 		} else do {
 			c = fgetc(fl);
@@ -142,8 +156,12 @@ static int _get_proc_number(const char *file, const char *name,
 	}
 	fclose(fl);
 
-	log_error("%s: No entry for %s found", file, name);
-	return 0;
+	if (number) {
+		log_error("%s: No entry for %s found", file, name);
+		return 0;
+	}
+
+	return 1;
 }
 
 static int _control_device_number(uint32_t *major, uint32_t *minor)
@@ -219,7 +237,7 @@ static int _create_control(const char *control, uint32_t major, uint32_t minor)
 	}
 
 #ifdef HAVE_SELINUX
-        if (!set_selinux_context(control)) {
+        if (!set_selinux_context(control, S_IFCHR)) {
                 stack;
                 return 0;
         }
@@ -229,6 +247,35 @@ static int _create_control(const char *control, uint32_t major, uint32_t minor)
 }
 #endif
 
+static int _create_dm_bitset(void)
+{
+#ifdef DM_IOCTLS
+	if (_dm_bitset)
+		return 1;
+
+	if (!(_dm_bitset = bitset_create(NULL, NUMBER_OF_MAJORS)))
+		return 0;
+
+	if (!_get_proc_number(PROC_DEVICES, DM_NAME, NULL)) {
+		bitset_destroy(_dm_bitset);
+		_dm_bitset = NULL;
+		return 0;
+	}
+
+	return 1;
+#else
+	return 0;
+#endif
+}
+
+int dm_is_dm_major(uint32_t major)
+{
+	if (!_create_dm_bitset())
+		return 0;
+
+	return bit(_dm_bitset, major) ? 1 : 0;
+}
+
 static int _open_control(void)
 {
 #ifdef DM_IOCTLS
@@ -252,6 +299,11 @@ static int _open_control(void)
 		goto error;
 	}
 
+	if (!_create_dm_bitset()) {
+		log_error("Failed to set up list of device-mapper major numbers");
+		return 0;
+	}
+
 	return 1;
 
 error:
@@ -268,27 +320,27 @@ void dm_task_destroy(struct dm_task *dmt)
 
 	for (t = dmt->head; t; t = n) {
 		n = t->next;
-		free(t->params);
-		free(t->type);
-		free(t);
+		dbg_free(t->params);
+		dbg_free(t->type);
+		dbg_free(t);
 	}
 
 	if (dmt->dev_name)
-		free(dmt->dev_name);
+		dbg_free(dmt->dev_name);
 
 	if (dmt->newname)
-		free(dmt->newname);
+		dbg_free(dmt->newname);
 
 	if (dmt->message)
-		free(dmt->message);
+		dbg_free(dmt->message);
 
 	if (dmt->dmi.v4)
-		free(dmt->dmi.v4);
+		dbg_free(dmt->dmi.v4);
 
 	if (dmt->uuid)
-		free(dmt->uuid);
+		dbg_free(dmt->uuid);
 
-	free(dmt);
+	dbg_free(dmt);
 }
 
 /*
@@ -469,7 +521,7 @@ static struct dm_ioctl_v1 *_flatten_v1(struct dm_task *dmt)
 	if (len < min_size)
 		len = min_size;
 
-	if (!(dmi = malloc(len)))
+	if (!(dmi = dbg_malloc(len)))
 		return NULL;
 
 	memset(dmi, 0, len);
@@ -518,7 +570,7 @@ static struct dm_ioctl_v1 *_flatten_v1(struct dm_task *dmt)
 	return dmi;
 
       bad:
-	free(dmi);
+	dbg_free(dmi);
 	return NULL;
 }
 
@@ -610,8 +662,10 @@ static int _dm_task_run_v1(struct dm_task *dmt)
 	if (dmt->type == DM_DEVICE_TABLE)
 		dmi->flags |= DM_STATUS_TABLE_FLAG;
 
-	log_debug("dm %s %s %s %s", _cmd_data_v1[dmt->type].name, dmi->name,
-		  dmi->uuid, dmt->newname ? dmt->newname : "");
+	log_debug("dm %s %s %s%s%s [%u]", _cmd_data_v1[dmt->type].name,
+		  dmi->name, dmi->uuid, dmt->newname ? " " : "",
+		  dmt->newname ? dmt->newname : "",
+		  dmi->data_size);
 	if (dmt->type == DM_DEVICE_LIST) {
 		if (!_dm_names_v1(dmi))
 			goto bad;
@@ -667,7 +721,7 @@ static int _dm_task_run_v1(struct dm_task *dmt)
 		dmt->type = DM_DEVICE_INFO;
 		if (!dm_task_run(dmt))
 			goto bad;
-		free(dmi);	/* We'll use what info returned */
+		dbg_free(dmi);	/* We'll use what info returned */
 		return 1;
 	}
 
@@ -675,7 +729,7 @@ static int _dm_task_run_v1(struct dm_task *dmt)
 	return 1;
 
       bad:
-	free(dmi);
+	dbg_free(dmi);
 	return 0;
 }
 
@@ -915,7 +969,7 @@ int dm_task_set_ro(struct dm_task *dmt)
 
 int dm_task_set_newname(struct dm_task *dmt, const char *newname)
 {
-	if (!(dmt->newname = strdup(newname))) {
+	if (!(dmt->newname = dbg_strdup(newname))) {
 		log_error("dm_task_set_newname: strdup(%s) failed", newname);
 		return 0;
 	}
@@ -925,7 +979,7 @@ int dm_task_set_newname(struct dm_task *dmt, const char *newname)
 
 int dm_task_set_message(struct dm_task *dmt, const char *message)
 {
-	if (!(dmt->message = strdup(message))) {
+	if (!(dmt->message = dbg_strdup(message))) {
 		log_error("dm_task_set_message: strdup(%s) failed", message);
 		return 0;
 	}
@@ -947,6 +1001,13 @@ int dm_task_no_open_count(struct dm_task *dmt)
 	return 1;
 }
 
+int dm_task_skip_lockfs(struct dm_task *dmt)
+{
+	dmt->skip_lockfs = 1;
+
+	return 1;
+}
+
 int dm_task_set_event_nr(struct dm_task *dmt, uint32_t event_nr)
 {
 	dmt->event_nr = event_nr;
@@ -957,7 +1018,7 @@ int dm_task_set_event_nr(struct dm_task *dmt, uint32_t event_nr)
 struct target *create_target(uint64_t start, uint64_t len, const char *type,
 			     const char *params)
 {
-	struct target *t = malloc(sizeof(*t));
+	struct target *t = dbg_malloc(sizeof(*t));
 
 	if (!t) {
 		log_error("create_target: malloc(%d) failed", sizeof(*t));
@@ -966,12 +1027,12 @@ struct target *create_target(uint64_t start, uint64_t len, const char *type,
 
 	memset(t, 0, sizeof(*t));
 
-	if (!(t->params = strdup(params))) {
+	if (!(t->params = dbg_strdup(params))) {
 		log_error("create_target: strdup(params) failed");
 		goto bad;
 	}
 
-	if (!(t->type = strdup(type))) {
+	if (!(t->type = dbg_strdup(type))) {
 		log_error("create_target: strdup(type) failed");
 		goto bad;
 	}
@@ -981,9 +1042,9 @@ struct target *create_target(uint64_t start, uint64_t len, const char *type,
 	return t;
 
       bad:
-	free(t->params);
-	free(t->type);
-	free(t);
+	dbg_free(t->params);
+	dbg_free(t->type);
+	dbg_free(t);
 	return NULL;
 }
 
@@ -1026,7 +1087,7 @@ static void *_add_target(struct target *t, void *out, void *end)
 	return out;
 }
 
-static struct dm_ioctl *_flatten(struct dm_task *dmt)
+static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count)
 {
 	const size_t min_size = 16 * 1024;
 	const int (*version)[3];
@@ -1077,7 +1138,11 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt)
 	if (len < min_size)
 		len = min_size;
 
-	if (!(dmi = malloc(len)))
+	/* Increase buffer size if repeating because buffer was too small */
+	while (repeat_count--)
+		len *= 2;
+
+	if (!(dmi = dbg_malloc(len)))
 		return NULL;
 
 	memset(dmi, 0, len);
@@ -1098,6 +1163,8 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt)
 		dmi->flags |= DM_SUSPEND_FLAG;
 	if (dmt->read_only)
 		dmi->flags |= DM_READONLY_FLAG;
+	if (dmt->skip_lockfs)
+		dmi->flags |= DM_SKIP_LOCKFS_FLAG;
 
 	if (dmt->minor >= 0) {
 		if (dmt->major <= 0) {
@@ -1133,7 +1200,7 @@ static struct dm_ioctl *_flatten(struct dm_task *dmt)
 	return dmi;
 
       bad:
-	free(dmi);
+	dbg_free(dmi);
 	return NULL;
 }
 
@@ -1268,7 +1335,7 @@ static int _create_and_load_v4(struct dm_task *dmt)
 
 	/* Use the original structure last so the info will be correct */
 	dmt->type = DM_DEVICE_RESUME;
-	free(dmt->uuid);
+	dbg_free(dmt->uuid);
 	dmt->uuid = NULL;
 
 	r = dm_task_run(dmt);
@@ -1276,10 +1343,59 @@ static int _create_and_load_v4(struct dm_task *dmt)
 	return r;
 }
 
+static struct dm_ioctl *_do_dm_ioctl(struct dm_task *dmt, unsigned command,
+				     unsigned repeat_count)
+{
+	struct dm_ioctl *dmi;
+
+	dmi = _flatten(dmt, repeat_count);
+	if (!dmi) {
+		log_error("Couldn't create ioctl argument");
+		return NULL;
+	}
+
+	if (dmt->type == DM_DEVICE_TABLE)
+		dmi->flags |= DM_STATUS_TABLE_FLAG;
+
+	dmi->flags |= DM_EXISTS_FLAG;	/* FIXME */
+
+	if (dmt->no_open_count)
+		dmi->flags |= DM_SKIP_BDGET_FLAG;
+
+	log_debug("dm %s %s %s%s%s %c %.0llu %s [%u]",
+		  _cmd_data_v4[dmt->type].name,
+		  dmi->name, dmi->uuid, dmt->newname ? " " : "",
+		  dmt->newname ? dmt->newname : "",
+		  dmt->no_open_count ? 'N' : 'O',
+		  dmt->sector, dmt->message ? dmt->message : "",
+		  dmi->data_size);
+#ifdef DM_IOCTLS
+	if (ioctl(_control_fd, command, dmi) < 0) {
+		if (errno == ENXIO && ((dmt->type == DM_DEVICE_INFO) ||
+				       (dmt->type == DM_DEVICE_MKNODES)))
+			dmi->flags &= ~DM_EXISTS_FLAG;	/* FIXME */
+		else {
+			if (_log_suppress)
+				log_verbose("device-mapper ioctl "
+					    "cmd %d failed: %s",
+					    _IOC_NR(command), strerror(errno));
+			else
+				log_error("device-mapper ioctl "
+					  "cmd %d failed: %s",
+					  _IOC_NR(command), strerror(errno));
+			dbg_free(dmi);
+			return NULL;
+		}
+	}
+#else /* Userspace alternative for testing */
+#endif
+	return dmi;
+}
+
 int dm_task_run(struct dm_task *dmt)
 {
-	struct dm_ioctl *dmi = NULL;
-	unsigned int command;
+	struct dm_ioctl *dmi;
+	unsigned command;
 
 #ifdef DM_COMPAT
 	if (_dm_version == 1)
@@ -1290,7 +1406,7 @@ int dm_task_run(struct dm_task *dmt)
 	    (sizeof(_cmd_data_v4) / sizeof(*_cmd_data_v4))) {
 		log_error("Internal error: unknown device-mapper task %d",
 			  dmt->type);
-		goto bad;
+		return 0;
 	}
 
 	command = _cmd_data_v4[dmt->type].cmd;
@@ -1306,43 +1422,25 @@ int dm_task_run(struct dm_task *dmt)
 	if (!_open_control())
 		return 0;
 
-	dmi = _flatten(dmt);
-	if (!dmi) {
-		log_error("Couldn't create ioctl argument");
+repeat_ioctl:
+	if (!(dmi = _do_dm_ioctl(dmt, command, _ioctl_buffer_double_factor)))
 		return 0;
-	}
 
-	if (dmt->type == DM_DEVICE_TABLE)
-		dmi->flags |= DM_STATUS_TABLE_FLAG;
-
-	dmi->flags |= DM_EXISTS_FLAG;	/* FIXME */
-
-	if (dmt->no_open_count)
-		dmi->flags |= DM_SKIP_BDGET_FLAG;
-
-	log_debug("dm %s %s %s %s%c %.0llu %s", _cmd_data_v4[dmt->type].name,
-		  dmi->name, dmi->uuid, dmt->newname ? dmt->newname : "",
-		  dmt->no_open_count ? 'N' : 'O',
-		  dmt->sector, dmt->message ? dmt->message : "");
-#ifdef DM_IOCTLS
-	if (ioctl(_control_fd, command, dmi) < 0) {
-		if (errno == ENXIO && ((dmt->type == DM_DEVICE_INFO) ||
-				       (dmt->type == DM_DEVICE_MKNODES)))
-			dmi->flags &= ~DM_EXISTS_FLAG;	/* FIXME */
-		else {
-			if (_log_suppress)
-				log_verbose("device-mapper ioctl "
-					    "cmd %d failed: %s",
-					    _IOC_NR(command), strerror(errno));
-			else
-				log_error("device-mapper ioctl "
-					  "cmd %d failed: %s",
-					  _IOC_NR(command), strerror(errno));
-			goto bad;
+	if (dmi->flags & DM_BUFFER_FULL_FLAG) {
+		switch (dmt->type) {
+		case DM_DEVICE_LIST_VERSIONS:
+		case DM_DEVICE_LIST:
+		case DM_DEVICE_DEPS:
+		case DM_DEVICE_STATUS:
+		case DM_DEVICE_TABLE:
+		case DM_DEVICE_WAITEVENT:
+			_ioctl_buffer_double_factor++;
+			dbg_free(dmi);
+			goto repeat_ioctl;
+		default:
+			log_error("Warning: libdevmapper buffer too small for data");
 		}
 	}
-#else /* Userspace alternative for testing */
-#endif
 
 	switch (dmt->type) {
 	case DM_DEVICE_CREATE:
@@ -1383,7 +1481,7 @@ int dm_task_run(struct dm_task *dmt)
 	return 1;
 
       bad:
-	free(dmi);
+	dbg_free(dmi);
 	return 0;
 }
 
@@ -1399,6 +1497,10 @@ void dm_lib_release(void)
 void dm_lib_exit(void)
 {
 	dm_lib_release();
+	if (_dm_bitset)
+		bitset_destroy(_dm_bitset);
+	_dm_bitset = NULL;
+	dump_memory();
 	_version_ok = 1;
 	_version_checked = 0;
 }

libdm/ioctl/libdm-targets.h

@@ -52,6 +52,7 @@ struct dm_task {
 	char *message;
 	uint64_t sector;
 	int no_open_count;
+	int skip_lockfs;
 
 	char *uuid;
 };

libdm/libdevmapper.h

@@ -135,6 +135,7 @@ int dm_task_set_event_nr(struct dm_task *dmt, uint32_t event_nr);
 int dm_task_set_message(struct dm_task *dmt, const char *message);
 int dm_task_set_sector(struct dm_task *dmt, uint64_t sector);
 int dm_task_no_open_count(struct dm_task *dmt);
+int dm_task_skip_lockfs(struct dm_task *dmt);
 
 /*
  * Use these to prepare for a create or reload.
@@ -164,8 +165,71 @@ int dm_task_run(struct dm_task *dmt);
 int dm_set_dev_dir(const char *dir);
 const char *dm_dir(void);
 
-/* Release library resources */
+/*
+ * Determine whether a major number belongs to device-mapper or not.
+ */
+int dm_is_dm_major(uint32_t major);
+
+/*
+ * Release library resources
+ */
 void dm_lib_release(void);
 void dm_lib_exit(void) __attribute((destructor));
 
+/*****************************
+ * Dependency tree functions *
+ *****************************/
+struct deptree;
+struct deptree_node;
+
+/*
+ * Initialise an empty dependency tree.
+ *
+ * The tree consists of a root node together with one node for each mapped 
+ * device which has child nodes for each device referenced in its table.
+ *
+ * Every node in the tree has one or more children and one or more parents.
+ *
+ * The root node is the parent/child of every node that doesn't have other 
+ * parents/children.
+ */
+struct deptree *dm_deptree_create(void);
+void dm_deptree_free(struct deptree *deptree);
+
+/*
+ * Add nodes to the tree for a given device and all the devices it uses.
+ */
+int dm_deptree_add_dev(struct deptree *deptree, uint32_t major, uint32_t minor);
+
+/*
+ * Search for a node in the tree.
+ * Set major and minor to 0 to get the root node.
+ */
+struct deptree_node *dm_deptree_find_node(struct deptree *deptree,
+					  uint32_t major,
+					  uint32_t minor);
+
+/*
+ * Use this to walk through all children of a given node.
+ * Set handle to NULL in first call.
+ * Returns NULL after the last child.
+ * Set inverted to use inverted tree.
+ */
+struct deptree_node *dm_deptree_next_child(void **handle,
+					   struct deptree_node *parent,
+					   uint32_t inverted);
+
+/*
+ * Get properties of a node.
+ */
+const char *dm_deptree_node_get_name(struct deptree_node *node);
+const char *dm_deptree_node_get_uuid(struct deptree_node *node);
+const struct dm_info *dm_deptree_node_get_info(struct deptree_node *node);
+
+/*
+ * Returns the number of children of the given node (excluding the root node).
+ * Set inverted for the number of parents.
+ */
+int dm_deptree_node_num_children(struct deptree_node *node, uint32_t inverted);
+
 #endif				/* LIB_DEVICE_MAPPER_H */

libdm/libdm-common.c

@@ -93,7 +93,7 @@ int dm_get_library_version(char *version, size_t size)
 
 struct dm_task *dm_task_create(int type)
 {
-	struct dm_task *dmt = malloc(sizeof(*dmt));
+	struct dm_task *dmt = dbg_malloc(sizeof(*dmt));
 
 	if (!dmt) {
 		log_error("dm_task_create: malloc(%d) failed", sizeof(*dmt));
@@ -111,6 +111,7 @@ struct dm_task *dm_task_create(int type)
 	dmt->uid = DEVICE_UID;
 	dmt->gid = DEVICE_GID;
 	dmt->mode = DEVICE_MODE;
+	dmt->no_open_count = 0;
 
 	return dmt;
 }
@@ -122,7 +123,7 @@ int dm_task_set_name(struct dm_task *dmt, const char *name)
 	struct stat st1, st2;
 
 	if (dmt->dev_name) {
-		free(dmt->dev_name);
+		dbg_free(dmt->dev_name);
 		dmt->dev_name = NULL;
 	}
 
@@ -142,7 +143,7 @@ int dm_task_set_name(struct dm_task *dmt, const char *name)
 		name = pos + 1;
 	}
 
-	if (!(dmt->dev_name = strdup(name))) {
+	if (!(dmt->dev_name = dbg_strdup(name))) {
 		log_error("dm_task_set_name: strdup(%s) failed", name);
 		return 0;
 	}
@@ -153,11 +154,11 @@ int dm_task_set_name(struct dm_task *dmt, const char *name)
 int dm_task_set_uuid(struct dm_task *dmt, const char *uuid)
 {
 	if (dmt->uuid) {
-		free(dmt->uuid);
+		dbg_free(dmt->uuid);
 		dmt->uuid = NULL;
 	}
 
-	if (!(dmt->uuid = strdup(uuid))) {
+	if (!(dmt->uuid = dbg_strdup(uuid))) {
 		log_error("dm_task_set_uuid: strdup(%s) failed", uuid);
 		return 0;
 	}
@@ -200,26 +201,28 @@ int dm_task_add_target(struct dm_task *dmt, uint64_t start, uint64_t size,
 }
 
 #ifdef HAVE_SELINUX
-int set_selinux_context(const char *path)
+int set_selinux_context(const char *path, mode_t mode)
 {
 	security_context_t scontext;
 
-	log_debug("Setting SELinux context for %s", path);
 	if (is_selinux_enabled() <= 0)
 		return 1;
 
-	if (matchpathcon(path, 0, &scontext) < 0) {
-		log_error("%s: matchpathcon failed: %s", path, strerror(errno));
+	if (matchpathcon(path, mode, &scontext) < 0) {
+		log_error("%s: matchpathcon %07o failed: %s", path, mode,
+			  strerror(errno));
 		return 0;
 	}
 
+	log_debug("Setting SELinux context for %s to %s.", path, scontext);
+
 	if ((lsetfilecon(path, scontext) < 0) && (errno != ENOTSUP)) {
 		log_error("%s: lsetfilecon failed: %s", path, strerror(errno));
-		free(scontext);
+		freecon(scontext);
 		return 0;
 	}
 
-	free(scontext);
+	freecon(scontext);
 	return 1;
 }
 #endif
@@ -265,7 +268,7 @@ static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor,
 	}
 
 #ifdef HAVE_SELINUX
-	if (!set_selinux_context(path))
+	if (!set_selinux_context(path, S_IFBLK))
 		return 0;
 #endif
 
@@ -378,7 +381,7 @@ static int _stack_node_op(node_op_t type, const char *dev_name, uint32_t major,
 	size_t len = strlen(dev_name) + strlen(old_name) + 2;
 	char *pos;
 
-	if (!(nop = malloc(sizeof(*nop) + len))) {
+	if (!(nop = dbg_malloc(sizeof(*nop) + len))) {
 		log_error("Insufficient memory to stack mknod operation");
 		return 0;
 	}
@@ -409,7 +412,7 @@ static void _pop_node_ops(void)
 		_do_node_op(nop->type, nop->dev_name, nop->major, nop->minor,
 			    nop->uid, nop->gid, nop->mode, nop->old_name);
 		list_del(&nop->list);
-		free(nop);
+		dbg_free(nop);
 	}
 }
 

libdm/libdm-common.h.in

@@ -28,7 +28,7 @@ int rm_dev_node(const char *dev_name);
 int rename_dev_node(const char *old_name, const char *new_name);
 void update_devs(void);
 
-int set_selinux_context(const char *path);
+int set_selinux_context(const char *path, mode_t mode);
 
 #define DM_LIB_VERSION @DM_LIB_VERSION@
 

libdm/libdm-deptree.c

@@ -0,0 +1,403 @@
+/*
+ * Copyright (C) 2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU Lesser General Public License v.2.1.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "libdm-targets.h"
+#include "libdm-common.h"
+#include "list.h"
+#include "kdev_t.h"
+#include "pool.h"
+#include "hash.h"
+
+#include <stdarg.h>
+#include <sys/param.h>
+
+#include <linux/dm-ioctl.h>
+
+struct deptree_node {
+	struct deptree *deptree;
+
+        const char *name;
+        const char *uuid;
+        struct dm_info info;
+
+        struct list uses;       	/* Nodes this node uses */
+        struct list used_by;    	/* Nodes that use this node */
+};
+
+struct deptree {
+	struct pool *mem;
+	struct hash_table *devs;
+	struct deptree_node root;
+};
+
+struct deptree_link {
+	struct list list;
+	struct deptree_node *node;
+};
+
+struct deptree *dm_deptree_create(void)
+{
+	struct deptree *deptree;
+
+	if (!(deptree = dbg_malloc(sizeof(*deptree)))) {
+		log_error("dm_deptree_create malloc failed");
+		return NULL;
+	}
+
+	memset(deptree, 0, sizeof(*deptree));
+	deptree->root.deptree = deptree;
+	list_init(&deptree->root.uses);
+	list_init(&deptree->root.used_by);
+
+	if (!(deptree->mem = pool_create("deptree", 1024))) {
+		log_error("deptree pool creation failed");
+		dbg_free(deptree);
+		return NULL;
+	}
+
+	if (!(deptree->devs = hash_create(8))) {
+		log_error("deptree hash creation failed");
+		pool_destroy(deptree->mem);
+		dbg_free(deptree);
+		return NULL;
+	}
+
+	return deptree;
+}
+
+void dm_deptree_free(struct deptree *deptree)
+{
+	if (!deptree)
+		return;
+
+	hash_destroy(deptree->devs);
+	pool_destroy(deptree->mem);
+	dbg_free(deptree);
+}
+
+static int _nodes_are_linked(struct deptree_node *parent,
+			     struct deptree_node *child)
+{
+	struct deptree_link *dlink;
+
+	list_iterate_items(dlink, &parent->uses) {
+		if (dlink->node == child)
+			return 1;
+	}
+
+	return 0;
+}
+
+static int _link(struct list *list, struct deptree_node *node)
+{
+	struct deptree_link *dlink;
+
+	if (!(dlink = pool_alloc(node->deptree->mem, sizeof(*dlink)))) {
+		log_error("deptree link allocation failed");
+		return 0;
+	}
+
+	dlink->node = node;
+	list_add(list, &dlink->list);
+
+	return 1;
+}
+
+static int _link_nodes(struct deptree_node *parent,
+		       struct deptree_node *child)
+{
+	if (_nodes_are_linked(parent, child))
+		return 1;
+
+	if (!_link(&parent->uses, child))
+		return 0;
+
+	if (!_link(&child->used_by, parent))
+		return 0;
+
+	return 1;
+}
+
+static void _unlink(struct list *list, struct deptree_node *node)
+{
+	struct deptree_link *dlink;
+
+	list_iterate_items(dlink, list) {
+		if (dlink->node == node) {
+			list_del(&dlink->list);
+			break;
+		}
+	}
+}
+
+static void _unlink_nodes(struct deptree_node *parent,
+			  struct deptree_node *child)
+{
+	if (!_nodes_are_linked(parent, child))
+		return;
+
+	_unlink(&parent->uses, child);
+	_unlink(&child->used_by, parent);
+}
+
+static void _remove_from_toplevel(struct deptree_node *node)
+{
+	return _unlink_nodes(&node->deptree->root, node);
+}
+
+static int _add_to_bottomlevel(struct deptree_node *node)
+{
+	return _link_nodes(node, &node->deptree->root);
+}
+
+static struct deptree_node *_create_deptree_node(struct deptree *deptree,
+						 struct deptree_node *parent,
+						 const char *name,
+						 const char *uuid,
+						 struct dm_info *info)
+{
+	struct deptree_node *node;
+	uint64_t dev;
+
+	if (!(node = pool_zalloc(deptree->mem, sizeof(*node)))) {
+		log_error("_create_deptree_node alloc failed");
+		return NULL;
+	}
+
+	node->deptree = deptree;
+
+	node->name = name;
+	node->uuid = uuid;
+	node->info = *info;
+
+	list_init(&node->uses);
+	list_init(&node->used_by);
+
+	dev = MKDEV(info->major, info->minor);
+
+	if (!hash_insert_binary(deptree->devs, (const char *) &dev,
+				sizeof(dev), node)) {
+		log_error("deptree node hash insertion failed");
+		pool_free(deptree->mem, node);
+		return NULL;
+	}
+
+	return node;
+}
+
+static struct deptree_node *_find_deptree_node(struct deptree *deptree,
+					       uint32_t major, uint32_t minor)
+{
+	uint64_t dev = MKDEV(major, minor);
+
+	return hash_lookup_binary(deptree->devs, (const char *) &dev,
+				  sizeof(dev));
+}
+
+static int _deps(struct dm_task **dmt, struct pool *mem, uint32_t major, uint32_t minor,
+		 const char **name, const char **uuid,
+		 struct dm_info *info, struct dm_deps **deps)
+{
+	memset(info, 0, sizeof(*info));
+
+	if (!dm_is_dm_major(major)) {
+		*name = "";
+		*uuid = "";
+		*deps = NULL;
+		info->major = major;
+		info->minor = minor;
+		info->exists = 0;
+		return 1;
+	}
+
+	if (!(*dmt = dm_task_create(DM_DEVICE_DEPS))) {
+		log_error("deps dm_task creation failed");
+		return 0;
+	}
+
+	if (!dm_task_set_major(*dmt, major))
+		goto failed;
+
+	if (!dm_task_set_minor(*dmt, minor))
+		goto failed;
+
+	if (!dm_task_run(*dmt))
+		goto failed;
+
+	if (!dm_task_get_info(*dmt, info))
+		goto failed;
+
+	if (!info->exists) {
+		*name = "";
+		*uuid = "";
+		*deps = NULL;
+	} else {
+		if (info->major != major) {
+			log_error("Inconsistent deptree major number: %u != %u",
+				  major, info->major);
+			goto failed;
+		}
+		if (info->minor != minor) {
+			log_error("Inconsistent deptree minor number: %u != %u",
+				  minor, info->minor);
+			goto failed;
+		}
+		if (!(*name = pool_strdup(mem, dm_task_get_name(*dmt)))) {
+			log_error("name pool_strdup failed");
+			goto failed;
+		}
+		if (!(*uuid = pool_strdup(mem, dm_task_get_uuid(*dmt)))) {
+			log_error("uuid pool_strdup failed");
+			goto failed;
+		}
+		*deps = dm_task_get_deps(*dmt);
+	}
+
+	return 1;
+
+failed:
+	dm_task_destroy(*dmt);
+	return 0;
+}
+
+static int _add_dev(struct deptree *deptree, struct deptree_node *parent,
+		    uint32_t major, uint32_t minor)
+{
+	struct dm_task *dmt = NULL;
+	struct dm_info info;
+	struct dm_deps *deps = NULL;
+	const char *name = NULL;
+	const char *uuid = NULL;
+	struct deptree_node *node;
+	uint32_t i;
+	int r = 0;
+	int new = 0;
+
+	/* Already in tree? */
+	if (!(node = _find_deptree_node(deptree, major, minor))) {
+		if (!_deps(&dmt, deptree->mem, major, minor, &name, &uuid, &info, &deps))
+			return 0;
+
+		if (!(node = _create_deptree_node(deptree, node, name, uuid,
+						  &info)))
+			goto out;
+		new = 1;
+	}
+
+	/* If new parent not root node, remove any existing root node parent */
+	if (parent != &deptree->root)
+		_remove_from_toplevel(node);
+
+	/* Create link to parent.  Use root node only if no other parents. */
+	if ((parent != &deptree->root) || !dm_deptree_node_num_children(node, 1))
+		if (!_link_nodes(parent, node))
+			goto out;
+
+	/* If node was already in tree, no need to recurse. */
+	if (!new)
+		return 1;
+
+	/* Can't recurse if not a mapped device or there are no dependencies */
+	if (!node->info.exists || !deps->count) {
+		if (!_add_to_bottomlevel(node))
+			goto out;
+		return 1;
+	}
+
+	/* Add dependencies to tree */
+	for (i = 0; i < deps->count; i++)
+		if (!_add_dev(deptree, node, MAJOR(deps->device[i]),
+			      MINOR(deps->device[i])))
+			goto out;
+
+	r = 1;
+out:
+	if (dmt)
+		dm_task_destroy(dmt);
+
+	return r;
+}
+
+int dm_deptree_add_dev(struct deptree *deptree, uint32_t major, uint32_t minor)
+{
+	return _add_dev(deptree, &deptree->root, major, minor);
+}
+
+const char *dm_deptree_node_get_name(struct deptree_node *node)
+{
+	return node->info.exists ? node->name : "";
+}
+
+const char *dm_deptree_node_get_uuid(struct deptree_node *node)
+{
+	return node->info.exists ? node->uuid : "";
+}
+
+const struct dm_info *dm_deptree_node_get_info(struct deptree_node *node)
+{
+	return &node->info;
+}
+
+int dm_deptree_node_num_children(struct deptree_node *node, uint32_t inverted)
+{
+	if (inverted) {
+		if (_nodes_are_linked(&node->deptree->root, node))
+			return 0;
+		return list_size(&node->used_by);
+	}
+
+	if (_nodes_are_linked(node, &node->deptree->root))
+		return 0;
+
+	return list_size(&node->uses);
+}
+
+/*
+ * Set major and minor to zero for root of tree.
+ */
+struct deptree_node *dm_deptree_find_node(struct deptree *deptree,
+					  uint32_t major,
+					  uint32_t minor)
+{
+	if (!major && !minor)
+		return &deptree->root;
+
+	return _find_deptree_node(deptree, major, minor);
+}
+
+/*
+ * First time set *handle to NULL.
+ * Set inverted to invert the tree.
+ */
+struct deptree_node *dm_deptree_next_child(void **handle,
+					   struct deptree_node *parent,
+					   uint32_t inverted)
+{
+	struct list **dlink = (struct list **) handle;
+	struct list *use_list;
+
+	if (inverted)
+		use_list = &parent->used_by;
+	else
+		use_list = &parent->uses;
+
+	if (!*dlink)
+		*dlink = list_first(use_list);
+	else
+		*dlink = list_next(use_list, *dlink);
+
+	return (*dlink) ? list_item(*dlink, struct deptree_link)->node : NULL;
+}
+

libdm/libdm-event.h

@@ -25,6 +25,7 @@
 #define	FIFO_SERVER	"/var/run/dmeventd-server"
 #define PIDFILE		"/var/run/dmeventd.pid"
 
+#define DEFAULT_TIMEOUT 10
 /* Commands for the daemon passed in the message below. */
 enum dmeventd_command {
 	CMD_ACTIVE = 1,
@@ -32,6 +33,8 @@ enum dmeventd_command {
 	CMD_UNREGISTER_FOR_EVENT,
 	CMD_GET_REGISTERED_DEVICE,
 	CMD_GET_NEXT_REGISTERED_DEVICE,
+	CMD_SET_TIMEOUT,
+	CMD_GET_TIMEOUT,
 };
 
 /* Message passed between client and daemon. */
@@ -60,6 +63,7 @@ enum event_type {
 	PATH_ERROR	= 0x10, /* Failure on an io path. */
 	ADAPTOR_ERROR	= 0x20, /* Failure off a host adaptor. */
 	SYNC_STATUS	= 0x40, /* Mirror synchronization completed/failed. */
+	TIMEOUT		= 0x80, /* Timeout has occured */
 };
 #define	ALL_ERRORS (SECTOR_ERROR | DEVICE_ERROR | PATH_ERROR | ADAPTOR_ERROR)
 
@@ -69,6 +73,8 @@ int dm_unregister_for_event(char *dso_name, char *device,
 			    enum event_type events);
 int dm_get_registered_device(char **dso_name, char **device,
 			     enum event_type *events, int next);
+int dm_set_event_timeout(char *device, uint32_t timeout);
+int dm_get_event_timeout(char *device, uint32_t *timeout);
 
 /* Prototypes for DSO interface. */
 void process_event(char *device, enum event_type event);

libdm/mm/dbg_malloc.c

@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "dbg_malloc.h"
+
+#include <assert.h>
+#include <stdarg.h>
+
+char *dbg_strdup(const char *str)
+{
+	char *ret = dbg_malloc(strlen(str) + 1);
+
+	if (ret)
+		strcpy(ret, str);
+
+	return ret;
+}
+
+#ifdef DEBUG_MEM
+
+struct memblock {
+	struct memblock *prev, *next;	/* All allocated blocks are linked */
+	size_t length;		/* Size of the requested block */
+	int id;			/* Index of the block */
+	const char *file;	/* File that allocated */
+	int line;		/* Line that allocated */
+	void *magic;		/* Address of this block */
+};
+
+static struct {
+	unsigned block_serialno;/* Non-decreasing serialno of block */
+	unsigned blocks_allocated; /* Current number of blocks allocated */
+	unsigned blocks_max;	/* Max no of concurrently-allocated blocks */
+	unsigned int bytes, mbytes;
+
+} _mem_stats = {
+0, 0, 0, 0, 0};
+
+static struct memblock *_head = 0;
+static struct memblock *_tail = 0;
+
+void *malloc_aux(size_t s, const char *file, int line)
+{
+	struct memblock *nb;
+	size_t tsize = s + sizeof(*nb) + sizeof(unsigned long);
+
+	if (s > 50000000) {
+		log_error("Huge memory allocation (size %" PRIsize_t
+			  ") rejected - metadata corruption?", s);
+		return 0;
+	}
+
+	if (!(nb = malloc(tsize))) {
+		log_error("couldn't allocate any memory, size = %" PRIsize_t,
+			  s);
+		return 0;
+	}
+
+	/* set up the file and line info */
+	nb->file = file;
+	nb->line = line;
+
+#ifdef BOUNDS_CHECK
+	bounds_check();
+#endif
+
+	/* setup fields */
+	nb->magic = nb + 1;
+	nb->length = s;
+	nb->id = ++_mem_stats.block_serialno;
+	nb->next = 0;
+	nb->prev = _tail;
+
+	/* link to tail of the list */
+	if (!_head)
+		_head = _tail = nb;
+	else {
+		_tail->next = nb;
+		_tail = nb;
+	}
+
+	/* stomp a pretty pattern across the new memory
+	   and fill in the boundary bytes */
+	{
+		char *ptr = (char *) (nb + 1);
+		size_t i;
+		for (i = 0; i < s; i++)
+			*ptr++ = i & 0x1 ? (char) 0xba : (char) 0xbe;
+
+		for (i = 0; i < sizeof(unsigned long); i++)
+			*ptr++ = (char) nb->id;
+	}
+
+	_mem_stats.blocks_allocated++;
+	if (_mem_stats.blocks_allocated > _mem_stats.blocks_max)
+		_mem_stats.blocks_max = _mem_stats.blocks_allocated;
+
+	_mem_stats.bytes += s;
+	if (_mem_stats.bytes > _mem_stats.mbytes)
+		_mem_stats.mbytes = _mem_stats.bytes;
+
+	/* log_debug("Allocated: %u %u %u", nb->id, _mem_stats.blocks_allocated,
+		  _mem_stats.bytes); */
+
+	return nb + 1;
+}
+
+void free_aux(void *p)
+{
+	char *ptr;
+	size_t i;
+	struct memblock *mb = ((struct memblock *) p) - 1;
+	if (!p)
+		return;
+
+#ifdef BOUNDS_CHECK
+	bounds_check();
+#endif
+
+	/* sanity check */
+	assert(mb->magic == p);
+
+	/* check data at the far boundary */
+	ptr = ((char *) mb) + sizeof(struct memblock) + mb->length;
+	for (i = 0; i < sizeof(unsigned long); i++)
+		if (*ptr++ != (char) mb->id)
+			assert(!"Damage at far end of block");
+
+	/* have we freed this before ? */
+	assert(mb->id != 0);
+	mb->id = 0;
+
+	/* stomp a different pattern across the memory */
+	ptr = ((char *) mb) + sizeof(struct memblock);
+	for (i = 0; i < mb->length; i++)
+		*ptr++ = i & 1 ? (char) 0xde : (char) 0xad;
+
+	/* unlink */
+	if (mb->prev)
+		mb->prev->next = mb->next;
+	else
+		_head = mb->next;
+
+	if (mb->next)
+		mb->next->prev = mb->prev;
+	else
+		_tail = mb->prev;
+
+	assert(_mem_stats.blocks_allocated);
+	_mem_stats.blocks_allocated--;
+	_mem_stats.bytes -= mb->length;
+
+	/* free the memory */
+	free(mb);
+}
+
+void *realloc_aux(void *p, unsigned int s, const char *file, int line)
+{
+	void *r;
+	struct memblock *mb = ((struct memblock *) p) - 1;
+
+	r = malloc_aux(s, file, line);
+
+	if (p) {
+		memcpy(r, p, mb->length);
+		free_aux(p);
+	}
+
+	return r;
+}
+
+int dump_memory(void)
+{
+	unsigned long tot = 0;
+	struct memblock *mb;
+	char str[32];
+	size_t c;
+
+	if (_head)
+		log_very_verbose("You have a memory leak:");
+
+	for (mb = _head; mb; mb = mb->next) {
+		for (c = 0; c < sizeof(str) - 1; c++) {
+			if (c >= mb->length)
+				str[c] = ' ';
+			else if (*(char *)(mb->magic + c) == '\0')
+				str[c] = '\0';
+			else if (*(char *)(mb->magic + c) < ' ')
+				str[c] = '?';
+			else
+				str[c] = *(char *)(mb->magic + c);
+		}
+		str[sizeof(str) - 1] = '\0';
+
+		_log(_LOG_INFO, mb->file, mb->line,
+		     "block %d at %p, size %" PRIsize_t "\t [%s]",
+		     mb->id, mb->magic, mb->length, str);
+		tot += mb->length;
+	}
+
+	if (_head)
+		log_very_verbose("%ld bytes leaked in total", tot);
+
+	return 1;
+}
+
+void bounds_check(void)
+{
+	struct memblock *mb = _head;
+	while (mb) {
+		size_t i;
+		char *ptr = ((char *) (mb + 1)) + mb->length;
+		for (i = 0; i < sizeof(unsigned long); i++)
+			if (*ptr++ != (char) mb->id)
+				assert(!"Memory smash");
+
+		mb = mb->next;
+	}
+}
+
+#else
+
+void *malloc_aux(size_t s, const char *file, int line)
+{
+	if (s > 50000000) {
+		log_error("Huge memory allocation (size %" PRIsize_t
+			  ") rejected - metadata corruption?", s);
+		return 0;
+	}
+
+	return malloc(s);
+}
+
+#endif

libdm/mm/dbg_malloc.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_DBG_MALLOC_H
+#define _LVM_DBG_MALLOC_H
+
+#include <stdlib.h>
+#include <string.h>
+
+void *malloc_aux(size_t s, const char *file, int line);
+#define dbg_malloc(s) malloc_aux((s), __FILE__, __LINE__)
+
+char *dbg_strdup(const char *str);
+
+#ifdef DEBUG_MEM
+
+void free_aux(void *p);
+void *realloc_aux(void *p, unsigned int s, const char *file, int line);
+int dump_memory(void);
+void bounds_check(void);
+
+#  define dbg_free(p) free_aux(p)
+#  define dbg_realloc(p, s) realloc_aux(p, s, __FILE__, __LINE__)
+
+#else
+
+#  define dbg_free(p) free(p)
+#  define dbg_realloc(p, s) realloc(p, s)
+#  define dump_memory()
+#  define bounds_check()
+
+#endif
+
+#endif

libdm/mm/pool-debug.c

@@ -0,0 +1,263 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "pool.h"
+
+struct block {
+	struct block *next;
+	size_t size;
+	void *data;
+};
+
+typedef struct {
+	unsigned block_serialno;	/* Non-decreasing serialno of block */
+	unsigned blocks_allocated;	/* Current number of blocks allocated */
+	unsigned blocks_max;	/* Max no of concurrently-allocated blocks */
+	unsigned int bytes, maxbytes;
+} pool_stats;
+
+struct pool {
+	const char *name;
+
+	int begun;
+	struct block *object;
+
+	struct block *blocks;
+	struct block *tail;
+
+	pool_stats stats;
+};
+
+/* by default things come out aligned for doubles */
+#define DEFAULT_ALIGNMENT __alignof__ (double)
+
+struct pool *pool_create(const char *name, size_t chunk_hint)
+{
+	struct pool *mem = dbg_malloc(sizeof(*mem));
+
+	if (!mem) {
+		log_error("Couldn't create memory pool %s (size %"
+			  PRIsize_t ")", name, sizeof(*mem));
+		return NULL;
+	}
+
+	mem->name = name;
+	mem->begun = 0;
+	mem->object = 0;
+	mem->blocks = mem->tail = NULL;
+
+	mem->stats.block_serialno = 0;
+	mem->stats.blocks_allocated = 0;
+	mem->stats.blocks_max = 0;
+	mem->stats.bytes = 0;
+	mem->stats.maxbytes = 0;
+
+#ifdef DEBUG_POOL
+	log_debug("Created mempool %s", name);
+#endif
+
+	return mem;
+}
+
+static void _free_blocks(struct pool *p, struct block *b)
+{
+	struct block *n;
+
+	while (b) {
+		p->stats.bytes -= b->size;
+		p->stats.blocks_allocated--;
+
+		n = b->next;
+		dbg_free(b->data);
+		dbg_free(b);
+		b = n;
+	}
+}
+
+static void _pool_stats(struct pool *p, const char *action)
+{
+#ifdef DEBUG_POOL
+	log_debug("%s mempool %s: %u/%u bytes, %u/%u blocks, "
+		  "%u allocations)", action, p->name, p->stats.bytes,
+		  p->stats.maxbytes, p->stats.blocks_allocated,
+		  p->stats.blocks_max, p->stats.block_serialno);
+#else
+	;
+#endif
+}
+
+void pool_destroy(struct pool *p)
+{
+	_pool_stats(p, "Destroying");
+	_free_blocks(p, p->blocks);
+	dbg_free(p);
+}
+
+void *pool_alloc(struct pool *p, size_t s)
+{
+	return pool_alloc_aligned(p, s, DEFAULT_ALIGNMENT);
+}
+
+static void _append_block(struct pool *p, struct block *b)
+{
+	if (p->tail) {
+		p->tail->next = b;
+		p->tail = b;
+	} else
+		p->blocks = p->tail = b;
+
+	p->stats.block_serialno++;
+	p->stats.blocks_allocated++;
+	if (p->stats.blocks_allocated > p->stats.blocks_max)
+		p->stats.blocks_max = p->stats.blocks_allocated;
+
+	p->stats.bytes += b->size;
+	if (p->stats.bytes > p->stats.maxbytes)
+		p->stats.maxbytes = p->stats.bytes;
+}
+
+static struct block *_new_block(size_t s, unsigned alignment)
+{
+	static const char *_oom = "Out of memory";
+
+	/* FIXME: I'm currently ignoring the alignment arg. */
+	size_t len = sizeof(struct block) + s;
+	struct block *b = dbg_malloc(len);
+
+	/*
+	 * Too lazy to implement alignment for debug version, and
+	 * I don't think LVM will use anything but default
+	 * align.
+	 */
+	assert(alignment == DEFAULT_ALIGNMENT);
+
+	if (!b) {
+		log_err(_oom);
+		return NULL;
+	}
+
+	if (!(b->data = dbg_malloc(s))) {
+		log_err(_oom);
+		dbg_free(b);
+		return NULL;
+	}
+
+	b->next = NULL;
+	b->size = s;
+
+	return b;
+}
+
+void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment)
+{
+	struct block *b = _new_block(s, alignment);
+
+	if (!b)
+		return NULL;
+
+	_append_block(p, b);
+
+	return b->data;
+}
+
+void pool_empty(struct pool *p)
+{
+	_pool_stats(p, "Emptying");
+	_free_blocks(p, p->blocks);
+	p->blocks = p->tail = NULL;
+}
+
+void pool_free(struct pool *p, void *ptr)
+{
+	struct block *b, *prev = NULL;
+
+	_pool_stats(p, "Freeing (before)");
+
+	for (b = p->blocks; b; b = b->next) {
+		if (b->data == ptr)
+			break;
+		prev = b;
+	}
+
+	/*
+	 * If this fires then you tried to free a
+	 * pointer that either wasn't from this
+	 * pool, or isn't the start of a block.
+	 */
+	assert(b);
+
+	_free_blocks(p, b);
+
+	if (prev) {
+		p->tail = prev;
+		prev->next = NULL;
+	} else
+		p->blocks = p->tail = NULL;
+
+	_pool_stats(p, "Freeing (after)");
+}
+
+int pool_begin_object(struct pool *p, size_t init_size)
+{
+	assert(!p->begun);
+	p->begun = 1;
+	return 1;
+}
+
+int pool_grow_object(struct pool *p, const void *buffer, size_t delta)
+{
+	struct block *new;
+	size_t size = delta;
+
+	assert(p->begun);
+
+	if (p->object)
+		size += p->object->size;
+
+	if (!(new = _new_block(size, DEFAULT_ALIGNMENT))) {
+		log_err("Couldn't extend object.");
+		return 0;
+	}
+
+	if (p->object) {
+		memcpy(new->data, p->object->data, p->object->size);
+		dbg_free(p->object->data);
+		dbg_free(p->object);
+	}
+	p->object = new;
+
+	memcpy(new->data + size - delta, buffer, delta);
+
+	return 1;
+}
+
+void *pool_end_object(struct pool *p)
+{
+	assert(p->begun);
+	_append_block(p, p->object);
+
+	p->begun = 0;
+	p->object = NULL;
+	return p->tail->data;
+}
+
+void pool_abandon_object(struct pool *p)
+{
+	assert(p->begun);
+	dbg_free(p->object);
+	p->begun = 0;
+	p->object = NULL;
+}

libdm/mm/pool-fast.c

@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.   
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lib.h"
+#include "pool.h"
+
+struct chunk {
+	char *begin, *end;
+	struct chunk *prev;
+};
+
+struct pool {
+	struct chunk *chunk, *spare_chunk;	/* spare_chunk is a one entry free
+						   list to stop 'bobbling' */
+	size_t chunk_size;
+	size_t object_len;
+	unsigned object_alignment;
+};
+
+void _align_chunk(struct chunk *c, unsigned alignment);
+struct chunk *_new_chunk(struct pool *p, size_t s);
+
+/* by default things come out aligned for doubles */
+#define DEFAULT_ALIGNMENT __alignof__ (double)
+
+struct pool *pool_create(const char *name, size_t chunk_hint)
+{
+	size_t new_size = 1024;
+	struct pool *p = dbg_malloc(sizeof(*p));
+
+	if (!p) {
+		log_error("Couldn't create memory pool %s (size %"
+			  PRIsize_t ")", name, sizeof(*p));
+		return 0;
+	}
+	memset(p, 0, sizeof(*p));
+
+	/* round chunk_hint up to the next power of 2 */
+	p->chunk_size = chunk_hint + sizeof(struct chunk);
+	while (new_size < p->chunk_size)
+		new_size <<= 1;
+	p->chunk_size = new_size;
+	return p;
+}
+
+void pool_destroy(struct pool *p)
+{
+	struct chunk *c, *pr;
+	dbg_free(p->spare_chunk);
+	c = p->chunk;
+	while (c) {
+		pr = c->prev;
+		dbg_free(c);
+		c = pr;
+	}
+
+	dbg_free(p);
+}
+
+void *pool_alloc(struct pool *p, size_t s)
+{
+	return pool_alloc_aligned(p, s, DEFAULT_ALIGNMENT);
+}
+
+void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment)
+{
+	struct chunk *c = p->chunk;
+	void *r;
+
+	/* realign begin */
+	if (c)
+		_align_chunk(c, alignment);
+
+	/* have we got room ? */
+	if (!c || (c->begin > c->end) || (c->end - c->begin < s)) {
+		/* allocate new chunk */
+		int needed = s + alignment + sizeof(struct chunk);
+		c = _new_chunk(p, (needed > p->chunk_size) ?
+			       needed : p->chunk_size);
+
+		if (!c)
+			return NULL;
+
+		_align_chunk(c, alignment);
+	}
+
+	r = c->begin;
+	c->begin += s;
+	return r;
+}
+
+void pool_empty(struct pool *p)
+{
+	struct chunk *c;
+
+	for (c = p->chunk; c && c->prev; c = c->prev)
+		;
+
+	if (c)
+		pool_free(p, (char *) (c + 1));
+}
+
+void pool_free(struct pool *p, void *ptr)
+{
+	struct chunk *c = p->chunk;
+
+	while (c) {
+		if (((char *) c < (char *) ptr) &&
+		    ((char *) c->end > (char *) ptr)) {
+			c->begin = ptr;
+			break;
+		}
+
+		if (p->spare_chunk)
+			dbg_free(p->spare_chunk);
+		p->spare_chunk = c;
+		c = c->prev;
+	}
+
+	if (!c)
+		log_error("Internal error: pool_free asked to free pointer "
+			  "not in pool");
+	else
+		p->chunk = c;
+}
+
+int pool_begin_object(struct pool *p, size_t hint)
+{
+	struct chunk *c = p->chunk;
+	const size_t align = DEFAULT_ALIGNMENT;
+
+	p->object_len = 0;
+	p->object_alignment = align;
+
+	if (c)
+		_align_chunk(c, align);
+
+	if (!c || (c->begin > c->end) || (c->end - c->begin < hint)) {
+		/* allocate a new chunk */
+		c = _new_chunk(p,
+			       hint > (p->chunk_size - sizeof(struct chunk)) ?
+			       hint + sizeof(struct chunk) + align :
+			       p->chunk_size);
+
+		if (!c)
+			return 0;
+
+		_align_chunk(c, align);
+	}
+
+	return 1;
+}
+
+int pool_grow_object(struct pool *p, const void *extra, size_t n)
+{
+	struct chunk *c = p->chunk, *nc;
+
+	if (c->end - (c->begin + p->object_len) < n) {
+		/* move into a new chunk */
+		if (p->object_len + n > (p->chunk_size / 2))
+			nc = _new_chunk(p, (p->object_len + n) * 2);
+		else
+			nc = _new_chunk(p, p->chunk_size);
+
+		if (!nc)
+			return 0;
+
+		_align_chunk(p->chunk, p->object_alignment);
+		memcpy(p->chunk->begin, c->begin, p->object_len);
+		c = p->chunk;
+	}
+
+	memcpy(c->begin + p->object_len, extra, n);
+	p->object_len += n;
+	return 1;
+}
+
+void *pool_end_object(struct pool *p)
+{
+	struct chunk *c = p->chunk;
+	void *r = c->begin;
+	c->begin += p->object_len;
+	p->object_len = 0u;
+	p->object_alignment = DEFAULT_ALIGNMENT;
+	return r;
+}
+
+void pool_abandon_object(struct pool *p)
+{
+	p->object_len = 0;
+	p->object_alignment = DEFAULT_ALIGNMENT;
+}
+
+void _align_chunk(struct chunk *c, unsigned alignment)
+{
+	c->begin += alignment - ((unsigned long) c->begin & (alignment - 1));
+}
+
+struct chunk *_new_chunk(struct pool *p, size_t s)
+{
+	struct chunk *c;
+
+	if (p->spare_chunk &&
+	    ((p->spare_chunk->end - (char *) p->spare_chunk) >= s)) {
+		/* reuse old chunk */
+		c = p->spare_chunk;
+		p->spare_chunk = 0;
+	} else {
+		if (!(c = dbg_malloc(s))) {
+			log_error("Out of memory.  Requested %" PRIsize_t
+				  " bytes.", s);
+			return NULL;
+		}
+
+		c->end = (char *) c + s;
+	}
+
+	c->prev = p->chunk;
+	c->begin = (char *) (c + 1);
+	p->chunk = c;
+
+	return c;
+}

libdm/mm/pool.c

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifdef DEBUG_POOL
+#include "pool-debug.c"
+#else
+#include "pool-fast.c"
+#endif
+
+char *pool_strdup(struct pool *p, const char *str)
+{
+	char *ret = pool_alloc(p, strlen(str) + 1);
+
+	if (ret)
+		strcpy(ret, str);
+
+	return ret;
+}
+
+char *pool_strndup(struct pool *p, const char *str, size_t n)
+{
+	char *ret = pool_alloc(p, n + 1);
+
+	if (ret) {
+		strncpy(ret, str, n);
+		ret[n] = '\0';
+	}
+
+	return ret;
+}
+
+void *pool_zalloc(struct pool *p, size_t s)
+{
+	void *ptr = pool_alloc(p, s);
+
+	if (ptr)
+		memset(ptr, 0, s);
+
+	return ptr;
+}

libdm/mm/pool.h

@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.  
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of the device-mapper userspace tools.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LVM_POOL_H
+#define _LVM_POOL_H
+
+#include <string.h>
+#include <stdlib.h>
+
+/*
+ * The pool allocator is useful when you are going to allocate
+ * lots of memory, use the memory for a bit, and then free the
+ * memory in one go.  A surprising amount of code has this usage
+ * profile.
+ *
+ * You should think of the pool as an infinite, contiguous chunk
+ * of memory.  The front of this chunk of memory contains
+ * allocated objects, the second half is free.  pool_alloc grabs
+ * the next 'size' bytes from the free half, in effect moving it
+ * into the allocated half.  This operation is very efficient.
+ *
+ * pool_free frees the allocated object *and* all objects
+ * allocated after it.  It is important to note this semantic
+ * difference from malloc/free.  This is also extremely
+ * efficient, since a single pool_free can dispose of a large
+ * complex object.
+ *
+ * pool_destroy frees all allocated memory.
+ *
+ * eg, If you are building a binary tree in your program, and
+ * know that you are only ever going to insert into your tree,
+ * and not delete (eg, maintaining a symbol table for a
+ * compiler).  You can create yourself a pool, allocate the nodes
+ * from it, and when the tree becomes redundant call pool_destroy
+ * (no nasty iterating through the tree to free nodes).
+ *
+ * eg, On the other hand if you wanted to repeatedly insert and
+ * remove objects into the tree, you would be better off
+ * allocating the nodes from a free list; you cannot free a
+ * single arbitrary node with pool.
+ */
+
+struct pool;
+
+/* constructor and destructor */
+struct pool *pool_create(const char *name, size_t chunk_hint);
+void pool_destroy(struct pool *p);
+
+/* simple allocation/free routines */
+void *pool_alloc(struct pool *p, size_t s);
+void *pool_alloc_aligned(struct pool *p, size_t s, unsigned alignment);
+void pool_empty(struct pool *p);
+void pool_free(struct pool *p, void *ptr);
+
+/*
+ * Object building routines:
+ *
+ * These allow you to 'grow' an object, useful for
+ * building strings, or filling in dynamic
+ * arrays.
+ *
+ * It's probably best explained with an example:
+ *
+ * char *build_string(struct pool *mem)
+ * {
+ *      int i;
+ *      char buffer[16];
+ *
+ *      if (!pool_begin_object(mem, 128))
+ *              return NULL;
+ *
+ *      for (i = 0; i < 50; i++) {
+ *              snprintf(buffer, sizeof(buffer), "%d, ", i);
+ *              if (!pool_grow_object(mem, buffer, strlen(buffer)))
+ *                      goto bad;
+ *      }
+ *
+ *	// add null
+ *      if (!pool_grow_object(mem, "\0", 1))
+ *              goto bad;
+ *
+ *      return pool_end_object(mem);
+ *
+ * bad:
+ *
+ *      pool_abandon_object(mem);
+ *      return NULL;
+ *}
+ *
+ * So start an object by calling pool_begin_object
+ * with a guess at the final object size - if in
+ * doubt make the guess too small.
+ *
+ * Then append chunks of data to your object with
+ * pool_grow_object.  Finally get your object with
+ * a call to pool_end_object.
+ *
+ */
+int pool_begin_object(struct pool *p, size_t hint);
+int pool_grow_object(struct pool *p, const void *extra, size_t delta);
+void *pool_end_object(struct pool *p);
+void pool_abandon_object(struct pool *p);
+
+/* utilities */
+char *pool_strdup(struct pool *p, const char *str);
+char *pool_strndup(struct pool *p, const char *str, size_t n);
+void *pool_zalloc(struct pool *p, size_t s);
+
+#endif

man/lvcreate.8

@@ -42,7 +42,7 @@ keep the contents of the original logical volume for backup purposes.
 See \fBlvm\fP for common options.
 .TP
 .I \-c, \-\-chunksize ChunkSize
-Power of 2 chunk size for the snapshot logical volume between 4k and 1024k.
+Power of 2 chunk size for the snapshot logical volume between 4k and 512k.
 .TP
 .I \-C, \-\-contiguous y/n
 Sets or resets the contiguous allocation policy for

man/vgs.8

@@ -37,7 +37,7 @@ vg_tags.
 Any "vg_" prefixes are optional.  Columns mentioned in either \fBpvs (8)\fP 
 or \fBlvs (8)\fP can also be chosen, but columns cannot be taken from both
 at the same time.  The vg_attr bits are: (w)riteable, (r)eadonly, 
-resi(z)eable, e(x)ported, (p)artial.
+resi(z)eable, e(x)ported, (p)artial and (c)lustered.
 .TP
 .I \-O, \-\-sort
 Comma-separated ordered list of columns to sort by.  Replaces the default

scripts/lvmconf.sh

@@ -0,0 +1,243 @@
+#!/bin/sh
+#
+# Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
+#
+# This file is part of the lvm2-cluster package.
+#
+# 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
+
+#
+# Edit an lvm.conf file to adjust various properties
+#
+
+function usage
+{
+    echo "usage: $0 <command>"
+    echo ""
+    echo "Commands:"
+    echo "Enable clvm:  --enable-cluster --lockinglibdir <dir> [--lockinglib <lib>]"
+    echo "Disable clvm: --disable-cluster"
+    echo ""
+    echo "Global options:"
+    echo "Config file location: --file <configfile>"
+    echo ""
+}
+
+
+function parse_args
+{
+    while [ -n "$1" ]; do
+        case $1 in
+            --enable-cluster)
+                LOCKING_TYPE=2
+                shift
+                ;;
+            --disable-cluster)
+                LOCKING_TYPE=1
+                shift
+                ;;
+            --lockinglibdir)
+                if [ -n "$2" ]; then
+                    LOCKINGLIBDIR=$2
+                    shift 2
+                else
+                    usage
+                    exit 1
+                fi
+                ;;
+            --lockinglib)
+                if [ -n "$2" ]; then
+                    LOCKINGLIB=$2
+                    shift 2
+                else
+                    usage
+                    exit 1
+                fi
+                ;;
+            --file)
+                if [ -n "$2" ]; then
+                    CONFIGFILE=$2
+                    shift 2
+                else
+                    usage
+                    exit 1
+                fi
+                ;;
+            *)
+                usage
+                exit 1
+        esac
+    done
+}
+
+function validate_args
+{
+    [ -z "$CONFIGFILE" ] && CONFIGFILE="/etc/lvm/lvm.conf"
+
+    if [ ! -f "$CONFIGFILE" ]
+            then
+            echo "$CONFIGFILE does not exist"
+            exit 10
+    fi
+
+    if [ -z "$LOCKING_TYPE" ]; then
+        usage
+        exit 1
+    fi
+
+    if [ "$LOCKING_TYPE" == "2" ]; then
+
+        [ -z "$LOCKINGLIBDIR" ] && usage && exit 1    
+        [ -z "$LOCKINGLIB" ] && LOCKINGLIB="liblvm2clusterlock.so"
+            
+        if [ "${LOCKINGLIBDIR:0:1}" != "/" ]
+            then
+            echo "Prefix must be an absolute path name (starting with a /)"
+            exit 12
+        fi
+    
+        if [ ! -f "$LOCKINGLIBDIR/$LOCKINGLIB" ]
+            then
+            echo "$LOCKINGLIBDIR/$LOCKINGLIB does not exist, did you do a \"make install\" ?"
+            exit 11
+        fi
+        
+    fi
+}
+
+umask 0077
+
+parse_args "$@"
+
+validate_args
+
+
+SCRIPTFILE=/etc/lvm/.lvmconf-script.tmp
+TMPFILE=/etc/lvm/.lvmconf-tmp.tmp
+
+
+# Flags so we know which parts of the file we can replace and which need
+# adding. These are return codes from grep, so zero means it IS present!
+have_type=1
+have_dir=1
+have_library=1
+have_global=1
+
+grep -q '^[[:blank:]]*locking_type[[:blank:]]*=' $CONFIGFILE
+have_type=$?
+
+grep -q '^[[:blank:]]*library_dir[[:blank:]]*=' $CONFIGFILE
+have_dir=$?
+
+grep -q '^[[:blank:]]*locking_library[[:blank:]]*=' $CONFIGFILE
+have_library=$?
+
+# Those options are in section "global {" so we must have one if any are present.
+if [ "$have_type" = "0" -o "$have_dir" = "0" -o "$have_library" = "0" ]
+then
+
+    # See if we can find it...
+    grep -q '^[[:blank:]]*global[[:blank:]]*{' $CONFIGFILE
+    have_global=$?
+    
+    if [ "$have_global" = "1" ] 
+	then
+	echo "global keys but no 'global {' found, can't edit file"
+	exit 13
+    fi
+fi
+
+# So if we don't have "global {" we need to create one and 
+# populate it
+
+if [ "$have_global" = "1" ]
+then
+    if [ "$LOCKING_TYPE" = "2" ]; then
+        cat $CONFIGFILE - <<EOF > $TMPFILE
+global {
+    # Enable locking for cluster LVM
+    locking_type = $LOCKING_TYPE
+    library_dir = "$LOCKINGLIBDIR"
+    locking_library = "$LOCKINGLIB"
+}
+EOF
+    fi # if we aren't setting cluster locking, we don't need to create a global section
+
+    if [ $? != 0 ]
+    then
+	echo "failed to create temporary config file, $CONFIGFILE not updated"
+	exit 14
+    fi
+else
+    #
+    # We have a "global {" section, so add or replace the
+    # locking entries as appropriate
+    #
+
+    if [ "$have_type" = "0" ] 
+    then
+	SEDCMD=" s/^[[:blank:]]*locking_type[[:blank:]]*=.*/\ \ \ \ locking_type = $LOCKING_TYPE/g"
+    else
+	SEDCMD=" /global[[:blank:]]*{/a\ \ \ \ locking_type = $LOCKING_TYPE"
+    fi
+    
+    if [ "$LOCKING_TYPE" = "2" ]; then
+        if [ "$have_dir" = "0" ] 
+            then
+            SEDCMD="${SEDCMD}\ns'^[[:blank:]]*library_dir[[:blank:]]*=.*'\ \ \ \ library_dir = \"$LOCKINGLIBDIR\"'g"
+        else
+            SEDCMD="${SEDCMD}\n/global[[:blank:]]*{/a\ \ \ \ library_dir = \"$LOCKINGLIBDIR\""
+        fi
+
+        if [ "$have_library" = "0" ] 
+            then
+            SEDCMD="${SEDCMD}\ns/^[[:blank:]]*locking_library[[:blank:]]*=.*/\ \ \ \ locking_library = \"$LOCKINGLIB\"/g"
+        else
+            SEDCMD="${SEDCMD}\n/global[[:blank:]]*{/a\ \ \ \ locking_library = \"$LOCKINGLIB\""
+        fi
+    else
+        # if we're not using cluster locking, remove the library dir and locking library name
+        if [ "$have_dir" = "0" ] 
+            then
+            SEDCMD="${SEDCMD}\n/^[[:blank:]]*library_dir[[:blank:]]*=.*/d"
+        fi
+
+        if [ "$have_library" = "0" ] 
+            then
+            SEDCMD="${SEDCMD}\n/^[[:blank:]]*locking_library[[:blank:]]*=.*/d"
+        fi
+    fi
+
+    echo -e $SEDCMD > $SCRIPTFILE
+    sed  <$CONFIGFILE >$TMPFILE -f $SCRIPTFILE
+    if [ $? != 0 ]
+    then
+	echo "sed failed, $CONFIGFILE not updated"
+	exit 15
+    fi
+fi
+
+# Now we have a suitably editted config file in a temp place,
+# backup the original and copy our new one into place.
+
+cp $CONFIGFILE $CONFIGFILE.lvmconfold
+if [ $? != 0 ]
+    then
+    echo "failed to backup old config file, $CONFIGFILE not updated"
+    exit 2
+fi
+
+cp $TMPFILE $CONFIGFILE
+if [ $? != 0 ]
+    then
+    echo "failed to copy new config file into place, check $CONFIGFILE is still OK"
+    exit 3
+fi
+
+rm -f $SCRIPTFILE $TMPFILE

tools/Makefile.in

@@ -24,6 +24,7 @@ SOURCES =\
 	dumpconfig.c \
 	formats.c \
 	lvchange.c \
+	lvconvert.c \
 	lvcreate.c \
 	lvdisplay.c \
 	lvextend.c \