1.01.01

DEBUGLOG() message now print threadid rather than PID which is more useful.

VERSION

@@ -1 +1 @@
-2.01.02-cvs (2005-01-21)
+2.01.09-cvs (2005-03-22)

WHATS_NEW

@@ -1,3 +1,62 @@
+Version 2.01.09 - 
+=================================
+
+Version 2.01.08 - 22nd March 2005
+=================================
+  Add clustered attribute so vgchange can identify clustered VGs w/o locking.
+  Improve detection of external changes affecting internal cache.
+  Add 'already in device cache' debug message.
+  Add -a to pvdisplay -C.
+  Avoid rmdir opendir error messsages when dir was already removed.
+  Tighten signal handlers.
+  Avoid some compiler warnings.
+  Additional rename failure error message.
+  read/write may be macros.
+  clvmd: don't take out lvm thread lock at startup, it only protects jobs list.
+
+Version 2.01.07 - 8th March 2005
+================================
+  Cope with new devices appearing by rescanning /dev if a uuid can't be found.
+  Remove DESTDIR from LVM_SHARED_PATH.
+  clvmd fixes: make FDs close-on-exec
+               gulm unlocks VG & orphan locks at startup in case they are stale
+               gulm now unlocks VG & orphan locks if client dies.
+
+Version 2.01.06 - 1st March 2005
+================================
+  Suppress 'open failed' error messages during scanning.
+  Option to suppress warnings of file descriptors left open.
+  Fix default value of metadatacopies in documentation (2->1).
+  Fix clvmd-gulm locking.
+  ./configure --enable-debug now enables debugging code in clvmd.
+  Fix clvmd-gulm node up/down code so it actually works.
+  clvmd-gulm now releases locks when shut down.
+
+Version 2.01.05 - 18th February 2005
+====================================
+  Static binary invokes dynamic binary if appropriate.
+  Make clvmd config check a little more tolerant.
+  gulm clvmd can now cope with >1 message arriving in a TCP message.
+
+Version 2.01.04 - 9th February 2005
+===================================
+  Add fixed offset to imported pool minor numbers.
+  Update binary pathnames in clvmd_init_rhel4.
+  lvm2cmd.so should skip the check for open fds.
+  Remove unused -f from pvmove.
+  Gulm clvmd doesn't report "connection refused" errors.
+  clvmd does a basic config file sanity check at startup.
+  Fix potential thread shutdown race in clvmd.
+
+Version 2.01.03 - 1st February 2005
+===================================
+  More 64-bit display/report fixes.
+  More informative startup mesg if can't create /etc/lvm.
+  Fix snapshot device size bug (since 2.01.01).
+  clvmd announces startup and cluster connection in syslog.
+  Gulm clvmd doesn't hang trying to talk to a rebooted node.
+  Gulm clvmd doesn't print cman error on startup.
+
 Version 2.01.02 - 21st January 2005
 ===================================
   Update clvmd_init_rhel4: use lvm.static and don't load dlm.

WHATS_NEW_DM

@@ -1,5 +1,9 @@
-Version 1.01.01 -
+Version 1.01.01 - 29 Mar 2005
 =============================
+  Update dmsetup man page.
+  Drop-in devmap_name replacement.
+  Add option to compile without ioctl for testing.
+  Fix DM_LIB_VERSION sed.
 
 Version 1.01.00 - 17 Jan 2005
 =============================

daemons/clvmd/Makefile.in

@@ -34,6 +34,10 @@ ifeq ("@CLVMD@", "all")
 	CMAN = yes
 endif
 
+ifeq ("@DEBUG@", "yes")
+	CFLAGS += -DDEBUG
+endif
+
 ifeq ("$(GULM)", "yes")
 	SOURCES += clvmd-gulm.c tcp-comms.c
 	LMLIBS += -lccs -lgulm

daemons/clvmd/clvmd-cman.c

@@ -74,9 +74,11 @@ static int _init_cluster(void)
 	/* Open the cluster communication socket */
 	cluster_sock = socket(AF_CLUSTER, SOCK_DGRAM, CLPROTO_CLIENT);
 	if (cluster_sock == -1) {
-		syslog(LOG_ERR, "Can't open cman cluster manager socket: %m");
+		/* Don't print an error here because we could be just probing for CMAN */
 		return -1;
 	}
+	/* Set Close-on-exec */
+	fcntl(cluster_sock, F_SETFD, 1);
 
 	/* Bind to our port number on the cluster.
 	   Writes to this will block if the cluster loses quorum */
@@ -101,6 +103,7 @@ static int _init_cluster(void)
 		return -1;
 	}
 	dlm_ls_pthread_init(lockspace);
+
 	return 0;
 }
 

daemons/clvmd/clvmd-command.c

@@ -274,9 +274,10 @@ void cmd_client_cleanup(struct local_client *client)
 
 	hash_iterate(v, lock_hash) {
 		int lkid = (int)(long)hash_get_data(lock_hash, v);
+		char *lockname = hash_get_key(lock_hash, v);
 
-		DEBUGLOG("cleanup: Unlocking lkid %x\n", lkid);
-		sync_unlock("DUMMY", lkid);
+		DEBUGLOG("cleanup: Unlocking lock %s %x\n", lockname, lkid);
+		sync_unlock(lockname, lkid);
 	}
 
 	hash_destroy(lock_hash);

daemons/clvmd/clvmd-gulm.c

@@ -2,6 +2,7 @@
 *******************************************************************************
 **
 **  Copyright (C) Sistina Software, Inc.  2002-2003  All rights reserved.
+**  Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
 **
 *******************************************************************************
 ******************************************************************************/
@@ -46,6 +47,7 @@
 #include "log.h"
 #include "clvm.h"
 #include "clvmd-comms.h"
+#include "lvm-functions.h"
 #include "clvmd.h"
 #include "hash.h"
 #include "clvmd-gulm.h"
@@ -65,6 +67,7 @@ static uint8_t current_corestate;
 static int num_nodes;
 
 static char *cluster_name;
+static int in_shutdown = 0;
 
 static pthread_mutex_t lock_start_mutex;
 static volatile int lock_start_flag;
@@ -114,6 +117,9 @@ static int add_internal_client(int fd, fd_callback_t callback)
     client->callback = callback;
     add_client(client);
 
+    /* Set Close-on-exec */
+    fcntl(fd, F_SETFD, 1);
+
     return 0;
 }
 
@@ -224,7 +230,7 @@ static int _init_cluster(void)
 	exit(status);
     }
 
-    /* Request a list of nodes, we can;t really do anything until
+    /* Request a list of nodes, we can't really do anything until
        this comes back */
     status = lg_core_nodelist(gulm_if);
     if (status)
@@ -246,6 +252,8 @@ static int _init_cluster(void)
 static void _cluster_closedown(void)
 {
     DEBUGLOG("cluster_closedown\n");
+    in_shutdown = 1;
+    unlock_all();
     lg_lock_logout(gulm_if);
     lg_core_logout(gulm_if);
     lg_release(gulm_if);
@@ -258,6 +266,7 @@ static void drop_expired_locks(char *nodename)
     struct utsname nodeinfo;
     uint8_t mask[GIO_KEY_SIZE];
 
+    DEBUGLOG("Dropping expired locks for %s\n", nodename?nodename:"(null)");
     memset(mask, 0xff, GIO_KEY_SIZE);
 
     if (!nodename)
@@ -358,7 +367,7 @@ static struct node_info *add_or_set_node(char *name, struct in6_addr *ip, uint8_
 	}
     }
 
-    set_node_state(ninfo, (char *)&ip, state);
+    set_node_state(ninfo, (char *)ip, state);
 
     return ninfo;
 }
@@ -465,7 +474,7 @@ static int lock_login_reply(void *misc, uint32_t error, uint8_t which)
 	lock_start_flag = 0;
 	pthread_mutex_unlock(&lock_start_mutex);
     }
-
+    
     return 0;
 }
 
@@ -478,6 +487,10 @@ static int lock_lock_state(void *misc, uint8_t *key, uint16_t keylen,
 
     DEBUGLOG("LOCK lock state: %s, error = %d\n", key, error);
 
+    /* No waiting process to wake up when we are shutting down */
+    if (in_shutdown)
+	    return 0;
+
     lwait = hash_lookup(lock_hash, key);
     if (!lwait)
     {
@@ -596,9 +609,12 @@ void gulm_add_up_node(char *csid)
     struct node_info *ninfo;
 
     ninfo = hash_lookup_binary(node_hash, csid, GULM_MAX_CSID_LEN);
-    if (!ninfo)
+    if (!ninfo) {
+	    DEBUGLOG("gulm_add_up_node no node_hash entry for csid %s\n", print_csid(csid));
 	return;
+    }
 
+    DEBUGLOG("gulm_add_up_node %s\n", ninfo->name);
     ninfo->state = NODE_CLVMD;
     return;
 
@@ -616,13 +632,14 @@ void add_down_node(char *csid)
        running clvmd - gulm may set it DOWN quite soon */
     if (ninfo->state == NODE_CLVMD)
 	ninfo->state = NODE_UP;
+    drop_expired_locks(ninfo->name);
     return;
 
 }
 
 /* Call a callback for each node, so the caller knows whether it's up or down */
 static int _cluster_do_node_callback(struct local_client *master_client,
-			     void (*callback)(struct local_client *, char *csid, int node_up))
+				     void (*callback)(struct local_client *, char *csid, int node_up))
 {
     struct hash_node *hn;
     struct node_info *ninfo;
@@ -638,8 +655,19 @@ static int _cluster_do_node_callback(struct local_client *master_client,
 	DEBUGLOG("down_callback. node %s, state = %d\n", ninfo->name, ninfo->state);
 
 	client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
-	if (client)
-	    callback(master_client, csid, ninfo->state == NODE_CLVMD);
+	if (!client)
+	{
+	    /* If it's up but not connected, try to make contact */
+	    if (ninfo->state == NODE_UP)
+		    gulm_connect_csid(csid, &client);
+
+	    client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
+
+	}
+	if (ninfo->state != NODE_DOWN)
+		callback(master_client, csid, ninfo->state == NODE_CLVMD);
+
+
     }
     return 0;
 }
@@ -650,15 +678,13 @@ static int gulm_to_errno(int gulm_ret)
     switch (gulm_ret)
     {
     case lg_err_TryFailed:
-	errno = EAGAIN;
-	break;
-
     case lg_err_AlreadyPend:
-	errno = EBUSY;
+	    errno = EAGAIN;
+	    break;
 
 	/* More?? */
     default:
-	errno = EINVAL;
+	    errno = EINVAL;
     }
 
     return gulm_ret ? -1 : 0;
@@ -729,6 +755,11 @@ static int _unlock_resource(char *resource, int lockid)
 	return status;
     }
 
+    /* When we are shutting down, don't wait for unlocks
+       to be acknowledged, just do it. */
+    if (in_shutdown)
+	    return status;
+
     /* Wait for it to complete */
 
     pthread_cond_wait(&lwait.cond, &lwait.mutex);
@@ -765,7 +796,7 @@ static int _sync_lock(const char *resource, int mode, int flags, int *lockid)
 	if (status)
 	    goto out;
 
-	/* If we can't get this lock then bail out */
+	/* If we can't get this lock too then bail out */
 	status = _lock_resource(lock2, lg_lock_state_Exclusive, LCK_NONBLOCK, lockid);
         if (status == lg_err_TryFailed)
         {
@@ -777,10 +808,16 @@ static int _sync_lock(const char *resource, int mode, int flags, int *lockid)
 
     case LCK_READ:
 	status = _lock_resource(lock1, lg_lock_state_Shared, flags, lockid);
+	if (status)
+		goto out;
+	status = _unlock_resource(lock2, *lockid);
 	break;
 
     case LCK_WRITE:
 	status = _lock_resource(lock2, lg_lock_state_Exclusive, flags, lockid);
+	if (status)
+		goto out;
+	status = _unlock_resource(lock1, *lockid);
 	break;
 
     default:
@@ -807,25 +844,10 @@ static int _sync_unlock(const char *resource, int lockid)
 	   lockid == LCK_READ ||
 	   lockid == LCK_WRITE);
 
-    switch (lockid)
-    {
-    case LCK_EXCL:
-	status = _unlock_resource(lock1, lockid);
-	if (status)
-	    goto out;
-	status = _unlock_resource(lock2, lockid);
-	break;
+    status = _unlock_resource(lock1, lockid);
+    if (!status)
+	    status = _unlock_resource(lock2, lockid);
 
-    case LCK_READ:
-	status = _unlock_resource(lock1, lockid);
-	break;
-
-    case LCK_WRITE:
-	status = _unlock_resource(lock2, lockid);
-	break;
-    }
-
- out:
     return status;
 }
 

daemons/clvmd/clvmd.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
- * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
  *
  * This file is part of LVM2.
  *
@@ -34,6 +34,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <getopt.h>
+#include <syslog.h>
 #include <errno.h>
 
 #include "clvmd-comms.h"
@@ -87,7 +88,7 @@ static pthread_t lvm_thread;
 static pthread_mutex_t lvm_thread_mutex;
 static pthread_cond_t lvm_thread_cond;
 static struct list lvm_cmd_head;
-static int quit = 0;
+static volatile sig_atomic_t quit = 0;
 static int child_pipe[2];
 
 /* Reasons the daemon failed initialisation */
@@ -164,6 +165,7 @@ int main(int argc, char *argv[])
 	int debug = 0;
 	int cmd_timeout = DEFAULT_CMD_TIMEOUT;
 	sigset_t ss;
+	int using_gulm = 0;
 
 	/* Deal with command-line arguments */
 	opterr = 0;
@@ -240,6 +242,7 @@ int main(int argc, char *argv[])
 		max_csid_len = CMAN_MAX_CSID_LEN;
 		max_cluster_message = CMAN_MAX_CLUSTER_MESSAGE;
 		max_cluster_member_name_len = CMAN_MAX_CLUSTER_MEMBER_NAME_LEN;
+		syslog(LOG_NOTICE, "Cluster LVM daemon started - connected to CMAN");
 	}
 #endif
 #ifdef USE_GULM
@@ -248,6 +251,8 @@ int main(int argc, char *argv[])
 			max_csid_len = GULM_MAX_CSID_LEN;
 			max_cluster_message = GULM_MAX_CLUSTER_MESSAGE;
 			max_cluster_member_name_len = GULM_MAX_CLUSTER_MEMBER_NAME_LEN;
+			using_gulm = 1;
+			syslog(LOG_NOTICE, "Cluster LVM daemon started - connected to GULM");
 		}
 #endif
 
@@ -281,7 +286,7 @@ int main(int argc, char *argv[])
 	/* This needs to be started after cluster initialisation
 	   as it may need to take out locks */
 	DEBUGLOG("starting LVM thread\n");
-	pthread_create(&lvm_thread, NULL, lvm_thread_fn, nodeinfo.nodename);
+	pthread_create(&lvm_thread, NULL, lvm_thread_fn, (void *)using_gulm);
 
 	/* Tell the rest of the cluster our version number */
 	/* CMAN can do this immediately, gulm needs to wait until
@@ -540,8 +545,9 @@ static void main_loop(int local_sock, int cmd_timeout)
 						lastfd->next = thisfd->next;
 						free_fd = thisfd;
 						thisfd = lastfd;
-						cmd_client_cleanup(free_fd);
-						free(free_fd);
+
+						/* Queue cleanup, this also frees the client struct */
+						add_to_lvmqueue(free_fd, NULL, 0, NULL);
 						break;
 					}
 
@@ -716,7 +722,7 @@ static int read_from_local_sock(struct local_client *thisfd)
 		if (thisfd->bits.localsock.threadid) {
 			DEBUGLOG("Waiting for child thread\n");
 			pthread_mutex_lock(&thisfd->bits.localsock.mutex);
-			thisfd->bits.localsock.state = POST_COMMAND;
+			thisfd->bits.localsock.state = PRE_COMMAND;
 			pthread_cond_signal(&thisfd->bits.localsock.cond);
 			pthread_mutex_unlock(&thisfd->bits.localsock.mutex);
 			pthread_kill(thisfd->bits.localsock.threadid, SIGUSR2);
@@ -1187,9 +1193,8 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 
 				/* If System LV operation failed then report it as EFBIG but only do it
 				   if the data buffer has something in it. */
-				if (system_lv_write_data
-				    (aggreply,
-				     replylen + sizeof(struct clvm_header)) < 0
+				if (system_lv_write_data(aggreply,
+							 replylen + sizeof(struct clvm_header)) < 0
 				    && replylen > 0)
 					agghead->status = EFBIG;
 
@@ -1207,7 +1212,7 @@ void process_remote_command(struct clvm_header *msg, int msglen, int fd,
 				agghead->node[0] = '\0';
 				send_message(aggreply,
 					     sizeof(struct clvm_header) +
-					     replylen + 2, csid, fd,
+					     replylen, csid, fd,
 					     "Error sending command reply");
 			}
 		} else {
@@ -1333,14 +1338,12 @@ static void *pre_and_post_thread(void *arg)
 
 		DEBUGLOG("Got post command condition...\n");
 
+		/* POST function must always run, even if the client aborts */
 		status = 0;
 		do_post_command(client);
 
 		write(pipe_fd, &status, sizeof(int));
 
-		if (client->bits.localsock.finished)
-			break;
-
 		DEBUGLOG("Waiting for next pre command\n");
 
 		pthread_mutex_lock(&client->bits.localsock.mutex);
@@ -1531,6 +1534,7 @@ static void send_version_message()
 	version_nums[1] = htonl(CLVMD_MINOR_VERSION);
 	version_nums[2] = htonl(CLVMD_PATCH_VERSION);
 
+	hton_clvm(msg);
 	clops->cluster_send_message(message, sizeof(message), NULL,
 			     "Error Sending version number");
 }
@@ -1543,7 +1547,7 @@ static int send_message(void *buf, int msglen, char *csid, int fd,
 
 	/* Send remote messages down the cluster socket */
 	if (csid == NULL || !ISLOCAL_CSID(csid)) {
-		hton_clvm((struct clvm_header *) buf);	/* Byte swap if necessary */
+		hton_clvm((struct clvm_header *) buf);
 		return clops->cluster_send_message(buf, msglen, csid, errtext);
 	} else {
 		int ptr = 0;
@@ -1564,6 +1568,14 @@ static int send_message(void *buf, int msglen, char *csid, int fd,
 
 static int process_work_item(struct lvm_thread_cmd *cmd)
 {
+
+	/* If msg is NULL then this is a cleanup request */
+	if (cmd->msg == NULL) {
+		cmd_client_cleanup(cmd->client);
+		free(cmd->client);
+		return 0;
+	}
+
 	if (!cmd->remote) {
 		DEBUGLOG("process_work_item: local\n");
 		process_local_command(cmd->msg, cmd->msglen, cmd->client,
@@ -1583,9 +1595,9 @@ static void *lvm_thread_fn(void *arg)
 {
 	struct list *cmdl, *tmp;
 	sigset_t ss;
+	int using_gulm = (int)arg;
 
 	DEBUGLOG("LVM thread function started\n");
-	pthread_mutex_lock(&lvm_thread_mutex);
 
 	/* Ignore SIGUSR1 & 2 */
 	sigemptyset(&ss);
@@ -1594,8 +1606,7 @@ static void *lvm_thread_fn(void *arg)
 	pthread_sigmask(SIG_BLOCK, &ss, NULL);
 
 	/* Initialise the interface to liblvm */
-	init_lvm();
-	pthread_mutex_unlock(&lvm_thread_mutex);
+	init_lvm(using_gulm);
 
 	/* Now wait for some actual work */
 	for (;;) {
@@ -1633,17 +1644,22 @@ static int add_to_lvmqueue(struct local_client *client, struct clvm_header *msg,
 	if (!cmd)
 		return ENOMEM;
 
-	cmd->msg = malloc(msglen);
-	if (!cmd->msg) {
-		log_error("Unable to allocate buffer space\n");
-		free(cmd);
-		return -1;
+	if (msglen) {
+		cmd->msg = malloc(msglen);
+		if (!cmd->msg) {
+			log_error("Unable to allocate buffer space\n");
+			free(cmd);
+			return -1;
+		}
+		memcpy(cmd->msg, msg, msglen);
+	}
+	else {
+		cmd->msg = NULL;
 	}
-
 	cmd->client = client;
 	cmd->msglen = msglen;
 	cmd->xid = client->xid;
-	memcpy(cmd->msg, msg, msglen);
+
 	if (csid) {
 		memcpy(cmd->csid, csid, max_csid_len);
 		cmd->remote = 1;
@@ -1676,6 +1692,8 @@ static int open_local_sock()
 		log_error("Can't create local socket: %m");
 		return -1;
 	}
+	/* Set Close-on-exec */
+	fcntl(local_socket, F_SETFD, 1);
 
 	memset(&sockaddr, 0, sizeof(sockaddr));
 	memcpy(sockaddr.sun_path, CLVMD_SOCKNAME, sizeof(CLVMD_SOCKNAME));

daemons/clvmd/clvmd.h

@@ -93,9 +93,9 @@ struct local_client {
 		struct netsock_bits net;
 	} bits;
 };
-#define DEBUG
+
 #ifdef DEBUG
-#define DEBUGLOG(fmt, args...) fprintf(stderr, "CLVMD[%d]: %ld ", getpid(), time(NULL) ); fprintf(stderr, fmt, ## args)
+#define DEBUGLOG(fmt, args...) fprintf(stderr, "CLVMD[%x]: %ld ", (int)pthread_self(), time(NULL) ); fprintf(stderr, fmt, ## args)
 #else
 #define DEBUGLOG(fmt, args...)
 #endif

daemons/clvmd/lvm-functions.c

@@ -388,6 +388,44 @@ int do_check_lvm1(char *vgname)
 	return status == 1 ? 0 : EBUSY;
 }
 
+
+/* Only called at gulm startup. Drop any leftover VG or P_orphan locks
+   that might be hanging around if we died for any reason
+*/
+static void drop_vg_locks()
+{
+	char vg[128];
+	char line[255];
+	FILE *vgs =
+	    popen
+	    ("lvm pvs --nolocking --noheadings -o vg_name", "r");
+
+	sync_unlock("P_orphans", LCK_EXCL);
+
+	if (!vgs)
+		return;
+
+	while (fgets(line, sizeof(line), vgs)) {
+		char *vgend;
+		char *vgstart;
+
+		if (line[strlen(line)-1] == '\n')
+			line[strlen(line)-1] = '\0';
+
+		vgstart = line + strspn(line, " ");
+		vgend = vgstart + strcspn(vgstart, " ");
+		*vgend = '\0';
+
+		if (strncmp(vgstart, "WARNING:", 8) == 0)
+			continue;
+
+		sprintf(vg, "V_%s", vgstart);
+		sync_unlock(vg, LCK_EXCL);
+
+	}
+	fclose(vgs);
+}
+
 /*
  * Ideally, clvmd should be started before any LVs are active
  * but this may not be the case...
@@ -400,7 +438,7 @@ static void *get_initial_state()
 	char line[255];
 	FILE *lvs =
 	    popen
-	    ("/sbin/lvm lvs --nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr",
+	    ("lvm lvs --nolocking --noheadings -o vg_uuid,lv_uuid,lv_attr",
 	     "r");
 
 	if (!lvs)
@@ -438,6 +476,30 @@ static void *get_initial_state()
 	return NULL;
 }
 
+/* This checks some basic cluster-LVM configuration stuff */
+static void check_config()
+{
+	int locking_type;
+
+	locking_type = find_config_int(cmd->cft->root, "global/locking_type", 1);
+
+	if (locking_type == 3) /* compiled-in cluster support */
+		return;
+
+	if (locking_type == 2) { /* External library, check name */
+		const char *libname;
+
+		libname = find_config_str(cmd->cft->root, "global/locking_library",
+					  "");
+		if (strstr(libname, "liblvm2clusterlock.so"))
+			return;
+
+		log_error("Incorrect LVM locking library specified in lvm.conf, cluster operations may not work.");
+		return;
+	}
+	log_error("locking_type not set correctly in lvm.conf, cluster operations will not work.");
+}
+
 void init_lvhash()
 {
 	/* Create hash table for keeping LV locks & status */
@@ -446,7 +508,7 @@ void init_lvhash()
 }
 
 /* Called to initialise the LVM context of the daemon */
-int init_lvm(void)
+int init_lvm(int using_gulm)
 {
 	if (!(cmd = create_toolcontext(NULL))) {
 		log_error("Failed to allocate command context");
@@ -457,6 +519,13 @@ int init_lvm(void)
 	init_syslog(LOG_DAEMON);
 	init_debug(_LOG_ERR);
 
+	/* Check lvm.conf is setup for cluster-LVM */
+	check_config();
+
+	/* Remove any non-LV locks that may have been left around */
+	if (using_gulm)
+		drop_vg_locks();
+
 	get_initial_state();
 
 	return 1;

daemons/clvmd/lvm-functions.h

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

daemons/clvmd/tcp-comms.c

@@ -2,6 +2,7 @@
 *******************************************************************************
 **
 **  Copyright (C) Sistina Software, Inc.  2002-2003  All rights reserved.
+**  Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
 **
 *******************************************************************************
 ******************************************************************************/
@@ -84,6 +85,9 @@ int init_comms(unsigned short port)
 
     listen(listen_fd, 5);
 
+    /* Set Close-on-exec */
+    fcntl(listen_fd, F_SETFD, 1);
+
     return 0;
 }
 
@@ -227,7 +231,9 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
 {
     struct sockaddr_in6 addr;
     socklen_t slen = sizeof(addr);
+    struct clvm_header *header = (struct clvm_header *)buf;
     int status;
+    uint32_t arglen;
 
     DEBUGLOG("read_from_tcpsock fd %d\n", client->fd);
     *new_client = NULL;
@@ -236,7 +242,26 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
     getpeername(client->fd, (struct sockaddr *)&addr, &slen);
     memcpy(csid, &addr.sin6_addr, GULM_MAX_CSID_LEN);
 
-    status = read(client->fd, buf, len);
+    /* Read just the header first, then get the rest if there is any.
+     * Stream sockets, sigh.
+     */
+    status = read(client->fd, buf, sizeof(struct clvm_header));
+    if (status > 0)
+    {
+	    int status2;
+
+	    arglen = ntohl(header->arglen);
+
+	    /* Get the rest */
+	    if (arglen && arglen < GULM_MAX_CLUSTER_MESSAGE)
+	    {
+		    status2 = read(client->fd, buf+status, arglen);
+		    if (status2 > 0)
+			    status += status2;
+		    else
+			    status = status2;
+	    }
+    }
 
     DEBUGLOG("read_from_tcpsock, status = %d(errno = %d)\n", status, errno);
 
@@ -259,13 +284,14 @@ static int read_from_tcpsock(struct local_client *client, char *buf, int len, ch
 	add_down_node(remcsid);
     }
     else {
+	    gulm_add_up_node(csid);
 	    /* Send it back to clvmd */
 	    process_message(client, buf, len, csid);
     }
     return status;
 }
 
-static int connect_csid(char *csid, struct local_client **newclient)
+int gulm_connect_csid(char *csid, struct local_client **newclient)
 {
     int fd;
     struct sockaddr_in6 addr;
@@ -287,12 +313,21 @@ static int connect_csid(char *csid, struct local_client **newclient)
     DEBUGLOG("Connecting socket %d\n", fd);
     if (connect(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in6)) < 0)
     {
-	syslog(LOG_ERR, "Unable to connect to remote node: %m");
+	/* "Connection refused" is "normal" because clvmd may not yet be running
+	 * on that node.
+	 */
+	if (errno != ECONNREFUSED)
+	{
+	    syslog(LOG_ERR, "Unable to connect to remote node: %m");
+	}
 	DEBUGLOG("Unable to connect to remote node: %s\n", strerror(errno));
 	close(fd);
 	return -1;
     }
 
+    /* Set Close-on-exec */
+    fcntl(fd, F_SETFD, 1);
+
     status = alloc_client(fd, csid, newclient);
     if (status)
 	close(fd);
@@ -323,7 +358,7 @@ static int tcp_send_message(void *buf, int msglen, unsigned char *csid, const ch
     client = hash_lookup_binary(sock_hash, csid, GULM_MAX_CSID_LEN);
     if (!client)
     {
-	status = connect_csid(csid, &client);
+	status = gulm_connect_csid(csid, &client);
 	if (status)
 	    return -1;
     }

daemons/clvmd/tcp-comms.h

@@ -10,3 +10,4 @@ int get_main_gulm_cluster_fd(void);
 int cluster_fd_gulm_callback(struct local_client *fd, char *buf, int len, char *csid, struct local_client **new_client);
 int gulm_cluster_send_message(void *buf, int msglen, char *csid, const char *errtext);
 void get_our_gulm_csid(char *csid);
+int gulm_connect_csid(char *csid, struct local_client **newclient);

doc/example.conf

@@ -258,11 +258,10 @@ activation {
 #
 # metadata {
     # Default number of copies of metadata to hold on each PV.  0, 1 or 2.
-    # It's best to leave this at 2.
-    # You might want to override it from the command line with 0 or 1 
+    # You might want to override it from the command line with 0 
     # when running pvcreate on new PVs which are to be added to large VGs.
 
-    # pvmetadatacopies = 2
+    # pvmetadatacopies = 1
 
     # Approximate default size of on-disk metadata areas in sectors.
     # You should increase this if you have large volume groups or

lib/activate/fs.c

@@ -65,7 +65,7 @@ static int _rm_dir(const char *dev_dir, const char *vg_name)
 		return 0;
 	}
 
-	if (is_empty_dir(vg_path)) {
+	if (dir_exists(vg_path) && is_empty_dir(vg_path)) {
 		log_very_verbose("Removing directory %s", vg_path);
 		rmdir(vg_path);
 	}

lib/cache/lvmcache.c

@@ -104,10 +104,30 @@ struct lvmcache_vginfo *vginfo_from_vgname(const char *vgname)
 const struct format_type *fmt_from_vgname(const char *vgname)
 {
 	struct lvmcache_vginfo *vginfo;
+	struct label *label;
+	struct list *ih, *devh, *tmp;
+	struct list devs;
+	struct device_list *devl;
 
 	if (!(vginfo = vginfo_from_vgname(vgname)))
 		return NULL;
 
+	/* This function is normally called before reading metadata so
+ 	 * we check cached labels here. Unfortunately vginfo is volatile. */
+	list_init(&devs);
+	list_iterate(ih, &vginfo->infos) {
+		devl = malloc(sizeof(*devl));
+		devl->dev = list_item(ih, struct lvmcache_info)->dev;
+		list_add(&devs, &devl->list);
+	}
+
+	list_iterate_safe(devh, tmp, &devs) {
+		devl = list_item(devh, struct device_list);
+		label_read(devl->dev, &label);
+		list_del(&devl->list);
+		free(devl);
+	}
+
 	return vginfo->fmt;
 }
 
@@ -188,7 +208,7 @@ int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)
 		goto out;
 	}
 
-	if (!(iter = dev_iter_create(cmd->filter))) {
+	if (!(iter = dev_iter_create(cmd->filter, (full_scan == 2) ? 1: 0))) {
 		log_error("dev_iter creation failed");
 		goto out;
 	}
@@ -266,7 +286,7 @@ struct device *device_from_pvid(struct cmd_context *cmd, struct id *pvid)
 	if (memlock())
 		return NULL;
 
-	lvmcache_label_scan(cmd, 1);
+	lvmcache_label_scan(cmd, 2);
 
 	/* Try again */
 	if ((info = info_from_pvid((char *) pvid))) {
@@ -403,6 +423,9 @@ int lvmcache_update_vgname(struct lvmcache_info *info, const char *vgname)
 	/* FIXME Check consistency of list! */
 	vginfo->fmt = info->fmt;
 
+	log_debug("lvmcache: %s now %s%s", dev_name(info->dev),
+		  *vgname ? "in VG " : "orphaned", vgname);
+
 	return 1;
 }
 
@@ -551,6 +574,8 @@ static void _lvmcache_destroy_lockname(int present)
 
 void lvmcache_destroy(void)
 {
+	log_verbose("Wiping internal VG cache");
+
 	_has_scanned = 0;
 
 	if (_vgid_hash) {

lib/cache/lvmcache.h

@@ -56,7 +56,8 @@ struct lvmcache_info {
 int lvmcache_init(void);
 void lvmcache_destroy(void);
 
-/* Set full_scan to 1 to reread every filtered device label */
+/* Set full_scan to 1 to reread every filtered device label or
+ * 2 to rescan /dev for new devices */
 int lvmcache_label_scan(struct cmd_context *cmd, int full_scan);
 
 /* Add/delete a device */

lib/commands/toolcontext.c

@@ -181,6 +181,12 @@ static int _process_config(struct cmd_context *cmd)
 		return 0;
 	}
 
+	if (*cmd->proc_dir && !dir_exists(cmd->proc_dir)) {
+		log_error("Warning: proc dir %s not found - some checks will be bypassed",
+			  cmd->proc_dir);
+		cmd->proc_dir[0] = '\0';
+	}
+
 	/* activation? */
 	cmd->default_settings.activation = find_config_int(cmd->cft->root,
 							   "global/activation",
@@ -825,8 +831,13 @@ struct cmd_context *create_toolcontext(struct arg *the_args)
 		goto error;
 
 	/* Create system directory if it doesn't already exist */
-	if (*cmd->sys_dir && !create_dir(cmd->sys_dir))
+	if (*cmd->sys_dir && !create_dir(cmd->sys_dir)) {
+		log_error("Failed to create LVM2 system dir for metadata backups, config "
+			  "files and internal cache.");
+		log_error("Set environment variable LVM_SYSTEM_DIR to alternative location "
+			  "or empty string.");
 		goto error;
+	}
 
 	if (!(cmd->libmem = pool_create("library", 4 * 1024))) {
 		log_error("Library memory pool creation failed");

lib/device/dev-cache.c

@@ -21,6 +21,7 @@
 #include "lvm-types.h"
 #include "btree.h"
 #include "filter.h"
+#include "filter-persistent.h"
 
 #include <unistd.h>
 #include <sys/param.h>
@@ -186,7 +187,7 @@ static int _add_alias(struct device *dev, const char *path)
 	/* Is name already there? */
 	list_iterate(ah, &dev->aliases) {
 		if (!strcmp(list_item(ah, struct str_list)->str, path)) {
-			stack;
+			log_debug("%s: Already in device cache", path);
 			return 1;
 		}
 	}
@@ -355,11 +356,11 @@ static int _insert(const char *path, int rec)
 	return r;
 }
 
-static void _full_scan(void)
+static void _full_scan(int dev_scan)
 {
 	struct list *dh;
 
-	if (_cache.has_scanned)
+	if (_cache.has_scanned && !dev_scan)
 		return;
 
 	list_iterate(dh, &_cache.dirs) {
@@ -368,6 +369,7 @@ static void _full_scan(void)
 	};
 
 	_cache.has_scanned = 1;
+	init_full_scan_done(1);
 }
 
 int dev_cache_has_scanned(void)
@@ -379,15 +381,14 @@ void dev_cache_scan(int do_scan)
 {
 	if (!do_scan)
 		_cache.has_scanned = 1;
-	else {
-		_cache.has_scanned = 0;
-		_full_scan();
-	}
+	else
+		_full_scan(1);
 }
 
 int dev_cache_init(void)
 {
 	_cache.names = NULL;
+	_cache.has_scanned = 0;
 
 	if (!(_cache.mem = pool_create("dev_cache", 10 * 1024))) {
 		stack;
@@ -540,7 +541,7 @@ struct device *dev_cache_get(const char *name, struct dev_filter *f)
 	return (d && (!f || f->passes_filter(f, d))) ? d : NULL;
 }
 
-struct dev_iter *dev_iter_create(struct dev_filter *f)
+struct dev_iter *dev_iter_create(struct dev_filter *f, int dev_scan)
 {
 	struct dev_iter *di = dbg_malloc(sizeof(*di));
 
@@ -549,7 +550,14 @@ struct dev_iter *dev_iter_create(struct dev_filter *f)
 		return NULL;
 	}
 
-	_full_scan();
+
+	if (dev_scan) {
+		/* Flag gets reset between each command */
+		if (!full_scan_done())
+			persistent_filter_wipe(f); /* Calls _full_scan(1) */
+	} else
+		_full_scan(0);
+
 	di->current = btree_first(_cache.devices);
 	di->filter = f;
 

lib/device/dev-cache.h

@@ -45,7 +45,7 @@ struct device *dev_cache_get(const char *name, struct dev_filter *f);
  * Object for iterating through the cache.
  */
 struct dev_iter;
-struct dev_iter *dev_iter_create(struct dev_filter *f);
+struct dev_iter *dev_iter_create(struct dev_filter *f, int dev_scan);
 void dev_iter_destroy(struct dev_iter *iter);
 struct device *dev_iter_get(struct dev_iter *iter);
 

lib/device/dev-io.c

@@ -341,7 +341,10 @@ int dev_open_flags(struct device *dev, int flags, int direct, int quiet)
 #endif
 
 	if ((dev->fd = open(name, flags, 0777)) < 0) {
-		log_sys_error("open", name);
+		if (quiet)
+			log_sys_debug("open", name);
+		else
+			log_sys_error("open", name);
 		return 0;
 	}
 

lib/display/display.c

@@ -258,7 +258,7 @@ void pvdisplay_full(struct cmd_context *cmd, struct physical_volume *pv,
 		log_print("PV Size               %s" " / not usable %s",	/*  [LVM: %s]", */
 			  size,
 			  display_size(cmd, (pv->size -
-					     pv->pe_count * pv->pe_size),
+				       (uint64_t) pv->pe_count * pv->pe_size),
 				       SIZE_SHORT));
 
 	} else

lib/filters/filter-persistent.c

@@ -53,7 +53,9 @@ int persistent_filter_wipe(struct dev_filter *f)
 {
 	struct pfilter *pf = (struct pfilter *) f->private;
 
+	log_verbose("Wiping cache of LVM-capable devices");
 	hash_wipe(pf->devices);
+
 	/* Trigger complete device scan */
 	dev_cache_scan(1);
 

lib/filters/filter-sysfs.c

@@ -172,7 +172,7 @@ static int _read_devs(struct dev_set *ds, const char *dir)
 	unsigned char dtype;
 	struct stat info;
 	char path[PATH_MAX];
-	dev_t dev;
+	dev_t dev = { 0 };
 	int r = 1;
 
         if (!(dr = opendir(dir))) {

lib/filters/filter.c

@@ -88,7 +88,7 @@ static int _passes_lvm_type_device_filter(struct dev_filter *f,
 	}
 
 	/* Check it's accessible */
-	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {
+	if (!dev_open_flags(dev, O_RDONLY, 0, 1)) {
 		log_debug("%s: Skipping: open failed", name);
 		return 0;
 	}

lib/format1/disk-rep.c

@@ -482,7 +482,7 @@ int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
 		/* vgcache_del(vg_name); */
 	}
 
-	if (!(iter = dev_iter_create(filter))) {
+	if (!(iter = dev_iter_create(filter, 1))) {
 		log_error("read_pvs_in_vg: dev_iter_create failed");
 		return 0;
 	}

lib/format_pool/disk_rep.h

@@ -20,6 +20,8 @@
 #include "metadata.h"
 #include "pool.h"
 
+#define MINOR_OFFSET 65536
+
 /* From NSP.cf */
 #define NSPMajorVersion	4
 #define NSPMinorVersion	1

lib/format_pool/import_export.c

@@ -108,7 +108,7 @@ int import_pool_lvs(struct volume_group *vg, struct pool *mem, struct list *pls)
 		/* for pool a minor of 0 is dynamic */
 		if (pl->pd.pl_minor) {
 			lv->status |= FIXED_MINOR;
-			lv->minor = pl->pd.pl_minor;
+			lv->minor = pl->pd.pl_minor + MINOR_OFFSET;
 		} else {
 			lv->minor = -1;
 		}

lib/format_text/archive.c

@@ -53,7 +53,7 @@ struct archive_file {
 	struct list list;
 
 	char *path;
-	int index;
+	uint32_t index;
 };
 
 /*
@@ -132,7 +132,8 @@ static char *_join(struct pool *mem, const char *dir, const char *name)
 static struct list *_scan_archive(struct pool *mem,
 				  const char *vgname, const char *dir)
 {
-	int i, count, ix;
+	int i, count;
+	uint32_t ix;
 	char vgname_found[64], *path;
 	struct dirent **dirent;
 	struct archive_file *af;
@@ -240,7 +241,7 @@ int archive_vg(struct volume_group *vg,
 	       uint32_t retain_days, uint32_t min_archive)
 {
 	int i, fd, renamed = 0;
-	unsigned int ix = 0;
+	uint32_t ix = 0;
 	struct archive_file *last;
 	FILE *fp = NULL;
 	char temp_file[PATH_MAX], archive_name[PATH_MAX];
@@ -285,7 +286,7 @@ int archive_vg(struct volume_group *vg,
 
 	for (i = 0; i < 10; i++) {
 		if (lvm_snprintf(archive_name, sizeof(archive_name),
-				 "%s/%s_%05d.vg", dir, vg->name, ix) < 0) {
+				 "%s/%s_%05u.vg", dir, vg->name, ix) < 0) {
 			log_error("Archive file name too long.");
 			return 0;
 		}

lib/format_text/format-text.c

@@ -188,6 +188,7 @@ static struct raw_locn *_find_vg_rlocn(struct device_area *dev_area,
 	size_t len;
 	char vgnamebuf[NAME_LEN + 2];
 	struct raw_locn *rlocn;
+	struct lvmcache_info *info;
 
 	rlocn = mdah->raw_locns;
 
@@ -196,7 +197,7 @@ static struct raw_locn *_find_vg_rlocn(struct device_area *dev_area,
 		if (!dev_read(dev_area->dev, dev_area->start + rlocn->offset,
 			      sizeof(vgnamebuf), vgnamebuf)) {
 			stack;
-			return NULL;
+			goto error;
 		}
 		if (!strncmp(vgnamebuf, vgname, len = strlen(vgname)) &&
 		    (isspace(vgnamebuf[len]) || vgnamebuf[len] == '{')) {
@@ -205,6 +206,10 @@ static struct raw_locn *_find_vg_rlocn(struct device_area *dev_area,
 		rlocn++;
 	}
 
+      error:
+	if ((info = info_from_pvid(dev_area->dev->pvid)))
+		lvmcache_update_vgname(info, ORPHAN);
+
 	return NULL;
 }
 
@@ -264,7 +269,7 @@ static struct volume_group *_vg_read_raw_area(struct format_instance *fid,
 	}
 
 	if (!(rlocn = _vg_posn(fid, area, vgname))) {
-		stack;
+		log_debug("VG %s not found on %s", vgname, dev_name(area->dev));
 		goto out;
 	}
 
@@ -1183,9 +1188,9 @@ static int _pv_read(const struct format_type *fmt, const char *pv_name,
 		return 1;
 	}
 
-	/* Perform full scan and try again */
-	if (!memlock()) {
-		lvmcache_label_scan(fmt->cmd, 1);
+	/* Perform full scan (just the first time) and try again */
+	if (!memlock() && !full_scan_done()) {
+		lvmcache_label_scan(fmt->cmd, 2);
 
 		if (info->vginfo && info->vginfo->vgname &&
 		    *info->vginfo->vgname &&

lib/format_text/import_vsn1.c

@@ -31,7 +31,7 @@ typedef int (*section_fn) (struct format_instance * fid, struct pool * mem,
 			   struct hash_table * pv_hash);
 
 #define _read_int32(root, path, result) \
-	get_config_uint32(root, path, result)
+	get_config_uint32(root, path, (uint32_t *) result)
 
 #define _read_uint32(root, path, result) \
 	get_config_uint32(root, path, result)

lib/label/label.c

@@ -117,12 +117,17 @@ static struct labeller *_find_labeller(struct device *dev, char *buf,
 	struct labeller_i *li;
 	struct labeller *r = NULL;
 	struct label_header *lh;
+	struct lvmcache_info *info;
 	uint64_t sector;
 	int found = 0;
 	char readbuf[LABEL_SCAN_SIZE];
 
 	if (!dev_open(dev)) {
 		stack;
+
+		if ((info = info_from_pvid(dev->pvid)))
+			lvmcache_update_vgname(info, ORPHAN);
+
 		return NULL;
 	}
 
@@ -182,10 +187,13 @@ static struct labeller *_find_labeller(struct device *dev, char *buf,
 		}
 	}
 
-	if (!found)
-		log_very_verbose("%s: No label detected", dev_name(dev));
-
       out:
+	if (!found) {
+		if ((info = info_from_pvid(dev->pvid)))
+			lvmcache_update_vgname(info, ORPHAN);
+		log_very_verbose("%s: No label detected", dev_name(dev));
+	}
+
 	if (!dev_close(dev))
 		stack;
 
@@ -279,7 +287,7 @@ int label_read(struct device *dev, struct label **result)
 		return 0;
 	}
 
-	if ((r = l->ops->read(l, dev, buf, result)) && result && *result)
+	if ((r = (l->ops->read)(l, dev, buf, result)) && result && *result)
 		(*result)->sector = sector;
 
 	return r;
@@ -309,7 +317,7 @@ int label_write(struct device *dev, struct label *label)
 	lh->sector_xl = xlate64(label->sector);
 	lh->offset_xl = xlate32(sizeof(*lh));
 
-	if (!label->labeller->ops->write(label, buf)) {
+	if (!(label->labeller->ops->write)(label, buf)) {
 		stack;
 		return 0;
 	}

lib/locking/cluster_locking.c

@@ -446,7 +446,7 @@ int init_cluster_locking(struct locking_type *locking, struct config_tree *cft)
 	locking->lock_resource = _lock_resource;
 	locking->fin_locking = _locking_end;
 	locking->reset_locking = _reset_locking;
-	locking->flags = LCK_PRE_MEMLOCK;
+	locking->flags = LCK_PRE_MEMLOCK | LCK_CLUSTERED;
 
 	_clvmd_sock = _open_local_sock();
 	if (_clvmd_sock == -1)
@@ -463,6 +463,7 @@ int locking_init(int type, struct config_tree *cf, uint32_t *flags)
 
 	/* Ask LVM to lock memory before calling us */
 	*flags |= LCK_PRE_MEMLOCK;
+	*flags |= LCK_CLUSTERED;
 
 	return 1;
 }

lib/locking/file_locking.c

@@ -41,7 +41,7 @@ static char _lock_dir[NAME_LEN];
 
 static sig_t _oldhandler;
 static sigset_t _fullsigset, _intsigset;
-static int _handler_installed;
+static volatile sig_atomic_t _handler_installed;
 
 static int _release_lock(const char *file, int unlock)
 {
@@ -95,38 +95,40 @@ static void _reset_file_locking(void)
 static void _remove_ctrl_c_handler()
 {
 	siginterrupt(SIGINT, 0);
-	if (!_handler_installed || _oldhandler == SIG_ERR)
+	if (!_handler_installed)
 		return;
 
+	_handler_installed = 0;
+
 	sigprocmask(SIG_SETMASK, &_fullsigset, NULL);
 	if (signal(SIGINT, _oldhandler) == SIG_ERR)
 		log_sys_error("signal", "_remove_ctrl_c_handler");
-
-	_handler_installed = 0;
 }
 
 static void _trap_ctrl_c(int sig)
 {
 	_remove_ctrl_c_handler();
 	log_error("CTRL-c detected: giving up waiting for lock");
-	return;
 }
 
 static void _install_ctrl_c_handler()
 {
-	if ((_oldhandler = signal(SIGINT, _trap_ctrl_c)) == SIG_ERR)
+	_handler_installed = 1;
+
+	if ((_oldhandler = signal(SIGINT, _trap_ctrl_c)) == SIG_ERR) {
+		_handler_installed = 0;
 		return;
+	}
 
 	sigprocmask(SIG_SETMASK, &_intsigset, NULL);
 	siginterrupt(SIGINT, 1);
-
-	_handler_installed = 1;
 }
 
 static int _lock_file(const char *file, int flags)
 {
 	int operation;
 	int r = 1;
+	int old_errno;
 
 	struct lock_list *ll;
 	struct stat buf1, buf2;
@@ -176,10 +178,12 @@ static int _lock_file(const char *file, int flags)
 			_install_ctrl_c_handler();
 
 		r = flock(ll->lf, operation);
+		old_errno = errno;
 		if (!(flags & LCK_NONBLOCK))
 			_remove_ctrl_c_handler();
 
 		if (r) {
+			errno = old_errno;
 			log_sys_error("flock", ll->res);
 			goto err;
 		}

lib/locking/locking.c

@@ -124,6 +124,8 @@ static inline void _update_vg_lock_count(int flags)
  */
 int init_locking(int type, struct config_tree *cft)
 {
+	init_lockingfailed(0);
+
 	switch (type) {
 	case 0:
 		init_no_locking(&_locking, cft);
@@ -165,6 +167,7 @@ int init_locking(int type, struct config_tree *cft)
 	log_verbose("Locking disabled - only read operations permitted.");
 
 	init_no_locking(&_locking, cft);
+	init_lockingfailed(1);
 
 	return 1;
 }
@@ -321,3 +324,9 @@ int vg_write_lock_held(void)
 {
 	return _vg_write_lock_held;
 }
+
+int locking_is_clustered(void)
+{
+	return (_locking.flags & LCK_CLUSTERED) ? 1 : 0;
+}
+

lib/locking/locking.h

@@ -20,6 +20,7 @@ int init_locking(int type, struct config_tree *cf);
 void fin_locking(void);
 void reset_locking(void);
 int vg_write_lock_held(void);
+int locking_is_clustered(void);
 
 /*
  * LCK_VG:

lib/locking/locking_types.h

@@ -23,6 +23,7 @@ typedef void (*fin_lock_fn) (void);
 typedef void (*reset_lock_fn) (void);
 
 #define LCK_PRE_MEMLOCK	0x00000001	/* Is memlock() needed before calls? */
+#define LCK_CLUSTERED	0x00000002
 
 struct locking_type {
 	uint32_t flags;

lib/log/log.c

@@ -30,6 +30,7 @@ static int _test = 0;
 static int _partial = 0;
 static int _md_filtering = 0;
 static int _pvmove = 0;
+static int _full_scan_done = 0;	/* Restrict to one full scan during each cmd */
 static int _debug_level = 0;
 static int _syslog = 0;
 static int _log_to_file = 0;
@@ -39,6 +40,7 @@ static int _indent = 1;
 static int _log_cmd_name = 0;
 static int _log_suppress = 0;
 static int _ignorelockingfailure = 0;
+static int _lockingfailed = 0;
 static int _security_level = SECURITY_LEVEL;
 static char _cmd_name[30] = "";
 static char _msg_prefix[30] = "  ";
@@ -149,11 +151,21 @@ void init_pvmove(int level)
 	_pvmove = level;
 }
 
+void init_full_scan_done(int level)
+{
+	_full_scan_done = level;
+}
+
 void init_ignorelockingfailure(int level)
 {
 	_ignorelockingfailure = level;
 }
 
+void init_lockingfailed(int level)
+{
+	_lockingfailed = level;
+}
+
 void init_security_level(int level)
 {
 	_security_level = level;
@@ -203,6 +215,16 @@ int pvmove_mode()
 	return _pvmove;
 }
 
+int full_scan_done()
+{
+	return _full_scan_done;
+}
+
+int lockingfailed()
+{
+	return _lockingfailed;
+}
+
 int ignorelockingfailure()
 {
 	return _ignorelockingfailure;

lib/log/log.h

@@ -65,11 +65,13 @@ void init_test(int level);
 void init_partial(int level);
 void init_md_filtering(int level);
 void init_pvmove(int level);
+void init_full_scan_done(int level);
 void init_debug(int level);
 void init_cmd_name(int status);
 void init_msg_prefix(const char *prefix);
 void init_indent(int indent);
 void init_ignorelockingfailure(int level);
+void init_lockingfailed(int level);
 void init_security_level(int level);
 
 void set_cmd_name(const char *cmd_name);
@@ -78,8 +80,10 @@ int test_mode(void);
 int partial_mode(void);
 int md_filtering(void);
 int pvmove_mode(void);
+int full_scan_done(void);
 int debug_level(void);
 int ignorelockingfailure(void);
+int lockingfailed(void);
 int security_level(void);
 
 /* Suppress messages to stdout/stderr */

lib/metadata/metadata.c

@@ -654,7 +654,7 @@ struct volume_group *vg_read(struct cmd_context *cmd, const char *vgname,
 				stack;
 				return NULL;
 			}
-			lvmcache_label_scan(cmd, 1);
+			lvmcache_label_scan(cmd, 2);
 			if (!(fmt = fmt_from_vgname(vgname))) {
 				stack;
 				return NULL;
@@ -687,10 +687,46 @@ struct volume_group *vg_read(struct cmd_context *cmd, const char *vgname,
 		}
 	}
 
-	/* Failed to find VG */
+	/* Failed to find VG where we expected it - full scan and retry */
 	if (!correct_vg) {
-		stack;
-		return NULL;
+		inconsistent = 0;
+
+		lvmcache_label_scan(cmd, 2);
+		if (!(fmt = fmt_from_vgname(vgname))) {
+			stack;
+			return NULL;
+		}
+
+		/* create format instance with appropriate metadata area */
+		if (!(fid = fmt->ops->create_instance(fmt, vgname, NULL))) {
+			log_error("Failed to create format instance");
+			return NULL;
+		}
+
+		/* Ensure contents of all metadata areas match - else recover */
+		list_iterate(mdah, &fid->metadata_areas) {
+			mda = list_item(mdah, struct metadata_area);
+			if (!(vg = mda->ops->vg_read(fid, vgname, mda))) {
+				inconsistent = 1;
+				continue;
+			}
+			if (!correct_vg) {
+				correct_vg = vg;
+				continue;
+			}
+			/* FIXME Also ensure contents same - checksums same? */
+			if (correct_vg->seqno != vg->seqno) {
+				inconsistent = 1;
+				if (vg->seqno > correct_vg->seqno)
+					correct_vg = vg;
+			}
+		}
+
+		/* Give up looking */
+		if (!correct_vg) {
+			stack;
+			return NULL;
+		}
 	}
 
 	lvmcache_update_vg(correct_vg);
@@ -768,7 +804,7 @@ struct volume_group *vg_read_by_vgid(struct cmd_context *cmd, const char *vgid)
 	 *       allowed to do a full scan here any more. */
 
 	// The slow way - full scan required to cope with vgrename 
-	if (!(vgnames = get_vgs(cmd, 1))) {
+	if (!(vgnames = get_vgs(cmd, 2))) {
 		log_error("vg_read_by_vgid: get_vgs failed");
 		return NULL;
 	}

lib/misc/lvm-file.c

@@ -86,7 +86,11 @@ int lvm_rename(const char *old, const char *new)
 {
 	struct stat buf;
 
-	link(old, new);
+	if (link(old, new)) {
+		log_error("%s: rename to %s failed: %s", old, new,
+			  strerror(errno));
+		return 0;
+	}
 
 	if (stat(old, &buf)) {
 		log_sys_error("stat", old);

lib/report/report.c

@@ -573,7 +573,7 @@ static int _vgsize_disp(struct report_handle *rh, struct field *field,
 	const struct volume_group *vg = (const struct volume_group *) data;
 	uint64_t size;
 
-	size = vg->extent_count * vg->extent_size;
+	size = (uint64_t) vg->extent_count * vg->extent_size;
 
 	return _size64_disp(rh, field, &size);
 }
@@ -584,7 +584,7 @@ static int _segstart_disp(struct report_handle *rh, struct field *field,
 	const struct lv_segment *seg = (const struct lv_segment *) data;
 	uint64_t start;
 
-	start = seg->le * seg->lv->vg->extent_size;
+	start = (uint64_t) seg->le * seg->lv->vg->extent_size;
 
 	return _size64_disp(rh, field, &start);
 }
@@ -595,7 +595,7 @@ static int _segsize_disp(struct report_handle *rh, struct field *field,
 	const struct lv_segment *seg = (const struct lv_segment *) data;
 	uint64_t size;
 
-	size = seg->len * seg->lv->vg->extent_size;
+	size = (uint64_t) seg->len * seg->lv->vg->extent_size;
 
 	return _size64_disp(rh, field, &size);
 }
@@ -610,7 +610,7 @@ static int _pvused_disp(struct report_handle *rh, struct field *field,
 	if (!pv->pe_count)
 		used = 0LL;
 	else
-		used = pv->pe_alloc_count * pv->pe_size;
+		used = (uint64_t) pv->pe_alloc_count * pv->pe_size;
 
 	return _size64_disp(rh, field, &used);
 }
@@ -625,7 +625,7 @@ static int _pvfree_disp(struct report_handle *rh, struct field *field,
 	if (!pv->pe_count)
 		freespace = pv->size;
 	else
-		freespace = (pv->pe_count - pv->pe_alloc_count) * pv->pe_size;
+		freespace = (uint64_t) (pv->pe_count - pv->pe_alloc_count) * pv->pe_size;
 
 	return _size64_disp(rh, field, &freespace);
 }
@@ -640,7 +640,7 @@ static int _pvsize_disp(struct report_handle *rh, struct field *field,
 	if (!pv->pe_count)
 		size = pv->size;
 	else
-		size = pv->pe_count * pv->pe_size;
+		size = (uint64_t) pv->pe_count * pv->pe_size;
 
 	return _size64_disp(rh, field, &size);
 }
@@ -663,7 +663,7 @@ static int _vgfree_disp(struct report_handle *rh, struct field *field,
 	const struct volume_group *vg = (const struct volume_group *) data;
 	uint64_t freespace;
 
-	freespace = vg->free_count * vg->extent_size;
+	freespace = (uint64_t) vg->free_count * vg->extent_size;
 
 	return _size64_disp(rh, field, &freespace);
 }

lib/snapshot/snapshot.c

@@ -31,7 +31,7 @@ static const char *_name(const struct lv_segment *seg)
 static int _text_import(struct lv_segment *seg, const struct config_node *sn,
 			struct hash_table *pv_hash)
 {
-	uint32_t chunk_size, extent_count;
+	uint32_t chunk_size;
 	const char *org_name, *cow_name;
 	struct logical_volume *org, *cow;
 
@@ -70,10 +70,7 @@ static int _text_import(struct lv_segment *seg, const struct config_node *sn,
 		return 0;
 	}
 
-	if (!get_config_uint32(sn, "extent_count", &extent_count))
-		extent_count = org->le_count;
-
-	if (!vg_add_snapshot(org, cow, 1, &seg->lv->lvid.id[1], extent_count,
+	if (!vg_add_snapshot(org, cow, 1, &seg->lv->lvid.id[1], seg->len,
 			     chunk_size)) {
 		stack;
 		return 0;
@@ -85,8 +82,6 @@ static int _text_import(struct lv_segment *seg, const struct config_node *sn,
 static int _text_export(const struct lv_segment *seg, struct formatter *f)
 {
 	outf(f, "chunk_size = %u", seg->chunk_size);
-	if (seg->len != seg->origin->le_count)
-		outf(f, "extent_count = %u", seg->len);
 	outf(f, "origin = \"%s\"", seg->origin->name);
 	outf(f, "cow_store = \"%s\"", seg->cow->name);
 

libdm/Makefile.in

@@ -22,7 +22,12 @@ SOURCES = libdm-common.c libdm-file.c $(interface)/libdm-iface.c
 INCLUDES = -I$(interface)
 
 LIB_STATIC = $(interface)/libdevmapper.a
-LIB_SHARED = $(interface)/libdevmapper.so
+
+ifeq ("@LIB_SUFFIX@","dylib")
+  LIB_SHARED = $(interface)/libdevmapper.dylib
+else
+  LIB_SHARED = $(interface)/libdevmapper.so
+endif
 
 CFLAGS += -DDEVICE_UID=@DEVICE_UID@ -DDEVICE_GID=@DEVICE_GID@ \
 	  -DDEVICE_MODE=@DEVICE_MODE@
@@ -41,7 +46,8 @@ endif
 install: $(INSTALL_TYPE)
 
 install_dynamic: install_@interface@
-	$(LN_S) -f libdevmapper.so.$(LIB_VERSION) $(libdir)/libdevmapper.so
+	$(LN_S) -f libdevmapper.$(LIB_SUFFIX).$(LIB_VERSION) \
+		$(libdir)/libdevmapper.$(LIB_SUFFIX)
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 444 libdevmapper.h \
 		$(includedir)/libdevmapper.h
 
@@ -50,13 +56,13 @@ install_static: install_@interface@_static
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 444 libdevmapper.h \
 		$(includedir)/libdevmapper.h
 
-install_fs: fs/libdevmapper.so
+install_fs: fs/libdevmapper.$(LIB_SUFFIX)
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
-		$(libdir)/libdevmapper.so.$(LIB_VERSION)
+		$(libdir)/libdevmapper.$(LIB_SUFFIX).$(LIB_VERSION)
 
-install_ioctl: ioctl/libdevmapper.so
+install_ioctl: ioctl/libdevmapper.$(LIB_SUFFIX)
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \
-		$(libdir)/libdevmapper.so.$(LIB_VERSION)
+		$(libdir)/libdevmapper.$(LIB_SUFFIX).$(LIB_VERSION)
 
 install_ioctl_static: ioctl/libdevmapper.a
 	$(INSTALL) -D $(OWNER) $(GROUP) -m 555 $(STRIP) $< \

libdm/ioctl/libdm-iface.c

@@ -30,13 +30,14 @@
 #ifdef linux
 #  include "kdev_t.h"
 #  include <linux/limits.h>
-#  include <linux/dm-ioctl.h>
 #else
 #  define MAJOR(x) major((x))
 #  define MINOR(x) minor((x))
 #  define MKDEV(x,y) makedev((x),(y))
 #endif
 
+#include <linux/dm-ioctl.h>
+
 /*
  * Ensure build compatibility.  
  * The hard-coded versions here are the highest present 
@@ -228,6 +229,7 @@ static int _create_control(const char *control, uint32_t major, uint32_t minor)
 
 static int _open_control(void)
 {
+#ifdef DM_IOCTLS
 	char control[PATH_MAX];
 	uint32_t major = 0, minor;
 
@@ -253,6 +255,9 @@ static int _open_control(void)
 error:
 	log_error("Failure to communicate with kernel device-mapper driver.");
 	return 0;
+#else
+	return 1;
+#endif
 }
 
 void dm_task_destroy(struct dm_task *dmt)
@@ -608,7 +613,9 @@ static int _dm_task_run_v1(struct dm_task *dmt)
 	if (dmt->type == DM_DEVICE_LIST) {
 		if (!_dm_names_v1(dmi))
 			goto bad;
-	} else if (ioctl(_control_fd, command, dmi) < 0) {
+	} 
+#ifdef DM_IOCTLS
+	else if (ioctl(_control_fd, command, dmi) < 0) {
 		if (_log_suppress)
 			log_verbose("device-mapper ioctl cmd %d failed: %s",
 				    _IOC_NR(command), strerror(errno));
@@ -617,6 +624,8 @@ static int _dm_task_run_v1(struct dm_task *dmt)
 				  _IOC_NR(command), strerror(errno));
 		goto bad;
 	}
+#else /* Userspace alternative for testing */
+#endif
 
 	if (dmi->flags & DM_BUFFER_FULL_FLAG)
 		/* FIXME Increase buffer size and retry operation (if query) */
@@ -1313,22 +1322,26 @@ int dm_task_run(struct dm_task *dmt)
 		  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))) {
+				       (dmt->type == DM_DEVICE_MKNODES)))
 			dmi->flags &= ~DM_EXISTS_FLAG;	/* FIXME */
-			goto ignore_error;
+		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 (_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;
 	}
+#else /* Userspace alternative for testing */
+#endif
 
-      ignore_error:
 	switch (dmt->type) {
 	case DM_DEVICE_CREATE:
 		add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev),

libdm/libdm-common.c

@@ -21,6 +21,7 @@
 
 #include <stdarg.h>
 #include <sys/param.h>
+
 #include <linux/dm-ioctl.h>
 
 #ifdef HAVE_SELINUX

libdm/libdm-file.c

@@ -19,7 +19,10 @@
 #include <sys/file.h>
 #include <fcntl.h>
 #include <dirent.h>
-#include <malloc.h>
+
+#ifdef linux
+#  include <malloc.h>
+#endif
 
 static int _create_dir_recursive(const char *dir)
 {

man/dmsetup.8.in

@@ -31,7 +31,10 @@ dmsetup \- low level logical volume management
 .br
 .B dmsetup ls
 .br
-.B dmsetup info
+.B dmsetup info 
+.I [device_name]
+.br
+.B dmsetup info -c|-C|--columns [--noheadings] [-o name]
 .I [device_name]
 .br
 .B dmsetup deps
@@ -53,6 +56,13 @@ dmsetup \- low level logical volume management
 .B dmsetup targets
 .br
 .B dmsetup version
+.br
+
+.B devmap_name
+.I major minor
+.br
+.B devmap_name 
+.I major:minor
 .ad b
 .SH DESCRIPTION
 dmsetup manages logical devices that use the device-mapper driver.  
@@ -61,16 +71,38 @@ each sector (512 bytes) in the logical device.
 
 The first argument to dmsetup is a command. 
 The second argument is the logical device name or uuid.
+
+Invoking the command as \fBdevmap_name\fP is equivalent to
+.br
+\fBdmsetup info -c --noheadings -j \fImajor\fB -m \fIminor\fP.
 .SH OPTIONS
+.IP \fB-c|-C|--columns
+.br
+Display output in columns rather than as Field: Value lines.
 .IP \fB-j|--major\ \fImajor
 .br
-Specify the major number to use on creation.
-.IP \fB-j|--minor\ \fIminor
+Specify the major number.
+.IP \fB-m|--minor\ \fIminor
 .br
-Specify the minor number to use on creation.
+Specify the minor number.
+.IP \fB-n|--noheadings
+.br
+Suppress the headings line when using columnar output.
+.IP \fB--noopencount
+.br
+Tell the kernel not to supply the open reference count for the device.
+.IP \fB--notable
+.br
+When creating a device, don't load any table.
+.IP \fB-o|--options
+.br
+Specify which fields to display.  Only \fB-o\ name\fP is supported.
 .IP \fB-r|--readonly
 .br
 Set the table being loaded read-only.
+.IP \fB-u|--uuid
+.br
+Specify the uuid.
 .IP \fB-v|--verbose [-v|--verbose]
 .br
 Produce additional output.

man/pvcreate.8

@@ -91,10 +91,10 @@ The approximate amount of space to be set aside for each metadata area.
 .BR \-\-metadatacopies " copies"
 The number of metadata areas to set aside on each PV.  Currently
 this can be 0, 1 or 2.  
-If set to 2 (the default), two copies of the volume group metadata 
+If set to 2, two copies of the volume group metadata 
 are held on the PV, one at the front of the PV and one at the end.  
-If set to 1, one copy is kept at the front of the PV (starting in the
-5th sector).
+If set to 1 (the default), one copy is kept at the front of the PV 
+(starting in the 5th sector).
 If set to 0, no copies are kept on this PV - you might wish to use this
 with VGs containing large numbers of PVs.  But if you do this and
 then later use \fBvgsplit\fP you must ensure that each VG is still going 

scripts/clvmd_init_rhel4

@@ -9,14 +9,15 @@
 ### END INIT INFO
 
 . /etc/init.d/functions
+
+LVDISPLAY="/usr/sbin/lvdisplay"
+VGCHANGE="/usr/sbin/vgchange"
+VGSCAN="/usr/sbin/vgscan"
+
 [ -f /etc/sysconfig/cluster ] && . /etc/sysconfig/cluster
 
 LOCK_FILE="/var/lock/subsys/clvmd"
 
-lvdisplay="/sbin/lvm.static lvdisplay"
-vgchange="/sbin/lvm.static vgchange"
-vgscan="/sbin/lvm.static vgscan"
-
 start()
 {
 	for rtrn in 0
@@ -38,14 +39,14 @@ start()
 		fi	
 		
 		# refresh cache
-		$vgscan  > /dev/null 2>&1
+		$VGSCAN  > /dev/null 2>&1
 		
 		if [ -n "$LVM_VGS" ]
 		then
 			for vg in $LVM_VGS
 			do
 				echo -n "Activating lvm $vg:"
-				if $vgchange -ayl $vg > /dev/null 2>&1
+				if $VGCHANGE -ayl $vg > /dev/null 2>&1
 				then
 					success
 					echo
@@ -57,7 +58,7 @@ start()
 			done
 		else
 			echo -n "Activating lvms:"
-			if $vgchange -ayl > /dev/null 2>&1
+			if $VGCHANGE -ayl > /dev/null 2>&1
 			then
 				success
 				echo
@@ -81,7 +82,7 @@ stop()
 			for vg in $LVM_VGS
 			do
 				echo -n "Deactivating lvm $vg:"
-				if $vgchange -anl $vg > /dev/null 2>&1
+				if $VGCHANGE -anl $vg > /dev/null 2>&1
 				then
 					success
 					echo
@@ -93,7 +94,7 @@ stop()
 			done
 		else
 			echo -n "Deactivating lvms:"
-			if $vgchange -anl > /dev/null 2>&1
+			if $VGCHANGE -anl > /dev/null 2>&1
 			then
 				success
 				echo
@@ -152,7 +153,7 @@ case "$1" in
 
   status)
 	status clvmd
-	vols=$( $lvdisplay -C --nohead 2> /dev/null | awk '($3 ~ /....a./) {print $1}' )
+	vols=$( $LVDISPLAY -C --nohead 2> /dev/null | awk '($3 ~ /....a./) {print $1}' )
 	echo active volumes: ${vols:-"(none)"}
 	rtrn=0
 	;;

tools/Makefile.in

@@ -90,14 +90,16 @@ ifeq ("@DEVMAPPER@", "yes")
 	LVMLIBS += -ldevmapper
 endif
 
+CFLAGS += -DLVM_SHARED_PATH=\"$(exec_prefix)/sbin/lvm\"
+
 include $(top_srcdir)/make.tmpl
 
 lvm: $(OBJECTS) lvm.o $(top_srcdir)/lib/liblvm.a
 	$(CC) -o $@ $(OBJECTS) lvm.o $(LDFLAGS) $(LVMLIBS) $(LIBS) -rdynamic
 
-lvm.static: $(OBJECTS) lvm.o $(top_srcdir)/lib/liblvm.a
-	$(CC) -o $@ $(OBJECTS) lvm.o -static $(LDFLAGS) $(LVMLIBS) $(LIBS) \
-		-rdynamic
+lvm.static: $(OBJECTS) lvm-static.o $(top_srcdir)/lib/liblvm.a
+	$(CC) -o $@ $(OBJECTS) lvm-static.o -static $(LDFLAGS) $(LVMLIBS) \
+		$(LIBS) -rdynamic
 
 liblvm2cmd.a: $(top_srcdir)/lib/liblvm.a $(OBJECTS)
 	cat $(top_srcdir)/lib/liblvm.a > $@

tools/args.h

@@ -59,6 +59,7 @@ arg(activevolumegroups_ARG, 'A', "activevolumegroups", NULL)
 arg(background_ARG, 'b', "background", NULL)
 arg(blockdevice_ARG, 'b', "blockdevice", NULL)
 arg(chunksize_ARG, 'c', "chunksize", size_kb_arg)
+arg(clustered_ARG, 'c', "clustered", yes_no_arg)
 arg(colon_ARG, 'c', "colon", NULL)
 arg(columns_ARG, 'C', "columns", NULL)
 arg(contiguous_ARG, 'C', "contiguous", yes_no_arg)

tools/commands.h

@@ -410,6 +410,7 @@ xx(pvdisplay,
    "\n"
    "pvdisplay --columns|-C\n"
    "\t[--aligned]\n"
+   "\t[-a|--all]\n"
    "\t[-d|--debug]\n"
    "\t[-h|--help]\n"
    "\t[--ignorelockingfailure]\n"
@@ -424,9 +425,9 @@ xx(pvdisplay,
    "\t[--version]" "\n"
    "\t[PhysicalVolumePath [PhysicalVolumePath...]]\n",
 
-   aligned_ARG, colon_ARG, columns_ARG, ignorelockingfailure_ARG, maps_ARG,
-   noheadings_ARG, nosuffix_ARG, options_ARG, separator_ARG, short_ARG,
-   sort_ARG, unbuffered_ARG, units_ARG)
+   aligned_ARG, all_ARG, colon_ARG, columns_ARG, ignorelockingfailure_ARG,
+   maps_ARG, noheadings_ARG, nosuffix_ARG, options_ARG, separator_ARG,
+   short_ARG, sort_ARG, unbuffered_ARG, units_ARG)
 
 xx(pvmove,
    "Move extents from one physical volume to another",
@@ -436,7 +437,6 @@ xx(pvmove,
    "\t[--alloc AllocationPolicy]\n"
    "\t[-b|--background]\n"
    "\t[-d|--debug]\n "
-   "\t[-f|--force]\n"
    "\t[-h|-?|--help]\n"
    "\t[-i|--interval seconds]\n"
    "\t[-t|--test]\n "
@@ -447,7 +447,7 @@ xx(pvmove,
    "\tSourcePhysicalVolume[:PhysicalExtent[-PhysicalExtent]...]}\n"
    "\t[DestinationPhysicalVolume[:PhysicalExtent[-PhysicalExtent]...]...]\n",
 
-   abort_ARG, alloc_ARG, autobackup_ARG, background_ARG, force_ARG,
+   abort_ARG, alloc_ARG, autobackup_ARG, background_ARG, 
    interval_ARG, name_ARG, test_ARG)
 
 xx(pvremove,
@@ -566,6 +566,7 @@ xx(vgchange,
    "\t[-v|--verbose] " "\n"
    "\t[--version]" "\n"
    "\t{-a|--available [e|l]{y|n}  |" "\n"
+   "\t -c|--clustered {y|n} |" "\n"
    "\t -x|--resizeable {y|n} |" "\n"
    "\t -l|--logicalvolume MaxLogicalVolumes |" "\n"
    "\t --addtag Tag |\n"
@@ -573,8 +574,8 @@ xx(vgchange,
    "\t[VolumeGroupName...]\n",
 
    addtag_ARG, alloc_ARG, allocation_ARG, autobackup_ARG, available_ARG,
-   deltag_ARG, ignorelockingfailure_ARG, logicalvolume_ARG, partial_ARG,
-   resizeable_ARG, resizable_ARG, test_ARG, uuid_ARG)
+   clustered_ARG, deltag_ARG, ignorelockingfailure_ARG, logicalvolume_ARG,
+   partial_ARG, resizeable_ARG, resizable_ARG, test_ARG, uuid_ARG)
 
 xx(vgck,
    "Check the consistency of volume group(s)",
@@ -608,6 +609,7 @@ xx(vgcreate,
    "\t[-A|--autobackup {y|n}] " "\n"
    "\t[--addtag Tag] " "\n"
    "\t[--alloc AllocationPolicy] " "\n"
+   "\t[-c|--clustered] " "\n"
    "\t[-d|--debug]" "\n"
    "\t[-h|--help]" "\n"
    "\t[-l|--maxlogicalvolumes MaxLogicalVolumes]" "\n"
@@ -619,7 +621,7 @@ xx(vgcreate,
    "\t[--version] " "\n"
    "\tVolumeGroupName PhysicalVolume [PhysicalVolume...]\n",
 
-   addtag_ARG, alloc_ARG, autobackup_ARG, maxlogicalvolumes_ARG,
+   addtag_ARG, alloc_ARG, autobackup_ARG, clustered_ARG, maxlogicalvolumes_ARG,
    maxphysicalvolumes_ARG, metadatatype_ARG, physicalextentsize_ARG, test_ARG)
 
 xx(vgdisplay,

tools/dmsetup.c

@@ -23,6 +23,7 @@
 #include <dirent.h>
 #include <errno.h>
 #include <unistd.h>
+#include <libgen.h>
 
 #ifdef HAVE_GETOPTLONG
 #  include <getopt.h>
@@ -60,6 +61,7 @@ enum {
 	NOHEADINGS_ARG,
 	NOOPENCOUNT_ARG,
 	NOTABLE_ARG,
+	OPTIONS_ARG,
 	UUID_ARG,
 	VERBOSE_ARG,
 	VERSION_ARG,
@@ -69,6 +71,7 @@ enum {
 static int _switches[NUM_SWITCHES];
 static int _values[NUM_SWITCHES];
 static char *_uuid;
+static char *_fields;
 
 /*
  * Commands
@@ -137,15 +140,18 @@ static void _display_info_cols_noheadings(struct dm_task *dmt,
 
 	uuid = dm_task_get_uuid(dmt);
 
-	printf("%s:%d:%d:%s%s%s%s:%d:%d:%" PRIu32 ":%s\n",
-	       dm_task_get_name(dmt),
-	       info->major, info->minor,
-	       info->live_table ? "L" : "-",
-	       info->inactive_table ? "I" : "-",
-	       info->suspended ? "s" : "-",
-	       info->read_only ? "r" : "w",
-	       info->open_count, info->target_count, info->event_nr,
-	       uuid && *uuid ? uuid : "");
+	if (_switches[OPTIONS_ARG])
+		printf("%s\n", dm_task_get_name(dmt));
+	else
+		printf("%s:%d:%d:%s%s%s%s:%d:%d:%" PRIu32 ":%s\n",
+		       dm_task_get_name(dmt),
+		       info->major, info->minor,
+		       info->live_table ? "L" : "-",
+		       info->inactive_table ? "I" : "-",
+		       info->suspended ? "s" : "-",
+		       info->read_only ? "r" : "w",
+		       info->open_count, info->target_count, info->event_nr,
+		       uuid && *uuid ? uuid : "");
 }
 
 static void _display_info_cols(struct dm_task *dmt, struct dm_info *info)
@@ -159,24 +165,31 @@ static void _display_info_cols(struct dm_task *dmt, struct dm_info *info)
 	}
 
 	if (!_headings) {
-		printf("Name             Maj Min Stat Open Targ Event  UUID\n");
+		if (_switches[OPTIONS_ARG])
+			printf("Name\n");
+		else
+			printf("Name             Maj Min Stat Open Targ "
+			       "Event  UUID\n");
 		_headings = 1;
 	}
 
-	printf("%-16s ", dm_task_get_name(dmt));
+	if (_switches[OPTIONS_ARG])
+		printf("%s\n", dm_task_get_name(dmt));
+	else {
+		printf("%-16s %3d %3d %s%s%s%s %4d %4d %6" PRIu32 " ",
+		       dm_task_get_name(dmt),
+		       info->major, info->minor,
+		       info->live_table ? "L" : "-",
+		       info->inactive_table ? "I" : "-",
+		       info->suspended ? "s" : "-",
+		       info->read_only ? "r" : "w",
+		       info->open_count, info->target_count, info->event_nr);
 
-	printf("%3d %3d %s%s%s%s %4d %4d %6" PRIu32 " ",
-	       info->major, info->minor,
-	       info->live_table ? "L" : "-",
-	       info->inactive_table ? "I" : "-",
-	       info->suspended ? "s" : "-",
-	       info->read_only ? "r" : "w",
-	       info->open_count, info->target_count, info->event_nr);
+		if ((uuid = dm_task_get_uuid(dmt)) && *uuid)
+			printf("%s", uuid);
 
-	if ((uuid = dm_task_get_uuid(dmt)) && *uuid)
-		printf("%s", uuid);
-
-	printf("\n");
+		printf("\n");
+	}
 }
 
 static void _display_info_long(struct dm_task *dmt, struct dm_info *info)
@@ -217,12 +230,12 @@ static void _display_info_long(struct dm_task *dmt, struct dm_info *info)
 	printf("\n");
 }
 
-static void _display_info(struct dm_task *dmt)
+static int _display_info(struct dm_task *dmt)
 {
 	struct dm_info info;
 
 	if (!dm_task_get_info(dmt, &info))
-		return;
+		return 0;
 
 	if (!_switches[COLS_ARG])
 		_display_info_long(dmt, &info);
@@ -230,6 +243,8 @@ static void _display_info(struct dm_task *dmt)
 		_display_info_cols_noheadings(dmt, &info);
 	else
 		_display_info_cols(dmt, &info);
+
+	return info.exists ? 1 : 0;
 }
 
 static int _set_task_device(struct dm_task *dmt, const char *name, int optional)
@@ -301,7 +316,7 @@ static int _load(int argc, char **argv, void *data)
 	r = 1;
 
 	if (_switches[VERBOSE_ARG])
-		_display_info(dmt);
+		r = _display_info(dmt);
 
       out:
 	dm_task_destroy(dmt);
@@ -348,7 +363,7 @@ static int _create(int argc, char **argv, void *data)
 	r = 1;
 
 	if (_switches[VERBOSE_ARG])
-		_display_info(dmt);
+		r = _display_info(dmt);
 
       out:
 	dm_task_destroy(dmt);
@@ -495,7 +510,7 @@ static int _simple(int task, const char *name, uint32_t event_nr, int display)
 	r = dm_task_run(dmt);
 
 	if (r && display && _switches[VERBOSE_ARG])
-		_display_info(dmt);
+		r = _display_info(dmt);
 
       out:
 	dm_task_destroy(dmt);
@@ -735,9 +750,7 @@ static int _info(int argc, char **argv, void *data)
 	if (!dm_task_run(dmt))
 		goto out;
 
-	_display_info(dmt);
-
-	r = 1;
+	r = _display_info(dmt);
 
       out:
 	dm_task_destroy(dmt);
@@ -891,6 +904,7 @@ static struct command *_find_command(const char *name)
 
 static int _process_switches(int *argc, char ***argv)
 {
+	char *base, *namebase;
 	int ind;
 	int c;
 
@@ -903,6 +917,7 @@ static int _process_switches(int *argc, char ***argv)
 		{"noheadings", 0, NULL, NOHEADINGS_ARG},
 		{"noopencount", 0, NULL, NOOPENCOUNT_ARG},
 		{"notable", 0, NULL, NOTABLE_ARG},
+		{"options", 1, NULL, OPTIONS_ARG},
 		{"uuid", 1, NULL, UUID_ARG},
 		{"verbose", 1, NULL, VERBOSE_ARG},
 		{"version", 0, NULL, VERSION_ARG},
@@ -918,9 +933,43 @@ static int _process_switches(int *argc, char ***argv)
 	memset(&_switches, 0, sizeof(_switches));
 	memset(&_values, 0, sizeof(_values));
 
+	namebase = strdup((*argv)[0]);
+	base = basename(namebase);
+
+	if (!strcmp(base, "devmap_name")) {
+		free(namebase);
+		_switches[COLS_ARG]++;
+		_switches[NOHEADINGS_ARG]++;
+		_switches[OPTIONS_ARG]++;
+		_switches[MAJOR_ARG]++;
+		_switches[MINOR_ARG]++;
+		_fields = (char *) "name";
+
+		if (*argc == 3) {
+			_values[MAJOR_ARG] = atoi((*argv)[1]);
+			_values[MINOR_ARG] = atoi((*argv)[2]);
+			*argc -= 2;
+			*argv += 2;
+		} else if ((*argc == 2) && 
+			   (2 == sscanf((*argv)[1], "%i:%i",
+					&_values[MAJOR_ARG],
+					&_values[MINOR_ARG]))) {
+			*argc -= 1;
+			*argv += 1;
+		} else {
+			fprintf(stderr, "Usage: devmap_name <major> <minor>\n");
+			return 0;
+		}
+
+		(*argv)[0] = (char *) "info";
+		return 1;
+	}
+
+	free(namebase);
+
 	optarg = 0;
 	optind = OPTIND_INIT;
-	while ((c = GETOPTLONG_FN(*argc, *argv, "cCj:m:nru:v",
+	while ((c = GETOPTLONG_FN(*argc, *argv, "cCj:m:no:ru:v",
 				  long_options, &ind)) != -1) {
 		if (c == 'c' || c == 'C' || ind == COLS_ARG)
 			_switches[COLS_ARG]++;
@@ -936,6 +985,10 @@ static int _process_switches(int *argc, char ***argv)
 		}
 		if (c == 'n' || ind == NOTABLE_ARG)
 			_switches[NOTABLE_ARG]++;
+		if (c == 'o' || ind == OPTIONS_ARG) {
+			_switches[OPTIONS_ARG]++;
+			_fields = optarg;
+		}
 		if (c == 'v' || ind == VERBOSE_ARG)
 			_switches[VERBOSE_ARG]++;
 		if (c == 'u' || ind == UUID_ARG) {
@@ -960,6 +1013,11 @@ static int _process_switches(int *argc, char ***argv)
 		return 0;
 	}
 
+	if (_switches[OPTIONS_ARG] && strcmp(_fields, "name")) {
+		fprintf(stderr, "Only -o name is supported so far.\n");
+		return 0;
+	}
+
 	*argv += optind;
 	*argc -= optind;
 	return 1;
@@ -970,7 +1028,7 @@ int main(int argc, char **argv)
 	struct command *c;
 
 	if (!_process_switches(&argc, &argv)) {
-		fprintf(stderr, "Couldn't process command line switches.\n");
+		fprintf(stderr, "Couldn't process command line.\n");
 		exit(1);
 	}
 

tools/lvchange.c

@@ -94,6 +94,12 @@ static int lvchange_availability(struct cmd_context *cmd,
 			return 0;
 		}
 	} else {
+		if (lockingfailed() && (lv->vg->status & CLUSTERED)) {
+                	log_verbose("Locking failed: ignoring clustered "
+				    "logical volume %s", lv->name);
+                	return 0;
+        	}
+
 		if (lv_is_origin(lv) || (activate == CHANGE_AE)) {
 			log_verbose("Activating logical volume \"%s\" "
 				    "exclusively", lv->name);
@@ -361,6 +367,7 @@ static int lvchange_tag(struct cmd_context *cmd, struct logical_volume *lv,
 
 	return 1;
 }
+
 static int lvchange_single(struct cmd_context *cmd, struct logical_volume *lv,
 			   void *handle)
 {

tools/lvcreate.c

@@ -609,7 +609,7 @@ static int _lvcreate(struct cmd_context *cmd, struct lvcreate_params *lp)
 			return 0;
 		}
 
-		if (!vg_add_snapshot(org, lv, 1, NULL, lv->le_count,
+		if (!vg_add_snapshot(org, lv, 1, NULL, org->le_count,
 				     lp->chunk_size)) {
 			log_err("Couldn't create snapshot.");
 			return 0;

tools/lvm-static.c

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.   
+ * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
+ *
+ * This file is part of LVM2.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "lvm2cmdline.h"
+
+int main(int argc, char **argv)
+{
+	return lvm2_main(argc, argv, 1);
+}

tools/lvm.c

@@ -17,5 +17,5 @@
 
 int main(int argc, char **argv)
 {
-	return lvm2_main(argc, argv);
+	return lvm2_main(argc, argv, 0);
 }

tools/lvm2cmdline.h

@@ -16,6 +16,6 @@
 #ifndef _LVM_CMDLINE_H
 #define _LVM_CMDLINE_H
 
-int lvm2_main(int argc, char **argv);
+int lvm2_main(int argc, char **argv, int is_static);
 
 #endif

tools/lvmcmdline.c

@@ -753,6 +753,7 @@ static void _apply_settings(struct cmd_context *cmd)
 	init_debug(cmd->current_settings.debug);
 	init_verbose(cmd->current_settings.verbose + VERBOSE_BASE_LEVEL);
 	init_test(cmd->current_settings.test);
+	init_full_scan_done(0);
 
 	init_msg_prefix(cmd->default_settings.msg_prefix);
 	init_cmd_name(cmd->default_settings.cmd_name);
@@ -978,6 +979,7 @@ static void _close_stray_fds(void)
 {
 	struct rlimit rlim;
 	int fd;
+	int suppress_warnings = 0;
 
 	if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
 		fprintf(stderr, "getrlimit(RLIMIT_NOFILE) failed: %s\n",
@@ -985,8 +987,13 @@ static void _close_stray_fds(void)
 		return;
 	}
 
+	if (getenv("LVM_SUPPRESS_FD_WARNINGS"))
+		suppress_warnings = 1;
+
 	for (fd = 3; fd < rlim.rlim_cur; fd++) {
-		if (!close(fd))
+		if (suppress_warnings)
+			close(fd);
+		else if (!close(fd))
 			fprintf(stderr, "File descriptor %d left open\n", fd);
 		else if (errno != EBADF)
 			fprintf(stderr, "Close failed on stray file "
@@ -998,8 +1005,6 @@ static struct cmd_context *_init_lvm(void)
 {
 	struct cmd_context *cmd;
 
-	_close_stray_fds();
-
 	if (!(cmd = create_toolcontext(&the_args[0]))) {
 		stack;
 		return NULL;
@@ -1411,16 +1416,14 @@ static void _exec_lvm1_command(struct cmd_context *cmd, int argc, char **argv)
 	log_sys_error("execvp", path);
 }
 
-int lvm2_main(int argc, char **argv)
+int lvm2_main(int argc, char **argv, int is_static)
 {
 	char *namebase, *base;
 	int ret, alias = 0;
 	struct cmd_context *cmd;
 
-	if (!(cmd = _init_lvm()))
-		return -1;
+	_close_stray_fds();
 
-	cmd->argv = argv;
 	namebase = strdup(argv[0]);
 	base = basename(namebase);
 	while (*base == '/')
@@ -1428,8 +1431,21 @@ int lvm2_main(int argc, char **argv)
 	if (strcmp(base, "lvm") && strcmp(base, "lvm.static") &&
 	    strcmp(base, "initrd-lvm"))
 		alias = 1;
+
+	if (is_static && strcmp(base, "lvm.static") && 
+	    path_exists(LVM_SHARED_PATH) &&
+	    !getenv("LVM_DID_EXEC")) {
+		setenv("LVM_DID_EXEC", base, 1);
+		execvp(LVM_SHARED_PATH, argv);
+		unsetenv("LVM_DID_EXEC");
+	}
+
 	free(namebase);
 
+	if (!(cmd = _init_lvm()))
+		return -1;
+
+	cmd->argv = argv;
 	_register_commands();
 
 	if (_lvm1_fallback(cmd)) {

tools/lvmdiskscan.c

@@ -34,7 +34,7 @@ static int _get_max_dev_name_len(struct dev_filter *filter)
 	struct dev_iter *iter;
 	struct device *dev;
 
-	if (!(iter = dev_iter_create(filter))) {
+	if (!(iter = dev_iter_create(filter, 1))) {
 		log_error("dev_iter_create failed");
 		return 0;
 	}
@@ -103,7 +103,7 @@ int lvmdiskscan(struct cmd_context *cmd, int argc, char **argv)
 
 	max_len = _get_max_dev_name_len(cmd->filter);
 
-	if (!(iter = dev_iter_create(cmd->filter))) {
+	if (!(iter = dev_iter_create(cmd->filter, 0))) {
 		log_error("dev_iter_create failed");
 		return ECMD_FAILED;
 	}

tools/polldaemon.c

@@ -138,8 +138,11 @@ static int _wait_for_single_mirror(struct cmd_context *cmd, const char *name,
 	while (!finished) {
 		/* FIXME Also needed in vg/lvchange -ay? */
 		/* FIXME Use alarm for regular intervals instead */
-		if (parms->interval && !parms->aborting)
+		if (parms->interval && !parms->aborting) {
 			sleep(parms->interval);
+			/* Devices might have changed while we slept */
+			init_full_scan_done(0);
+		}
 
 		/* Locks the (possibly renamed) VG again */
 		if (!(vg = parms->poll_fns->get_copy_vg(cmd, name))) {

tools/pvcreate.c

@@ -63,10 +63,10 @@ static int pvcreate_check(struct cmd_context *cmd, const char *name)
 	/* Is there an md superblock here? */
 	if (!dev && md_filtering()) {
 		unlock_vg(cmd, "");
-		log_verbose("Wiping cache of LVM-capable devices");
+
 		persistent_filter_wipe(cmd->filter);
-		log_verbose("Wiping internal cache");
 		lvmcache_destroy();
+
 		init_md_filtering(0);
 		if (!lock_vol(cmd, "", LCK_VG_WRITE)) {
 			log_error("Can't get lock for orphan PVs");

tools/pvdisplay.c

@@ -64,6 +64,7 @@ int pvdisplay(struct cmd_context *cmd, int argc, char **argv)
 		}
 		return pvs(cmd, argc, argv);
 	} else if (arg_count(cmd, aligned_ARG) ||
+		   arg_count(cmd, all_ARG) ||
 		   arg_count(cmd, noheadings_ARG) ||
 		   arg_count(cmd, options_ARG) ||
 		   arg_count(cmd, separator_ARG) ||

tools/pvscan.c

@@ -123,10 +123,7 @@ int pvscan(struct cmd_context *cmd, int argc, char **argv)
 			  arg_count(cmd, exported_ARG) ?
 			  "of exported volume group(s)" : "in no volume group");
 
-	log_verbose("Wiping cache of LVM-capable devices");
 	persistent_filter_wipe(cmd->filter);
-
-	log_verbose("Wiping internal cache");
 	lvmcache_destroy();
 
 	log_verbose("Walking through all physical volumes");

tools/toollib.c

@@ -463,7 +463,7 @@ static int _process_all_devs(struct cmd_context *cmd, void *handle,
 	int ret_max = 0;
 	int ret = 0;
 
-	if (!(iter = dev_iter_create(cmd->filter))) {
+	if (!(iter = dev_iter_create(cmd->filter, 1))) {
 		log_error("dev_iter creation failed");
 		return ECMD_FAILED;
 	}

tools/tools.h

@@ -135,7 +135,7 @@ int alloc_arg(struct cmd_context *cmd, struct arg *a);
 char yes_no_prompt(const char *prompt, ...);
 
 /* we use the enums to access the switches */
-static inline const unsigned int arg_count(struct cmd_context *cmd, int a)
+static inline unsigned int arg_count(struct cmd_context *cmd, int a)
 {
 	return cmd->args[a].count;
 }
@@ -151,25 +151,25 @@ static inline const char *arg_str_value(struct cmd_context *cmd, int a,
 	return arg_count(cmd, a) ? cmd->args[a].value : def;
 }
 
-static inline const int32_t arg_int_value(struct cmd_context *cmd, int a,
+static inline int32_t arg_int_value(struct cmd_context *cmd, int a,
 					  const int32_t def)
 {
 	return arg_count(cmd, a) ? cmd->args[a].i_value : def;
 }
 
-static inline const uint32_t arg_uint_value(struct cmd_context *cmd, int a,
+static inline uint32_t arg_uint_value(struct cmd_context *cmd, int a,
 					    const uint32_t def)
 {
 	return arg_count(cmd, a) ? cmd->args[a].ui_value : def;
 }
 
-static inline const int64_t arg_int64_value(struct cmd_context *cmd, int a,
+static inline int64_t arg_int64_value(struct cmd_context *cmd, int a,
 					    const uint64_t def)
 {
 	return arg_count(cmd, a) ? cmd->args[a].i64_value : def;
 }
 
-static inline const uint64_t arg_uint64_value(struct cmd_context *cmd, int a,
+static inline uint64_t arg_uint64_value(struct cmd_context *cmd, int a,
 					      const uint64_t def)
 {
 	return arg_count(cmd, a) ? cmd->args[a].ui64_value : def;
@@ -181,13 +181,13 @@ static inline const void *arg_ptr_value(struct cmd_context *cmd, int a,
 	return arg_count(cmd, a) ? cmd->args[a].ptr : def;
 }
 
-static inline const sign_t arg_sign_value(struct cmd_context *cmd, int a,
+static inline sign_t arg_sign_value(struct cmd_context *cmd, int a,
 					  const sign_t def)
 {
 	return arg_count(cmd, a) ? cmd->args[a].sign : def;
 }
 
-static inline const int arg_count_increment(struct cmd_context *cmd, int a)
+static inline int arg_count_increment(struct cmd_context *cmd, int a)
 {
 	return cmd->args[a].count++;
 }

tools/vgchange.c

@@ -83,6 +83,12 @@ static int _vgchange_available(struct cmd_context *cmd, struct volume_group *vg)
 		return ECMD_FAILED;
 	}
 
+	if (activate && lockingfailed() && (vg->status & CLUSTERED)) {
+		log_error("Locking inactive: ignoring clustered "
+			  "volume group %s", vg->name);
+		return ECMD_FAILED;
+	}
+
 	if (activate && (active = lvs_in_vg_activated(vg)))
 		log_verbose("%d logical volume(s) in volume group \"%s\" "
 			    "already active", active, vg->name);
@@ -168,6 +174,41 @@ static int _vgchange_resizeable(struct cmd_context *cmd,
 	return ECMD_PROCESSED;
 }
 
+static int _vgchange_clustered(struct cmd_context *cmd,
+			       struct volume_group *vg)
+{
+	int clustered = !strcmp(arg_str_value(cmd, clustered_ARG, "n"), "y");
+
+	if (clustered && (vg->status & CLUSTERED)) {
+		log_error("Volume group \"%s\" is already clustered",
+			  vg->name);
+		return ECMD_FAILED;
+	}
+
+	if (!clustered && !(vg->status & CLUSTERED)) {
+		log_error("Volume group \"%s\" is already not clustered",
+			  vg->name);
+		return ECMD_FAILED;
+	}
+
+	if (!archive(vg))
+		return ECMD_FAILED;
+
+	if (clustered)
+		vg->status |= CLUSTERED;
+	else
+		vg->status &= ~CLUSTERED;
+
+	if (!vg_write(vg) || !vg_commit(vg))
+		return ECMD_FAILED;
+
+	backup(vg);
+
+	log_print("Volume group \"%s\" successfully changed", vg->name);
+
+	return ECMD_PROCESSED;
+}
+
 static int _vgchange_logicalvolume(struct cmd_context *cmd,
 				   struct volume_group *vg)
 {
@@ -334,6 +375,9 @@ static int vgchange_single(struct cmd_context *cmd, const char *vg_name,
 	else if (arg_count(cmd, alloc_ARG))
 		r = _vgchange_alloc(cmd, vg);
 
+	else if (arg_count(cmd, clustered_ARG))
+		r = _vgchange_clustered(cmd, vg);
+
 	return r;
 }
 
@@ -343,8 +387,8 @@ int vgchange(struct cmd_context *cmd, int argc, char **argv)
 	    (arg_count(cmd, available_ARG) + arg_count(cmd, logicalvolume_ARG) +
 	     arg_count(cmd, resizeable_ARG) + arg_count(cmd, deltag_ARG) +
 	     arg_count(cmd, addtag_ARG) + arg_count(cmd, uuid_ARG) +
-	     arg_count(cmd, alloc_ARG))) {
-		log_error("One of -a, -l, -x, --alloc, --addtag, --deltag "
+	     arg_count(cmd, clustered_ARG) + arg_count(cmd, alloc_ARG))) {
+		log_error("One of -a, -c, -l, -x, --alloc, --addtag, --deltag "
 			  "or --uuid required");
 		return EINVALID_CMD_LINE;
 	}
@@ -353,9 +397,9 @@ int vgchange(struct cmd_context *cmd, int argc, char **argv)
 	if (arg_count(cmd, available_ARG) + arg_count(cmd, logicalvolume_ARG) +
 	    arg_count(cmd, resizeable_ARG) + arg_count(cmd, deltag_ARG) +
 	    arg_count(cmd, addtag_ARG) + arg_count(cmd, alloc_ARG) +
-	    arg_count(cmd, uuid_ARG) > 1) {
-		log_error("Only one of -a, -l, -x, --alloc, --addtag, --deltag "
-		          "or --uuid allowed");
+	    arg_count(cmd, uuid_ARG) + arg_count(cmd, clustered_ARG) > 1) {
+		log_error("Only one of -a, -c, -l, -x, --uuid, --alloc, "
+			  "--addtag or --deltag allowed");
 		return EINVALID_CMD_LINE;
 	}
 

tools/vgcreate.c

@@ -26,6 +26,7 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
 	struct volume_group *vg;
 	const char *tag;
 	alloc_policy_t alloc;
+	int clustered;
 
 	if (!argc) {
 		log_error("Please provide volume group name and "
@@ -130,6 +131,17 @@ int vgcreate(struct cmd_context *cmd, int argc, char **argv)
 		}
 	}
 
+	if (arg_count(cmd, clustered_ARG))
+        	clustered = !strcmp(arg_str_value(cmd, clustered_ARG, "n"), "y");
+	else
+		/* Default depends on current locking type */
+		clustered = locking_is_clustered();
+
+	if (clustered)
+		vg->status |= CLUSTERED;
+	else
+		vg->status &= ~CLUSTERED;
+
 	if (!lock_vol(cmd, "", LCK_VG_WRITE)) {
 		log_error("Can't get lock for orphan PVs");
 		return ECMD_FAILED;

tools/vgscan.c

@@ -48,10 +48,7 @@ int vgscan(struct cmd_context *cmd, int argc, char **argv)
 		return EINVALID_CMD_LINE;
 	}
 
-	log_verbose("Wiping cache of LVM-capable devices");
 	persistent_filter_wipe(cmd->filter);
-
-	log_verbose("Wiping internal cache");
 	lvmcache_destroy();
 
 	log_print("Reading all physical volumes.  This may take a while...");