Pre-release.

Use set_lv() and dev_set() to wipe sections of devices.
Add mirror_in_sync() flag to avoid unnecessary resync on activation.

WHATS_NEW

@@ -1,5 +1,16 @@
 Version 2.02.06 -
 =================================
+  Add --nosync to lvcreate with LV flag NOTSYNCED.
+  Use mirror's uuid for a core log.
+  Add mirror log fault-handling policy.
+  Improve mirror warning messages and tidy dmeventd syslog output.
+  Propagate nosync flag around cluster.
+  Allow vgreduce to handle mirror log failures.
+  Add --corelog to lvcreate and lvconvert.
+  Create a log header for replacement in-sync mirror log.
+  Use set_lv() and dev_set() to wipe sections of devices.
+  Add mirror_in_sync() flag to avoid unnecessary resync on activation.
+  Add mirror_library description to example.conf.
   Fix uuid_from_num() buffer overrun.
   Make SIZE_SHORT the default for display_size().
   Fix some memory leaks in error paths found by coverity.

WHATS_NEW_DM

@@ -1,3 +1,8 @@
+Version 1.02.07 - 11 May 2006
+=============================
+  Add DM_CORELOG flag to dm_tree_node_add_mirror_target().
+  Avoid a dmeventd compiler warning.
+
 Version 1.02.06 - 10 May 2006
 =============================
   Move DEFS into configure.h.

daemons/clvmd/lvm-functions.c

@@ -306,6 +306,9 @@ int do_lock_lv(unsigned char command, unsigned char lock_flags, char *resource)
 	if (lock_flags & LCK_PARTIAL_MODE)
 		init_partial(1);
 
+	if (lock_flags & LCK_MIRROR_NOSYNC_MODE)
+		init_mirror_in_sync(1);
+
 	switch (command) {
 	case LCK_LV_EXCLUSIVE:
 		status = do_activate_lv(resource, lock_flags, LKM_EXMODE);

daemons/dmeventd/dmeventd.c

@@ -1213,14 +1213,14 @@ static void sig_alarm(int signum)
 /* Init thread signal handling. */
 static void init_thread_signals(void)
 {
-	sigset_t sigset;
+	sigset_t my_sigset;
 	struct sigaction act;
 	
 	memset(&act, 0, sizeof(act));
 	act.sa_handler = sig_alarm;
 	sigaction(SIGALRM, &act, NULL);
-	sigfillset(&sigset);
-	pthread_sigmask(SIG_BLOCK, &sigset, NULL);
+	sigfillset(&my_sigset);
+	pthread_sigmask(SIG_BLOCK, &my_sigset, NULL);
 }
 
 static int daemonize(void)

daemons/dmeventd/plugins/mirror/dmeventd_mirror.c

@@ -99,10 +99,13 @@ static int _get_mirror_event(char *params)
 	return rtn;
 }
 
-static void _temporary_log_fn(int level, const char *file, int line, const char *format)
+static void _temporary_log_fn(int level, const char *file,
+			      int line, const char *format)
 {
-	return;
-	syslog(LOG_DEBUG, "%s", format);
+	if (!strncmp(format, "WARNING: ", 9) && (level < 5))
+		syslog(LOG_CRIT, "%s", format);
+	else
+		syslog(LOG_DEBUG, "%s", format);
 }
 
 static int _remove_failed_devices(const char *device)
@@ -205,7 +208,7 @@ void process_event(const char *device, enum dm_event_type event)
 
 int register_device(const char *device)
 {
-	syslog(LOG_INFO, "Monitoring %s for events\n", device);
+	syslog(LOG_INFO, "Monitoring mirror device, %s for events\n", device);
 
 	/*
 	 * Need some space for allocations.  1024 should be more
@@ -224,8 +227,6 @@ int register_device(const char *device)
 
 int unregister_device(const char *device)
 {
-        syslog(LOG_INFO, "Stopped monitoring %s for events\n", device);
-
 	if (!(--register_count)) {
 		dm_pool_destroy(mem_pool);
 		mem_pool = NULL;

dmeventd/mirror/dmeventd_mirror.c

@@ -99,10 +99,13 @@ static int _get_mirror_event(char *params)
 	return rtn;
 }
 
-static void _temporary_log_fn(int level, const char *file, int line, const char *format)
+static void _temporary_log_fn(int level, const char *file,
+			      int line, const char *format)
 {
-	return;
-	syslog(LOG_DEBUG, "%s", format);
+	if (!strncmp(format, "WARNING: ", 9) && (level < 5))
+		syslog(LOG_CRIT, "%s", format);
+	else
+		syslog(LOG_DEBUG, "%s", format);
 }
 
 static int _remove_failed_devices(const char *device)
@@ -205,7 +208,7 @@ void process_event(const char *device, enum dm_event_type event)
 
 int register_device(const char *device)
 {
-	syslog(LOG_INFO, "Monitoring %s for events\n", device);
+	syslog(LOG_INFO, "Monitoring mirror device, %s for events\n", device);
 
 	/*
 	 * Need some space for allocations.  1024 should be more
@@ -224,8 +227,6 @@ int register_device(const char *device)
 
 int unregister_device(const char *device)
 {
-        syslog(LOG_INFO, "Stopped monitoring %s for events\n", device);
-
 	if (!(--register_count)) {
 		dm_pool_destroy(mem_pool);
 		mem_pool = NULL;

doc/example.conf

@@ -232,9 +232,6 @@ activation {
     # target or make it return zeros.
     missing_stripe_filler = "/dev/ioerror"
 
-    # Size (in KB) of each copy operation when mirroring
-    mirror_region_size = 512
-
     # How much stack (in KB) to reserve for use while devices suspended
     reserved_stack = 256
 
@@ -251,6 +248,54 @@ activation {
     #   "@*" matches if any tag defined on the host is also set in the LV or VG
     #
     # volume_list = [ "vg1", "vg2/lvol1", "@tag1", "@*" ]
+
+    # Size (in KB) of each copy operation when mirroring
+    mirror_region_size = 512
+
+    # 'mirror_image_fault_policy' and 'mirror_log_fault_policy' define
+    # how a device failure affecting a mirror is handled.
+    # A mirror is composed of mirror images (copies) and a log.
+    # A disk log ensures that a mirror does not need to be re-synced
+    # (all copies made the same) every time a machine reboots or crashes.
+    #
+    # In the event of a failure, the specified policy will be used to
+    # determine what happens:
+    #
+    # "remove" - Simply remove the faulty device and run without it.  If
+    #            the log device fails, the mirror would convert to using
+    #            an in-memory log.  This means the mirror will not
+    #            remember its sync status across crashes/reboots and
+    #            the entire mirror will be re-synced.  If a
+    #            mirror image fails, the mirror will convert to a
+    #            non-mirrored device if there is only one remaining good
+    #            copy.
+    #
+    # "allocate" - Remove the faulty device and try to allocate space on
+    #            a new device to be a replacement for the failed device.
+    #            Using this policy for the log is fast and maintains the
+    #            ability to remember sync state through crashes/reboots.
+    #            Using this policy for a mirror device is slow, as it
+    #            requires the mirror to resynchronize the devices, but it
+    #            will preserve the mirror characteristic of the device.
+    #            This policy acts like "remove" if no suitable device and
+    #            space can be allocated for the replacement.
+    #            Currently this is not implemented properly and behaves
+    #            similarly to:
+    #
+    # "allocate_anywhere" - Operates like "allocate", but it does not
+    #            require that the new space being allocated be on a
+    #            device is not part of the mirror.  For a log device
+    #            failure, this could mean that the log is allocated on
+    #            the same device as a mirror device.  For a mirror
+    #            device, this could mean that the mirror device is
+    #            allocated on the same device as another mirror device.
+    #            This policy would not be wise for mirror devices
+    #            because it would break the redundant nature of the
+    #            mirror.  This policy acts like "remove" if no suitable
+    #            device and space can be allocated for the replacement.
+
+    mirror_log_fault_policy = "allocate"
+    mirror_dev_fault_policy = "remove"
 }
 
 
@@ -291,7 +336,13 @@ activation {
 
 # Event daemon
 #
-#dmeventd {
+# dmeventd {
+    # mirror_library is the library used when monitoring a mirror device.
+    #
+    # "libdevmapper-event-lvm2mirror.so" attempts to recover from failures.
+    # It removes failed devices from a volume group and reconfigures a
+    # mirror as necessary.
+    #
     # mirror_library = "libdevmapper-event-lvm2mirror.so"
 #}
 

lib/activate/activate.c

@@ -862,28 +862,16 @@ int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
  * Does PV use VG somewhere in its construction?
  * Returns 1 on failure.
  */
-int pv_uses_vg(struct cmd_context *cmd, struct physical_volume *pv,
+int pv_uses_vg(struct physical_volume *pv,
                struct volume_group *vg)
 {
-	struct dev_manager *dm;
-	int r;
-
 	if (!activation())
 		return 0;
 
 	if (!dm_is_dm_major(MAJOR(pv->dev->dev)))
 		return 0;
 
-	if (!(dm = dev_manager_create(cmd, vg->name))) {
-		stack;
-		return 1;
-	}
-
-	r = dev_manager_device_uses_vg(dm, pv->dev, vg);
-
-	dev_manager_destroy(dm);
-
-	return r;
+	return dev_manager_device_uses_vg(pv->dev, vg);
 }
 
 void activation_exit(void)

lib/activate/activate.h

@@ -83,7 +83,7 @@ int lvs_in_vg_opened(struct volume_group *vg);
 /*
  * Returns 1 if PV has a dependency tree that uses anything in VG.
  */
-int pv_uses_vg(struct cmd_context *cmd, struct physical_volume *pv,
+int pv_uses_vg(struct physical_volume *pv,
 	       struct volume_group *vg);
 
 #endif

lib/activate/dev_manager.c

@@ -679,7 +679,7 @@ int add_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 		    (seg_type(seg, s) == AREA_LV && !seg_lv(seg, s)))
 			dm_tree_node_add_target_area(node,
 							dm->stripe_filler,
-							NULL, 0);
+							NULL, UINT64_C(0));
 		else if (seg_type(seg, s) == AREA_PV)
 			dm_tree_node_add_target_area(node,
 							dev_name(seg_dev(seg, s)),
@@ -704,7 +704,6 @@ int add_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 }
 
 static int _add_origin_target_to_dtree(struct dev_manager *dm,
-					 struct dm_tree *dtree,
 					 struct dm_tree_node *dnode,
 					 struct logical_volume *lv)
 {
@@ -720,7 +719,6 @@ static int _add_origin_target_to_dtree(struct dev_manager *dm,
 }
 
 static int _add_snapshot_target_to_dtree(struct dev_manager *dm,
-					   struct dm_tree *dtree,
 					   struct dm_tree_node *dnode,
 					   struct logical_volume *lv)
 {
@@ -749,7 +747,6 @@ static int _add_snapshot_target_to_dtree(struct dev_manager *dm,
 }
 
 static int _add_target_to_dtree(struct dev_manager *dm,
-				  struct dm_tree *dtree,
 				  struct dm_tree_node *dnode,
 				  struct lv_segment *seg)
 {
@@ -814,12 +811,12 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
 
 	/* Now we've added its dependencies, we can add the target itself */
 	if (lv_is_origin(seg->lv) && !layer) {
-		if (!_add_origin_target_to_dtree(dm, dtree, dnode, seg->lv))
+		if (!_add_origin_target_to_dtree(dm, dnode, seg->lv))
 			return_0;
 	} else if (lv_is_cow(seg->lv) && !layer) {
-		if (!_add_snapshot_target_to_dtree(dm, dtree, dnode, seg->lv))
+		if (!_add_snapshot_target_to_dtree(dm, dnode, seg->lv))
 			return_0;
-	} else if (!_add_target_to_dtree(dm, dtree, dnode, seg))
+	} else if (!_add_target_to_dtree(dm, dnode, seg))
 		return_0;
 
 	if (lv_is_origin(seg->lv) && !layer)
@@ -864,10 +861,10 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 	 * Major/minor settings only apply to the visible layer.
 	 */
 	if (!(dnode = dm_tree_add_new_dev(dtree, name, dlid,
-					     layer ? lv->major : 0,
-					     layer ? lv->minor : 0,
+					     layer ? (uint32_t) lv->major : UINT32_C(0),
+					     layer ? (uint32_t) lv->minor : UINT32_C(0),
 					     _read_only_lv(lv),
-					     lv->vg->status & PRECOMMITTED,
+					     (lv->vg->status & PRECOMMITTED) ? 1 : 0,
 					     lvlayer)))
 		return_0;
 
@@ -921,7 +918,7 @@ static int _create_lv_symlinks(struct dev_manager *dm, struct dm_tree_node *root
 	return r;
 }
 
-static int _clean_tree(struct dev_manager *dm, struct logical_volume *lv, struct dm_tree_node *root)
+static int _clean_tree(struct dev_manager *dm, struct dm_tree_node *root)
 {
 	void *handle = NULL;
 	struct dm_tree_node *child;
@@ -973,7 +970,7 @@ static int _tree_action(struct dev_manager *dm, struct logical_volume *lv, actio
 	switch(action) {
 	case CLEAN:
 		/* Deactivate any unused non-toplevel nodes */
-		if (!_clean_tree(dm, lv, root))
+		if (!_clean_tree(dm, root))
 			goto_out;
 		break;
 	case DEACTIVATE:
@@ -1056,7 +1053,7 @@ int dev_manager_suspend(struct dev_manager *dm, struct logical_volume *lv)
  * Does device use VG somewhere in its construction?
  * Returns 1 if uncertain.
  */
-int dev_manager_device_uses_vg(struct dev_manager *dm, struct device *dev,
+int dev_manager_device_uses_vg(struct device *dev,
 			       struct volume_group *vg)
 {
 	struct dm_tree *dtree;
@@ -1069,7 +1066,7 @@ int dev_manager_device_uses_vg(struct dev_manager *dm, struct device *dev,
 		return r;
 	}
 
-	if (!dm_tree_add_dev(dtree, MAJOR(dev->dev), MINOR(dev->dev))) {
+	if (!dm_tree_add_dev(dtree, (uint32_t) MAJOR(dev->dev), (uint32_t) MINOR(dev->dev))) {
 		log_error("Failed to add device %s (%" PRIu32 ":%" PRIu32") to dtree",
 			  dev_name(dev), (uint32_t) MAJOR(dev->dev), (uint32_t) MINOR(dev->dev));
 		goto out;

lib/activate/dev_manager.h

@@ -59,7 +59,7 @@ int dev_manager_lv_rmnodes(const struct logical_volume *lv);
  */
 int dev_manager_execute(struct dev_manager *dm);
 
-int dev_manager_device_uses_vg(struct dev_manager *dm, struct device *dev,
+int dev_manager_device_uses_vg(struct device *dev,
 			       struct volume_group *vg);
 
 #endif

lib/cache/lvmcache.c

@@ -50,7 +50,7 @@ int lvmcache_init(void)
 	return 1;
 }
 
-void lvmcache_lock_vgname(const char *vgname, int read_only)
+void lvmcache_lock_vgname(const char *vgname, int read_only __attribute((unused)))
 {
 	if (!_lock_hash && !lvmcache_init()) {
 		log_error("Internal cache initialisation failed");
@@ -857,7 +857,7 @@ static void _lvmcache_destroy_vgnamelist(struct lvmcache_vginfo *vginfo)
 	} while ((vginfo = next));
 }
 
-static void _lvmcache_destroy_lockname(int present)
+static void _lvmcache_destroy_lockname(int present __attribute((unused)))
 {
 	/* Nothing to do */
 }

lib/config/defaults.h

@@ -34,6 +34,8 @@
 #define DEFAULT_LOCK_DIR "/var/lock/lvm"
 #define DEFAULT_LOCKING_LIB "lvm2_locking.so"
 
+#define DEFAULT_MIRROR_LOG_FAULT_POLICY "allocate"
+#define DEFAULT_MIRROR_DEV_FAULT_POLICY "remove"
 #define DEFAULT_DMEVENTD_MIRROR_LIB "libdevmapper-event-lvm2mirror.so"
 
 #define DEFAULT_UMASK 0077

lib/device/dev-io.c

@@ -602,7 +602,7 @@ int dev_write(struct device *dev, uint64_t offset, size_t len, void *buffer)
 	return _aligned_io(&where, buffer, 1);
 }
 
-int dev_zero(struct device *dev, uint64_t offset, size_t len)
+int dev_set(struct device *dev, uint64_t offset, size_t len, int value)
 {
 	size_t s;
 	char buffer[4096];
@@ -620,7 +620,7 @@ int dev_zero(struct device *dev, uint64_t offset, size_t len)
 			  " sectors", dev_name(dev), offset >> SECTOR_SHIFT,
 			  len >> SECTOR_SHIFT);
 
-	memset(buffer, 0, sizeof(buffer));
+	memset(buffer, value, sizeof(buffer));
 	while (1) {
 		s = len > sizeof(buffer) ? sizeof(buffer) : len;
 		if (!dev_write(dev, offset, s, buffer))

lib/device/device.c

@@ -62,7 +62,7 @@ static int _has_partition_table(struct device *dev)
 		return -1;
 	}
 
-	if (!dev_read(dev, 0, sizeof(buf), &buf)) {
+	if (!dev_read(dev, UINT64_C(0), sizeof(buf), &buf)) {
 		stack;
 		goto out;
 	}

lib/device/device.h

@@ -80,7 +80,7 @@ const char *dev_name(const struct device *dev);
 int dev_read(struct device *dev, uint64_t offset, size_t len, void *buffer);
 int dev_write(struct device *dev, uint64_t offset, size_t len, void *buffer);
 int dev_append(struct device *dev, size_t len, void *buffer);
-int dev_zero(struct device *dev, uint64_t offset, size_t len);
+int dev_set(struct device *dev, uint64_t offset, size_t len, int value);
 void dev_flush(struct device *dev);
 
 struct device *dev_create_file(const char *filename, struct device *dev,

lib/error/errseg.c

@@ -38,11 +38,13 @@ static int _errseg_merge_segments(struct lv_segment *seg1, struct lv_segment *se
 }
 
 #ifdef DEVMAPPER_SUPPORT
-static int _errseg_add_target_line(struct dev_manager *dm, struct dm_pool *mem,
-				struct config_tree *cft, void **target_state,
-				struct lv_segment *seg,
+static int _errseg_add_target_line(struct dev_manager *dm __attribute((unused)),
+				struct dm_pool *mem __attribute((unused)),
+				struct config_tree *cft __attribute((unused)),
+				void **target_state __attribute((unused)),
+				struct lv_segment *seg __attribute((unused)),
 				struct dm_tree_node *node, uint64_t len,
-				uint32_t *pvmove_mirror_count)
+				uint32_t *pvmove_mirror_count __attribute((unused)))
 {
 	return dm_tree_node_add_error_target(node, len);
 }
@@ -64,7 +66,7 @@ static int _errseg_target_present(void)
 
 static void _errseg_destroy(const struct segment_type *segtype)
 {
-	dm_free((void *) segtype);
+	dm_free((void *)segtype);
 }
 
 static struct segtype_handler _error_ops = {

lib/format1/disk-rep.c

@@ -576,7 +576,7 @@ static int _write_lvs(struct disk_list *data)
 
 	pos = data->pvd.lv_on_disk.base;
 
-	if (!dev_zero(data->dev, pos, data->pvd.lv_on_disk.size)) {
+	if (!dev_set(data->dev, pos, data->pvd.lv_on_disk.size, 0)) {
 		log_error("Couldn't zero lv area on device '%s'",
 			  dev_name(data->dev));
 		return 0;

lib/format_text/export.c

@@ -183,7 +183,8 @@ static int _out_with_comment_file(struct formatter *f, const char *comment,
 	return 1;
 }
 
-static int _out_with_comment_raw(struct formatter *f, const char *comment,
+static int _out_with_comment_raw(struct formatter *f,
+				 const char *comment __attribute((unused)),
 				 const char *fmt, va_list ap)
 {
 	int n;
@@ -281,7 +282,7 @@ int out_text(struct formatter *f, const char *fmt, ...)
 }
 
 static int _print_header(struct formatter *f,
-			 struct volume_group *vg, const char *desc)
+			 const char *desc)
 {
 	time_t t;
 
@@ -665,7 +666,7 @@ static int _text_vg_export(struct formatter *f,
 	}
 #define fail do {stack; goto out;} while(0)
 
-	if (f->header && !_print_header(f, vg, desc))
+	if (f->header && !_print_header(f, desc))
 		fail;
 
 	if (!out_text(f, "%s {", vg->name))
@@ -688,7 +689,7 @@ static int _text_vg_export(struct formatter *f,
 	if (!out_text(f, "}"))
 		fail;
 
-	if (!f->header && !_print_header(f, vg, desc))
+	if (!f->header && !_print_header(f, desc))
 		fail;
 
 #undef fail

lib/format_text/flags.c

@@ -53,6 +53,7 @@ static struct flag _lv_flags[] = {
 	{VISIBLE_LV, "VISIBLE"},
 	{PVMOVE, "PVMOVE"},
 	{LOCKED, "LOCKED"},
+	{MIRROR_NOTSYNCED, "NOTSYNCED"},
 	{MIRROR_IMAGE, NULL},
 	{MIRROR_LOG, NULL},
 	{MIRRORED, NULL},

lib/format_text/format-text.c

@@ -69,7 +69,8 @@ struct text_context {
  * NOTE: Currently there can be only one vg per text file.
  */
 
-static int _text_vg_setup(struct format_instance *fid, struct volume_group *vg)
+static int _text_vg_setup(struct format_instance *fid __attribute((unused)),
+			  struct volume_group *vg)
 {
 	if (vg->extent_size & (vg->extent_size - 1)) {
 		log_error("Extent size must be power of 2");
@@ -79,7 +80,8 @@ static int _text_vg_setup(struct format_instance *fid, struct volume_group *vg)
 	return 1;
 }
 
-static int _text_lv_setup(struct format_instance *fid, struct logical_volume *lv)
+static int _text_lv_setup(struct format_instance *fid __attribute((unused)),
+			  struct logical_volume *lv)
 {
 /******** FIXME Any LV size restriction? 
 	uint64_t max_size = UINT_MAX;
@@ -1071,9 +1073,9 @@ static int _mda_setup(const struct format_type *fmt,
 		if (!add_mda(fmt, fmt->cmd->mem, mdas, pv->dev, start1,
 			     mda_size1)) return 0;
 
-		if (!dev_zero((struct device *) pv->dev, start1,
-			      (size_t) (mda_size1 >
-					wipe_size ? : mda_size1))) {
+		if (!dev_set((struct device *) pv->dev, start1,
+			     (size_t) (mda_size1 >
+				       wipe_size ? : mda_size1), 0)) {
 			log_error("Failed to wipe new metadata area");
 			return 0;
 		}
@@ -1117,9 +1119,9 @@ static int _mda_setup(const struct format_type *fmt,
 	if (mda_size2) {
 		if (!add_mda(fmt, fmt->cmd->mem, mdas, pv->dev, start2,
 			     mda_size2)) return 0;
-		if (!dev_zero(pv->dev, start2,
-			      (size_t) (mda_size1 >
-					wipe_size ? : mda_size1))) {
+		if (!dev_set(pv->dev, start2,
+			     (size_t) (mda_size1 >
+				       wipe_size ? : mda_size1), 0)) {
 			log_error("Failed to wipe new metadata area");
 			return 0;
 		}
@@ -1202,7 +1204,7 @@ static int _text_pv_write(const struct format_type *fmt, struct physical_volume
 		}
 	}
 	if (!add_da
-	    (fmt, NULL, &info->das, pv->pe_start << SECTOR_SHIFT, UINT64_C(0))) {
+	    (NULL, &info->das, pv->pe_start << SECTOR_SHIFT, UINT64_C(0))) {
 		stack;
 		return 0;
 	}
@@ -1339,7 +1341,7 @@ static int _text_pv_read(const struct format_type *fmt, const char *pv_name,
 	return 1;
 }
 
-static void _text_destroy_instance(struct format_instance *fid)
+static void _text_destroy_instance(struct format_instance *fid __attribute((unused)))
 {
 	return;
 }
@@ -1372,7 +1374,7 @@ static void _text_destroy(const struct format_type *fmt)
 		dm_free(fmt->private);
 	}
 
-	dm_free((void *) fmt);
+	dm_free((void *)fmt);
 }
 
 static struct metadata_area_ops _metadata_text_file_ops = {

lib/format_text/format-text.h

@@ -46,7 +46,7 @@ struct labeller *text_labeller_create(const struct format_type *fmt);
 
 int pvhdr_read(struct device *dev, char *buf);
 
-int add_da(const struct format_type *fmt, struct dm_pool *mem, struct list *das,
+int add_da(struct dm_pool *mem, struct list *das,
 	   uint64_t start, uint64_t size);
 void del_das(struct list *das);
 

lib/format_text/import.c

@@ -129,6 +129,6 @@ struct volume_group *text_vg_import_file(struct format_instance *fid,
 					 const char *file,
 					 time_t *when, char **desc)
 {
-	return text_vg_import_fd(fid, file, NULL, 0, 0, 0, 0, NULL, 0,
+	return text_vg_import_fd(fid, file, NULL, (off_t)0, 0, (off_t)0, 0, NULL, 0,
 				 when, desc);
 }

lib/format_text/text_label.c

@@ -23,7 +23,9 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 
-static int _text_can_handle(struct labeller *l, char *buf, uint64_t sector)
+static int _text_can_handle(struct labeller *l __attribute((unused)),
+			    char *buf,
+			    uint64_t sector __attribute((unused)))
 {
 	struct label_header *lh = (struct label_header *) buf;
 
@@ -86,7 +88,7 @@ static int _text_write(struct label *label, char *buf)
 	return 1;
 }
 
-int add_da(const struct format_type *fmt, struct dm_pool *mem, struct list *das,
+int add_da(struct dm_pool *mem, struct list *das,
 	   uint64_t start, uint64_t size)
 {
 	struct data_area_list *dal;
@@ -179,7 +181,8 @@ void del_mdas(struct list *mdas)
 	}
 }
 
-static int _text_initialise_label(struct labeller *l, struct label *label)
+static int _text_initialise_label(struct labeller *l __attribute((unused)),
+				  struct label *label)
 {
 	strncpy(label->type, LVM2_LABEL, sizeof(label->type));
 
@@ -220,7 +223,7 @@ static int _text_read(struct labeller *l, struct device *dev, char *buf,
 	/* Data areas holding the PEs */
 	dlocn_xl = pvhdr->disk_areas_xl;
 	while ((offset = xlate64(dlocn_xl->offset))) {
-		add_da(info->fmt, NULL, &info->das, offset,
+		add_da(NULL, &info->das, offset,
 		       xlate64(dlocn_xl->size));
 		dlocn_xl++;
 	}
@@ -248,7 +251,8 @@ static int _text_read(struct labeller *l, struct device *dev, char *buf,
 	return 1;
 }
 
-static void _text_destroy_label(struct labeller *l, struct label *label)
+static void _text_destroy_label(struct labeller *l __attribute((unused)),
+				struct label *label)
 {
 	struct lvmcache_info *info = (struct lvmcache_info *) label->info;
 

lib/locking/cluster_locking.c

@@ -333,6 +333,9 @@ static int _lock_for_cluster(unsigned char cmd, unsigned int flags, char *name)
 	if (partial_mode())
 		args[1] |= LCK_PARTIAL_MODE;
 
+	if (mirror_sync())
+		args[1] |= LCK_MIRROR_NOSYNC_MODE;
+
 	/*
 	 * VG locks are just that: locks, and have no side effects
 	 * so we only need to do them on the local node because all

lib/locking/file_locking.c

@@ -105,7 +105,7 @@ static void _remove_ctrl_c_handler()
 		log_sys_error("signal", "_remove_ctrl_c_handler");
 }
 
-static void _trap_ctrl_c(int sig)
+static void _trap_ctrl_c(int sig __attribute((unused)))
 {
 	_remove_ctrl_c_handler();
 	log_error("CTRL-c detected: giving up waiting for lock");

lib/locking/locking.c

@@ -33,7 +33,7 @@ static int _vg_lock_count = 0;		/* Number of locks held */
 static int _vg_write_lock_held = 0;	/* VG write lock held? */
 static int _signals_blocked = 0;
 
-static void _block_signals(int flags)
+static void _block_signals(int flags __attribute((unused)))
 {
 	sigset_t set;
 

lib/locking/locking.h

@@ -74,6 +74,7 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
  * Additional lock bits for cluster communication
  */
 #define LCK_PARTIAL_MODE	0x00000001	/* Running in partial mode */
+#define LCK_MIRROR_NOSYNC_MODE	0x00000002	/* Mirrors don't require sync */
 
 /*
  * Common combinations

lib/log/log.c

@@ -45,6 +45,7 @@ static int _security_level = SECURITY_LEVEL;
 static char _cmd_name[30] = "";
 static char _msg_prefix[30] = "  ";
 static int _already_logging = 0;
+static int _mirror_in_sync = 0;
 
 static lvm2_log_fn_t _lvm2_log_fn = NULL;
 
@@ -175,6 +176,11 @@ void init_security_level(int level)
 	_security_level = level;
 }
 
+void init_mirror_in_sync(int in_sync)
+{
+	_mirror_in_sync = in_sync;
+}
+
 void init_cmd_name(int status)
 {
 	_log_cmd_name = status;
@@ -239,6 +245,11 @@ int security_level()
 	return _security_level;
 }
 
+int mirror_in_sync(void)
+{
+	return _mirror_in_sync;
+}
+
 void init_debug(int level)
 {
 	_debug_level = level;

lib/log/log.h

@@ -73,6 +73,7 @@ void init_indent(int indent);
 void init_ignorelockingfailure(int level);
 void init_lockingfailed(int level);
 void init_security_level(int level);
+void init_mirror_in_sync(int in_sync);
 
 void set_cmd_name(const char *cmd_name);
 
@@ -85,6 +86,7 @@ int debug_level(void);
 int ignorelockingfailure(void);
 int lockingfailed(void);
 int security_level(void);
+int mirror_in_sync(void);
 
 /* Suppress messages to stdout/stderr (1) or everywhere (2) */
 /* Returns previous setting */

lib/metadata/lv_manip.c

@@ -498,7 +498,7 @@ static int _setup_alloced_segment(struct logical_volume *lv, uint32_t status,
 				  struct physical_volume *mirrored_pv,
 				  uint32_t mirrored_pe,
 				  uint32_t region_size,
-				  struct logical_volume *log_lv)
+				  struct logical_volume *log_lv __attribute((unused)))
 {
 	uint32_t s, extents, area_multiple, extra_areas = 0;
 	struct lv_segment *seg;
@@ -1102,7 +1102,7 @@ int lv_add_mirror_segment(struct alloc_handle *ah,
 	struct lv_segment *seg;
 	uint32_t m;
 
-	if (list_empty(&log_lv->segments)) {
+	if (log_lv && list_empty(&log_lv->segments)) {
 		log_error("Log LV %s is empty.", log_lv->name);
 		return 0;
 	}

lib/metadata/metadata.c

@@ -60,7 +60,7 @@ static int _add_pv_to_vg(struct format_instance *fid, struct volume_group *vg,
 	}
 
 	/* Ensure PV doesn't depend on another PV already in the VG */
-	if (pv_uses_vg(fid->fmt->cmd, pv, vg)) {
+	if (pv_uses_vg(pv, vg)) {
 		log_error("Physical volume %s might be constructed from same "
 			  "volume group %s", pv_name, vg->name);
 		return 0;
@@ -1342,7 +1342,7 @@ struct list *get_pvs(struct cmd_context *cmd)
 	return results;
 }
 
-int pv_write(struct cmd_context *cmd, struct physical_volume *pv,
+int pv_write(struct cmd_context *cmd __attribute((unused)), struct physical_volume *pv,
 	     struct list *mdas, int64_t label_sector)
 {
 	if (!pv->fmt->ops->pv_write) {

lib/metadata/metadata.h

@@ -58,8 +58,9 @@
 #define VIRTUAL			0x00010000U	/* LV - internal use only */
 #define MIRROR_LOG		0x00020000U	/* LV */
 #define MIRROR_IMAGE		0x00040000U	/* LV */
-#define ACTIVATE_EXCL		0x00080000U	/* LV - internal use only */
-#define PRECOMMITTED		0x00100000U	/* VG - internal use only */
+#define MIRROR_NOTSYNCED	0x00080000U	/* LV */
+#define ACTIVATE_EXCL		0x00100000U	/* LV - internal use only */
+#define PRECOMMITTED		0x00200000U	/* VG - internal use only */
 
 #define LVM_READ              	0x00000100U	/* LV VG */
 #define LVM_WRITE             	0x00000200U	/* LV VG */
@@ -580,6 +581,8 @@ int add_mirror_layers(struct alloc_handle *ah,
 
 int remove_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors,
 			 struct list *removable_pvs, int remove_log);
+int reconfigure_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors,
+			      struct list *removable_pvs, int remove_log);
 /*
  * Given mirror image or mirror log segment, find corresponding mirror segment 
  */

lib/metadata/mirror.c

@@ -23,6 +23,13 @@
 #include "lvm-string.h"
 #include "locking.h"	/* FIXME Should not be used in this file */
 
+#include "defaults.h" /* FIXME: should this be defaults.h? */
+
+/* These are the flags that represent the mirror failure restoration policies */
+#define MIRROR_REMOVE            0
+#define MIRROR_ALLOCATE          1
+#define MIRROR_ALLOCATE_ANYWHERE 2
+
 struct lv_segment *find_mirror_seg(struct lv_segment *seg)
 {
 	return seg->mirror_seg;
@@ -230,6 +237,163 @@ int remove_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors,
 	return 1;
 }
 
+static int get_mirror_fault_policy(struct cmd_context *cmd, int log_policy)
+{
+	const char *policy;
+
+	if (log_policy)
+		policy = find_config_str(NULL, "activation/mirror_log_fault_policy",
+					 DEFAULT_MIRROR_LOG_FAULT_POLICY);
+	else
+		policy = find_config_str(NULL, "activation/mirror_dev_fault_policy",
+					 DEFAULT_MIRROR_DEV_FAULT_POLICY);
+
+	if (!strcmp(policy, "remove"))
+		return MIRROR_REMOVE;
+	else if (!strcmp(policy, "allocate"))
+		return MIRROR_ALLOCATE;
+	else if (!strcmp(policy, "allocate_anywhere"))
+		return MIRROR_ALLOCATE_ANYWHERE;
+
+	if (log_policy)
+		log_error("Bad activation/mirror_log_fault_policy");
+	else
+		log_error("Bad activation/mirror_dev_fault_policy");
+
+	return MIRROR_REMOVE;
+}
+
+static int get_mirror_log_fault_policy(struct cmd_context *cmd)
+{
+	return get_mirror_fault_policy(cmd, 1);
+}
+
+static int get_mirror_dev_fault_policy(struct cmd_context *cmd)
+{
+	return get_mirror_fault_policy(cmd, 0);
+}
+
+/*
+ * replace_mirror_images
+ * @mirrored_seg: segment (which may be linear now) to restore
+ * @num_mirrors: number of copies we should end up with
+ * @replace_log: replace log if not present
+ * @in_sync: was the original mirror in-sync?
+ *
+ * in_sync will be set to 0 if new mirror devices are being added
+ * In other words, it is only useful if the log (and only the log)
+ * is being restored.
+ *
+ * Returns: 0 on failure, 1 on reconfig, -1 if no reconfig done
+ */
+static int replace_mirror_images(struct lv_segment *mirrored_seg,
+				 uint32_t num_mirrors,
+				 int log_policy, int in_sync)
+{
+	int r = -1;
+	struct logical_volume *lv = mirrored_seg->lv;
+
+	/* FIXME: Use lvconvert rather than duplicating its code */
+
+	if (mirrored_seg->area_count < num_mirrors) {
+		log_error("WARNING: Failed to replace mirror device in %s/%s",
+			  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
+
+		if ((mirrored_seg->area_count > 1) && !mirrored_seg->log_lv)
+			log_error("WARNING: Use 'lvconvert -m %d %s/%s --corelog' to replace failed devices",
+				  num_mirrors - 1, lv->vg->name, lv->name);
+		else
+			log_error("WARNING: Use 'lvconvert -m %d %s/%s' to replace failed devices",
+				  num_mirrors - 1, lv->vg->name, lv->name);
+		r = 0;
+
+		/* REMEMBER/FIXME: set in_sync to 0 if a new mirror device was added */
+		in_sync = 0;
+	}
+
+	/*
+	 * FIXME: right now, we ignore the allocation policy specified to
+	 * allocate the new log.
+	 */
+	if ((mirrored_seg->area_count > 1) && !mirrored_seg->log_lv &&
+	    (log_policy != MIRROR_REMOVE)) {
+		log_error("WARNING: Failed to replace mirror log device in %s/%s",
+			  lv->vg->name, lv->name);
+
+		log_error("WARNING: Use 'lvconvert -m %d %s/%s' to replace failed devices",
+			  mirrored_seg->area_count - 1 , lv->vg->name, lv->name);
+		r = 0;
+	}
+
+	return r;
+}
+
+int reconfigure_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirrors,
+			      struct list *removable_pvs, int remove_log)
+{
+	int r;
+	int insync = 0;
+	int log_policy, dev_policy;
+	uint32_t old_num_mirrors = mirrored_seg->area_count;
+	int had_log = (mirrored_seg->log_lv) ? 1 : 0;
+	float sync_percent = 0;
+
+	/* was the mirror in-sync before problems? */
+	if (!lv_mirror_percent(mirrored_seg->lv->vg->cmd,
+			       mirrored_seg->lv, 0, &sync_percent, NULL))
+		log_error("WARNING: Unable to determine mirror sync status of %s/%s.",
+			  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
+	else if (sync_percent >= 100.0)
+		insync = 1;
+
+	/*
+	 * While we are only removing devices, we can have sync set.
+	 * Setting this is only useful if we are moving to core log
+	 * otherwise the disk log will contain the sync information
+	 */
+	init_mirror_in_sync(insync);
+
+	r = remove_mirror_images(mirrored_seg, num_mirrors,
+				 removable_pvs, remove_log);
+	if (!r)
+		/* Unable to remove bad devices */
+		return 0;
+
+	log_print("WARNING: Bad device removed from mirror volume, %s/%s",
+		  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
+
+	log_policy = get_mirror_log_fault_policy(mirrored_seg->lv->vg->cmd);
+	dev_policy = get_mirror_dev_fault_policy(mirrored_seg->lv->vg->cmd);
+
+	r = replace_mirror_images(mirrored_seg,
+				  (dev_policy != MIRROR_REMOVE) ?
+				  old_num_mirrors : num_mirrors,
+				  log_policy, insync);
+
+	if (!r)
+		/* Failed to replace device(s) */
+		log_error("WARNING: Unable to find substitute device for mirror volume, %s/%s",
+			  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
+	else if (r > 0)
+		/* Success in replacing device(s) */
+		log_print("WARNING: Mirror volume, %s/%s restored - substitute for failed device found.",
+			  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
+	else
+		/* Bad device removed, but not replaced because of policy */
+		if (mirrored_seg->area_count == 1) {
+			log_print("WARNING: Mirror volume, %s/%s converted to linear due to device failure.",
+				  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
+		} else if (had_log && !mirrored_seg->log_lv) {
+			log_print("WARNING: Mirror volume, %s/%s disk log removed due to device failure.",
+				  mirrored_seg->lv->vg->name, mirrored_seg->lv->name);
+		}
+	/*
+	 * If we made it here, we at least removed the bad device.
+	 * Consider this success.
+	 */
+	return 1;
+}
+
 static int _create_layers_for_mirror(struct alloc_handle *ah,
 				     uint32_t first_area,
 				     uint32_t num_mirrors,

lib/mirror/mirrored.c

@@ -174,7 +174,8 @@ static struct mirror_state *_mirrored_init_target(struct dm_pool *mem,
 static int _mirrored_target_percent(void **target_state, struct dm_pool *mem,
 			   struct config_tree *cft, struct lv_segment *seg,
 			   char *params, uint64_t *total_numerator,
-			   uint64_t *total_denominator, float *percent)
+			   uint64_t *total_denominator,
+			   float *percent __attribute((unused)))
 {
 	struct mirror_state *mirr_state;
 	uint64_t numerator, denominator;
@@ -237,13 +238,26 @@ static int _add_log(struct dev_manager *dm, struct lv_segment *seg,
 	      (seg->lv->vg->status & CLUSTERED)))
 		clustered = 1;
 
-	if (seg->log_lv &&
-	    !(log_dlid = build_dlid(dm, seg->log_lv->lvid.s, NULL))) {
-		log_error("Failed to build uuid for log LV %s.",
-			  seg->log_lv->name);
-		return 0;
+	if (seg->log_lv) {
+		/* If disk log, use its UUID */
+		if (!(log_dlid = build_dlid(dm, seg->log_lv->lvid.s, NULL))) {
+			log_error("Failed to build uuid for log LV %s.",
+				  seg->log_lv->name);
+			return 0;
+		}
+	} else {
+		/* If core log, use mirror's UUID and set DM_CORELOG flag */
+		if (!(log_dlid = build_dlid(dm, seg->lv->lvid.s, NULL))) {
+			log_error("Failed to build uuid for mirror LV %s.",
+				  seg->lv->name);
+			return 0;
+		}
+		log_flags |= DM_CORELOG;
 	}
 
+	if (mirror_in_sync() && !(seg->status & PVMOVE))
+		log_flags |= DM_NOSYNC;
+
 	if (_block_on_error_available && !(seg->status & PVMOVE))
 		log_flags |= DM_BLOCK_ON_ERROR;
 

lib/report/report.c

@@ -333,9 +333,12 @@ static int _lvstatus_disp(struct report_handle *rh, struct field *field,
 
 	if (lv->status & PVMOVE)
 		repstr[0] = 'p';
-	else if (lv->status & MIRRORED)
-		repstr[0] = 'm';
-	else if (lv->status & MIRROR_IMAGE)
+	else if (lv->status & MIRRORED) {
+		if (lv->status & MIRROR_NOTSYNCED)
+			repstr[0] = 'M';
+		else
+			repstr[0] = 'm';
+	}else if (lv->status & MIRROR_IMAGE)
 		repstr[0] = 'i';
 	else if (lv->status & MIRROR_LOG)
 		repstr[0] = 'l';
@@ -472,7 +475,8 @@ static int _vgstatus_disp(struct report_handle *rh, struct field *field,
 	return 1;
 }
 
-static int _segtype_disp(struct report_handle *rh, struct field *field,
+static int _segtype_disp(struct report_handle *rh __attribute((unused)),
+			 struct field *field,
 			 const void *data)
 {
 	const struct lv_segment *seg = (const struct lv_segment *) data;

lib/snapshot/snapshot.c

@@ -27,7 +27,7 @@ static const char *_snap_name(const struct lv_segment *seg)
 }
 
 static int _snap_text_import(struct lv_segment *seg, const struct config_node *sn,
-			struct dm_hash_table *pv_hash)
+			struct dm_hash_table *pv_hash __attribute((unused)))
 {
 	uint32_t chunk_size;
 	const char *org_name, *cow_name;
@@ -87,8 +87,10 @@ static int _snap_text_export(const struct lv_segment *seg, struct formatter *f)
 }
 
 #ifdef DEVMAPPER_SUPPORT
-static int _snap_target_percent(void **target_state, struct dm_pool *mem,
-			   struct config_tree *cft, struct lv_segment *seg,
+static int _snap_target_percent(void **target_state __attribute((unused)),
+			   struct dm_pool *mem __attribute((unused)),
+			   struct config_tree *cft __attribute((unused)),
+			   struct lv_segment *seg __attribute((unused)),
 			   char *params, uint64_t *total_numerator,
 			   uint64_t *total_denominator, float *percent)
 {
@@ -126,7 +128,7 @@ static int _snap_target_present(void)
 
 static void _snap_destroy(const struct segment_type *segtype)
 {
-	dm_free((void *) segtype);
+	dm_free((void *)segtype);
 }
 
 static struct segtype_handler _snapshot_ops = {

lib/striped/striped.c

@@ -151,11 +151,13 @@ static int _striped_merge_segments(struct lv_segment *seg1, struct lv_segment *s
 }
 
 #ifdef DEVMAPPER_SUPPORT
-static int _striped_add_target_line(struct dev_manager *dm, struct dm_pool *mem,
-                                struct config_tree *cft, void **target_state,
+static int _striped_add_target_line(struct dev_manager *dm,
+				struct dm_pool *mem __attribute((unused)),
+                                struct config_tree *cft __attribute((unused)),
+				void **target_state __attribute((unused)),
                                 struct lv_segment *seg,
                                 struct dm_tree_node *node, uint64_t len,
-                                uint32_t *pvmove_mirror_count)
+                                uint32_t *pvmove_mirror_count __attribute((unused)))
 {
 	if (!seg->area_count) {
 		log_error("Internal error: striped add_target_line called "
@@ -189,7 +191,7 @@ static int _striped_target_present(void)
 
 static void _striped_destroy(const struct segment_type *segtype)
 {
-	dm_free((void *) segtype);
+	dm_free((void *)segtype);
 }
 
 static struct segtype_handler _striped_ops = {

libdm/libdevmapper.h

@@ -350,6 +350,7 @@ int dm_tree_node_add_mirror_target(struct dm_tree_node *node,
 #define DM_NOSYNC		0x00000001	/* Known already in sync */
 #define DM_FORCESYNC		0x00000002	/* Force resync */
 #define DM_BLOCK_ON_ERROR	0x00000004	/* On error, suspend I/O */
+#define DM_CORELOG		0x00000008	/* In-memory log */
 
 int dm_tree_node_add_mirror_target_log(struct dm_tree_node *node,
 					  uint32_t region_size,

libdm/libdm-deptree.c

@@ -1243,8 +1243,8 @@ static int _emit_segment_line(struct dm_task *dmt, struct load_segment *seg, uin
 		log_parm_count += hweight32(seg->flags);	/* [no]sync, block_on_error etc. */
 
 		if (seg->clustered) {
-			if (seg->uuid)
-				log_parm_count++;	/* uuid */
+			if (seg->uuid && !(seg->flags & DM_CORELOG))
+				log_parm_count++;	/* uuid (already counted for core log) */
 			if ((tw = _dm_snprintf(params + pos, paramsize - pos, "clustered_")) < 0) {
                         	stack;	/* Out of space */
                         	return -1;
@@ -1701,18 +1701,19 @@ int dm_tree_node_add_mirror_target_log(struct dm_tree_node *node,
 	seg = list_item(list_last(&node->props.segs), struct load_segment);
 
 	if (log_uuid) {
-		if (!(log_node = dm_tree_find_node_by_uuid(node->dtree, log_uuid))) {
-			log_error("Couldn't find mirror log uuid %s.", log_uuid);
-			return 0;
-		}
-
-		if (!_link_tree_nodes(node, log_node))
-			return_0;
-
 		if (!(seg->uuid = dm_pool_strdup(node->dtree->mem, log_uuid))) {
 			log_error("log uuid pool_strdup failed");
 			return 0;
 		}
+		if (!(flags & DM_CORELOG)) {
+			if (!(log_node = dm_tree_find_node_by_uuid(node->dtree, log_uuid))) {
+				log_error("Couldn't find mirror log uuid %s.", log_uuid);
+				return 0;
+			}
+
+			if (!_link_tree_nodes(node, log_node))
+				return_0;
+		}
 	}
 
 	seg->log = log_node;

man/lvs.8

@@ -44,7 +44,7 @@ can also be chosen.
 The lv_attr bits are: 
 .RS
 .IP 1 3
-Volume type: (m)irrored, (o)rigin, (p)vmove, (s)napshot, 
+Volume type: (m)irrored, (M)irrored without initial sync, (o)rigin, (p)vmove, (s)napshot, 
 invalid (S)napshot, (v)irtual
 .IP 2 3
 Permissions: (w)riteable, (r)ead-only

tools/args.h

@@ -45,6 +45,8 @@ arg(type_ARG, '\0', "type", segtype_arg)
 arg(alloc_ARG, '\0', "alloc", alloc_arg)
 arg(separator_ARG, '\0', "separator", string_arg)
 arg(mirrorsonly_ARG, '\0', "mirrorsonly", NULL)
+arg(nosync_ARG, '\0', "nosync", NULL)
+arg(corelog_ARG, '\0', "corelog", NULL)
 
 /* Allow some variations */
 arg(resizable_ARG, '\0', "resizable", yes_no_arg)

tools/commands.h

@@ -81,7 +81,7 @@ xx(lvchange,
 xx(lvconvert,
    "Change logical volume layout",
    "lvconvert "
-   "[-m|--mirrors Mirrors]\n"
+   "[-m|--mirrors Mirrors [--corelog]]\n"
    "\t[--alloc AllocationPolicy]\n"
    "\t[-d|--debug]\n"
    "\t[-h|-?|--help]\n"
@@ -99,7 +99,8 @@ xx(lvconvert,
    "\t[--version]" "\n"
    "\tOriginalLogicalVolume[Path] SnapshotLogicalVolume[Path]\n",
 
-   alloc_ARG, chunksize_ARG, mirrors_ARG, snapshot_ARG, test_ARG, zero_ARG)
+   alloc_ARG, chunksize_ARG, mirrors_ARG, corelog_ARG,
+   snapshot_ARG, test_ARG, zero_ARG)
 
 xx(lvcreate,
    "Create a logical volume",
@@ -114,7 +115,7 @@ xx(lvcreate,
    "\t{-l|--extents LogicalExtentsNumber |\n"
    "\t -L|--size LogicalVolumeSize[kKmMgGtT]}\n"
    "\t[-M|--persistent {y|n}] [--major major] [--minor minor]\n"
-   "\t[-m|--mirrors Mirrors]\n"
+   "\t[-m|--mirrors Mirrors [--nosync] [--corelog]]\n"
    "\t[-n|--name LogicalVolumeName]\n"
    "\t[-p|--permission {r|rw}]\n"
    "\t[-r|--readahead ReadAheadSectors]\n"
@@ -147,9 +148,10 @@ xx(lvcreate,
    "\tOriginalLogicalVolume[Path] [PhysicalVolumePath...]\n\n",
 
    addtag_ARG, alloc_ARG, autobackup_ARG, chunksize_ARG, contiguous_ARG,
-   extents_ARG, major_ARG, minor_ARG, mirrors_ARG, name_ARG, permission_ARG,
-   persistent_ARG, readahead_ARG, regionsize_ARG, size_ARG, snapshot_ARG,
-   stripes_ARG, stripesize_ARG, test_ARG, type_ARG, zero_ARG)
+   corelog_ARG, extents_ARG, major_ARG, minor_ARG, mirrors_ARG, name_ARG,
+   nosync_ARG, permission_ARG, persistent_ARG, readahead_ARG, regionsize_ARG,
+   size_ARG, snapshot_ARG, stripes_ARG, stripesize_ARG, test_ARG, type_ARG,
+   zero_ARG)
 
 xx(lvdisplay,
    "Display information about a logical volume",

tools/lvconvert.c

@@ -235,6 +235,8 @@ static int lvconvert_mirrors(struct cmd_context * cmd, struct logical_volume * l
 	struct alloc_handle *ah = NULL;
 	struct logical_volume *log_lv;
 	struct list *parallel_areas;
+	struct segment_type *segtype;  /* FIXME: could I just use lp->segtype */
+	float sync_percent;
 
 	seg = first_seg(lv);
 	existing_mirrors = seg->area_count;
@@ -277,10 +279,71 @@ static int lvconvert_mirrors(struct cmd_context * cmd, struct logical_volume * l
 				return 0;
 			}
 			if (lp->mirrors == existing_mirrors) {
-				log_error("Logical volume %s already has %"
-					  PRIu32 " mirror(s).", lv->name,
-					  lp->mirrors - 1);
-				return 1;
+				if (!seg->log_lv && !arg_count(cmd, corelog_ARG)) {
+					/* No disk log present, add one. */
+					/* FIXME: Why doesn't this work?  Without
+					   it, we will probably put the log on the
+					   same device as a mirror leg.
+					  if (!(parallel_areas = build_parallel_areas_from_lv(cmd, lv))) {
+					  stack;
+					  return 0;
+					  }
+					*/
+					parallel_areas = NULL;
+					if (!lv_mirror_percent(cmd, lv, 0, &sync_percent, NULL)) {
+						log_error("Unable to determine mirror sync status.");
+						return 0;
+					}
+
+					segtype = get_segtype_from_string(cmd, "striped");
+
+					if (!(ah = allocate_extents(lv->vg, NULL, segtype, 1,
+								    0, 1, 0,
+								    NULL, 0, 0, lp->pvh,
+								    lp->alloc,
+								    parallel_areas))) {
+						stack;
+						return 0;
+					}
+
+					if (sync_percent >= 100.0)
+						init_mirror_in_sync(1);
+					else
+						init_mirror_in_sync(0);
+
+					if (!(log_lv = create_mirror_log(cmd, lv->vg, ah,
+									 lp->alloc, lv->name,
+									 (sync_percent >= 100.0) ?
+									 1 : 0))) {
+						log_error("Failed to create mirror log.");
+						return 0;
+					}
+					seg->log_lv = log_lv;
+					log_lv->status |= MIRROR_LOG;
+					first_seg(log_lv)->mirror_seg = seg;
+				} else if (seg->log_lv && arg_count(cmd, corelog_ARG)) {
+					/* Had disk log, switch to core. */
+					if (!lv_mirror_percent(cmd, lv, 0, &sync_percent, NULL)) {
+						log_error("Unable to determine mirror sync status.");
+						return 0;
+					}
+
+					if (sync_percent >= 100.0)
+						init_mirror_in_sync(1);
+					else
+						init_mirror_in_sync(0);
+
+					if (!remove_mirror_images(seg, lp->mirrors,
+								  lp->pv_count ?
+								  lp->pvh : NULL, 1))
+						return_0;
+				} else {
+					/* No change */
+					log_error("Logical volume %s already has %"
+						  PRIu32 " mirror(s).", lv->name,
+						  lp->mirrors - 1);
+					return 1;
+				}
 			}
 			if (lp->mirrors > existing_mirrors) {
 				/* FIXME Unless anywhere, remove PV of log_lv 
@@ -314,7 +377,8 @@ static int lvconvert_mirrors(struct cmd_context * cmd, struct logical_volume * l
 				return_0;
 
 			if (!(ah = allocate_extents(lv->vg, NULL, lp->segtype,
-						    1, lp->mirrors - 1, 1,
+						    1, lp->mirrors - 1,
+						    arg_count(cmd, corelog_ARG) ? 0 : 1,
 						    lv->le_count * (lp->mirrors - 1),
 						    NULL, 0, 0, lp->pvh,
 						    lp->alloc,
@@ -325,9 +389,11 @@ static int lvconvert_mirrors(struct cmd_context * cmd, struct logical_volume * l
 								      lv->le_count,
 								      lp->region_size);
 
-			if (!(log_lv = create_mirror_log(cmd, lv->vg, ah,
+			log_lv = NULL;
+			if (!arg_count(cmd, corelog_ARG) &&
+			    !(log_lv = create_mirror_log(cmd, lv->vg, ah,
 							 lp->alloc,
-							 lv->name))) {
+							 lv->name, 0))) {
 				log_error("Failed to create mirror log.");
 				return 0;
 			}
@@ -390,7 +456,7 @@ static int lvconvert_snapshot(struct cmd_context *cmd,
 
 	if (!lp->zero)
 		log_error("WARNING: \"%s\" not zeroed", lv->name);
-	else if (!zero_lv(cmd, lv)) {
+	else if (!set_lv(cmd, lv, 0)) {
 			log_error("Aborting. Failed to wipe snapshot "
 				  "exception store.");
 			return 0;

tools/lvcreate.c

@@ -24,6 +24,8 @@ struct lvcreate_params {
 	int zero;
 	int major;
 	int minor;
+	int corelog;
+	int nosync;
 
 	char *origin;
 	const char *vg_name;
@@ -291,6 +293,9 @@ static int _read_mirror_params(struct lvcreate_params *lp,
 		return 0;
 	}
 
+	lp->corelog = arg_count(cmd, corelog_ARG) ? 1 : 0;
+	lp->nosync = arg_count(cmd, nosync_ARG) ? 1 : 0;
+
 	return 1;
 }
 
@@ -377,6 +382,16 @@ static int _lvcreate_params(struct lvcreate_params *lp, struct cmd_context *cmd,
 			stack;
 			return 0;
 		}
+	} else {
+		if (arg_count(cmd, corelog_ARG)) {
+			log_error("--corelog is only available with mirrors");
+			return 0;
+		}
+
+		if (arg_count(cmd, nosync_ARG)) {
+			log_error("--nosync is only available with mirrors");
+			return 0;
+		}
 	}
 
 	if (activation() && lp->segtype->ops->target_present &&
@@ -634,9 +649,9 @@ static int _lvcreate(struct cmd_context *cmd, struct lvcreate_params *lp)
 		/* FIXME Calculate how many extents needed for the log */
 
 		if (!(ah = allocate_extents(vg, NULL, lp->segtype, lp->stripes,
-					    lp->mirrors, 1, lp->extents,
-					    NULL, 0, 0, pvh, lp->alloc,
-					    NULL))) {
+					    lp->mirrors, lp->corelog ? 0 : 1,
+					    lp->extents, NULL, 0, 0,
+					    pvh, lp->alloc, NULL))) {
 			stack;
 			return 0;
 		}
@@ -645,8 +660,16 @@ static int _lvcreate(struct cmd_context *cmd, struct lvcreate_params *lp)
 							      lp->extents,
 							      lp->region_size);
 
+		init_mirror_in_sync(lp->nosync);
+
+		if (lp->nosync) {
+			log_print("WARNING: New mirror won't be synchronised. "
+				  "Don't read what you didn't write!");
+			status |= MIRROR_NOTSYNCED;
+		}
+
 		if (!(log_lv = create_mirror_log(cmd, vg, ah, lp->alloc,
-						 lv_name))) {
+						 lv_name, lp->nosync))) {
 			log_error("Failed to create mirror log.");
 			return 0;
 		}
@@ -730,7 +753,7 @@ static int _lvcreate(struct cmd_context *cmd, struct lvcreate_params *lp)
 	}
 
 	if ((lp->zero || lp->snapshot) && activation()) {
-		if (!zero_lv(cmd, lv) && lp->snapshot) {
+		if (!set_lv(cmd, lv, 0) && lp->snapshot) {
 			/* FIXME Remove the failed lv we just added */
 			log_error("Aborting. Failed to wipe snapshot "
 				  "exception store. Remove new LV and retry.");

tools/lvmcmdline.c

@@ -713,6 +713,8 @@ static int _get_settings(struct cmd_context *cmd)
 	    !_merge_synonym(cmd, allocation_ARG, resizeable_ARG))
 		return EINVALID_CMD_LINE;
 
+	init_mirror_in_sync(0);
+
 	/* Zero indicates success */
 	return 0;
 }

tools/pvcreate.c

@@ -96,7 +96,7 @@ static int pvcreate_check(struct cmd_context *cmd, const char *name)
 	     (yes_no_prompt("Software RAID md superblock "
 			    "detected on %s. Wipe it? [y/n] ", name) == 'y'))) {
 		log_print("Wiping software RAID md superblock on %s", name);
-		if (!dev_zero(dev, md_superblock, 4)) {
+		if (!dev_set(dev, md_superblock, 4, 0)) {
 			log_error("Failed to wipe RAID md superblock on %s",
 				  name);
 			return 0;
@@ -225,7 +225,7 @@ static int pvcreate_single(struct cmd_context *cmd, const char *pv_name,
 			goto error;
 		}
 
-		if (!dev_zero(dev, UINT64_C(0), (size_t) 2048)) {
+		if (!dev_set(dev, UINT64_C(0), (size_t) 2048, 0)) {
 			log_error("%s not wiped: aborting", pv_name);
 			dev_close(dev);
 			goto error;

tools/toollib.c

@@ -15,10 +15,15 @@
 
 #include "tools.h"
 #include "lv_alloc.h"
+#include "xlate.h"
 
 #include <sys/stat.h>
 #include <sys/wait.h>
 
+/* From linux/drivers/md/dm-log.c */
+#define MIRROR_MAGIC 0x4D695272
+#define MIRROR_DISK_VERSION 2
+
 /* Command line args */
 unsigned arg_count(struct cmd_context *cmd, int a)
 {
@@ -1111,9 +1116,9 @@ int generate_log_name_format(struct volume_group *vg __attribute((unused)),
 }
 
 /*
- * Volumes may be zeroed to remove old application data.
+ * Initialize the LV with 'value'.
  */
-int zero_lv(struct cmd_context *cmd, struct logical_volume *lv)
+int set_lv(struct cmd_context *cmd, struct logical_volume *lv, int value)
 {
 	struct device *dev;
 	char *name;
@@ -1126,27 +1131,80 @@ int zero_lv(struct cmd_context *cmd, struct logical_volume *lv)
 	 *	   (I know the device is at least 4k, but not 32k)
 	 */
 	if (!(name = dm_pool_alloc(cmd->mem, PATH_MAX))) {
-		log_error("Name allocation failed - device not zeroed");
+		log_error("Name allocation failed - device not cleared");
 		return 0;
 	}
 
 	if (lvm_snprintf(name, PATH_MAX, "%s%s/%s", cmd->dev_dir,
 			 lv->vg->name, lv->name) < 0) {
-		log_error("Name too long - device not zeroed (%s)", lv->name);
+		log_error("Name too long - device not cleared (%s)", lv->name);
 		return 0;
 	}
 
-	log_verbose("Zeroing start of logical volume \"%s\"", lv->name);
+	log_verbose("Clearing start of logical volume \"%s\"", lv->name);
 
 	if (!(dev = dev_cache_get(name, NULL))) {
-		log_error("%s: not found: device not zeroed", name);
+		log_error("%s: not found: device not cleared", name);
 		return 0;
 	}
 
 	if (!dev_open_quiet(dev))
 		return 0;
 
-	dev_zero(dev, UINT64_C(0), (size_t) 4096);
+	dev_set(dev, UINT64_C(0), (size_t) 4096, value);
+	dev_close_immediate(dev);
+
+	return 1;
+}
+
+
+/*
+ * This function writes a new header to the mirror log header to the lv
+ *
+ * Returns: 1 on success, 0 on failure
+ */
+static int _write_log_header(struct cmd_context *cmd, struct logical_volume *lv)
+{
+	struct device *dev;
+	char *name;
+	struct { /* The mirror log header */
+		uint32_t magic;
+		uint32_t version;
+		uint64_t nr_regions;
+	} log_header;
+
+	log_header.magic = xlate32(MIRROR_MAGIC);
+	log_header.version = xlate32(MIRROR_DISK_VERSION);
+	log_header.nr_regions = xlate64((uint64_t)-1);
+
+	if (!(name = dm_pool_alloc(cmd->mem, PATH_MAX))) {
+		log_error("Name allocation failed - log header not written (%s)",
+			lv->name);
+		return 0;
+	}
+
+	if (lvm_snprintf(name, PATH_MAX, "%s%s/%s", cmd->dev_dir,
+			 lv->vg->name, lv->name) < 0) {
+		log_error("Name too long - log header not written (%s)", lv->name);
+		return 0;
+	}
+
+	log_verbose("Writing log header to device, %s", lv->name);
+
+	if (!(dev = dev_cache_get(name, NULL))) {
+		log_error("%s: not found: log header not written", name);
+		return 0;
+	}
+
+	if (!dev_open_quiet(dev))
+		return 0;
+
+	if (!dev_write(dev, UINT64_C(0), sizeof(log_header), &log_header)) {
+		log_error("Failed to write log header to %s", name);
+		dev_close_immediate(dev);
+		return 0;
+	}
+
 	dev_close_immediate(dev);
 
 	return 1;
@@ -1156,7 +1214,8 @@ struct logical_volume *create_mirror_log(struct cmd_context *cmd,
 					 struct volume_group *vg,
 					 struct alloc_handle *ah,
 					 alloc_policy_t alloc,
-					 const char *lv_name)
+					 const char *lv_name,
+					 int in_sync)
 {
 	struct logical_volume *log_lv;
 	char *log_name;
@@ -1201,12 +1260,18 @@ struct logical_volume *create_mirror_log(struct cmd_context *cmd,
 		goto error;
 	}
 
-	if (activation() && !zero_lv(cmd, log_lv)) {
+	if (activation() && !set_lv(cmd, log_lv, in_sync)) {
 		log_error("Aborting. Failed to wipe mirror log. "
 			  "Remove new LV and retry.");
 		goto error;
 	}
 
+	if (!_write_log_header(cmd, log_lv)) {
+		log_error("Aborting. Failed to write mirror log header. "
+			  "Remove new LV and retry.");
+		goto error;
+	}
+
 	if (!deactivate_lv(cmd, log_lv)) {
 		log_error("Aborting. Failed to deactivate mirror log. "
 			  "Remove new LV and retry.");

tools/toollib.h

@@ -97,8 +97,9 @@ struct logical_volume *create_mirror_log(struct cmd_context *cmd,
 					 struct volume_group *vg,
 					 struct alloc_handle *ah,
 					 alloc_policy_t alloc,
-					 const char *lv_name);
+					 const char *lv_name,
+					 int in_sync);
 
-int zero_lv(struct cmd_context *cmd, struct logical_volume *lv);
+int set_lv(struct cmd_context *cmd, struct logical_volume *lv, int value);
 
 #endif

tools/vgmerge.c

@@ -125,7 +125,7 @@ static int _vgmerge_single(struct cmd_context *cmd, const char *vg_name_to,
 
 	/* Check no PVs are constructed from either VG */
 	list_iterate_items(pvl, &vg_to->pvs) {
-		if (pv_uses_vg(cmd, pvl->pv, vg_from)) {
+		if (pv_uses_vg(pvl->pv, vg_from)) {
 			log_error("Physical volume %s might be constructed "
 				  "from same volume group %s.",
 				  dev_name(pvl->pv->dev), vg_from->name);
@@ -134,7 +134,7 @@ static int _vgmerge_single(struct cmd_context *cmd, const char *vg_name_to,
 	}
 
 	list_iterate_items(pvl, &vg_from->pvs) {
-		if (pv_uses_vg(cmd, pvl->pv, vg_to)) {
+		if (pv_uses_vg(pvl->pv, vg_to)) {
 			log_error("Physical volume %s might be constructed "
 				  "from same volume group %s.",
 				  dev_name(pvl->pv->dev), vg_to->name);

tools/vgreduce.c

@@ -158,7 +158,7 @@ static int _make_vg_consistent(struct cmd_context *cmd, struct volume_group *vg)
 	struct lv_segment *seg, *mirrored_seg;
 	struct lv_segment_area area;
 	unsigned s;
-	uint32_t mimages;
+	uint32_t mimages, remove_log;
 	int list_unsafe, only_mirror_images_found;
 	LIST_INIT(lvs_changed);
 	only_mirror_images_found = 1;
@@ -259,7 +259,10 @@ static int _make_vg_consistent(struct cmd_context *cmd, struct volume_group *vg)
 			mirrored_seg = first_seg(lvl->lv);
 			if (!seg_is_mirrored(mirrored_seg))
 				continue;
+
 			mimages = mirrored_seg->area_count;
+			remove_log = 0;
+
 			for (s = 0; s < mirrored_seg->area_count; s++) {
 				list_iterate_items_safe(lvl2, lvlt, &lvs_changed) {
 					if (seg_type(mirrored_seg, s) != AREA_LV ||
@@ -272,8 +275,24 @@ static int _make_vg_consistent(struct cmd_context *cmd, struct volume_group *vg)
 					mimages--;	/* FIXME Assumes uniqueness */
 				}
 			}
-			if (mimages != mirrored_seg->area_count) {
-				if (!remove_mirror_images(mirrored_seg, mimages, NULL, 0)) {
+
+			if (mirrored_seg->log_lv) {
+				list_iterate_items(seg, &mirrored_seg->log_lv->segments) {
+					/* FIXME: The second test shouldn't be required */
+					if ((seg->segtype ==
+					     get_segtype_from_string(vg->cmd, "error")) ||
+					    (!strcmp(seg->segtype->name, "error"))) {
+						log_print("The log device for %s/%s has failed.",
+							  vg->name, mirrored_seg->lv->name);
+						remove_log = 1;
+						break;
+					}
+				}
+			}
+
+			if ((mimages != mirrored_seg->area_count) || (remove_log)){
+				if (!reconfigure_mirror_images(mirrored_seg, mimages,
+							       NULL, remove_log)) {
 					stack;
 					return 0;
 				}
@@ -295,14 +314,20 @@ static int _make_vg_consistent(struct cmd_context *cmd, struct volume_group *vg)
 
 		/* Deactivate error LVs */
 		if (!test_mode()) {
-			list_iterate_items(lvl, &lvs_changed) {
+			list_iterate_items_safe(lvl, lvlt, &lvs_changed) {
 				log_verbose("Deactivating (if active) logical volume %s",
 					    lvl->lv->name);
 
 				if (!deactivate_lv(cmd, lvl->lv)) {
 					log_error("Failed to deactivate LV %s",
 						  lvl->lv->name);
-					return 0;
+					/*
+					 * We failed to deactivate.
+					 * Probably because this was a mirror log.
+					 * Don't try to lv_remove it.
+					 * Continue work on others.
+					 */
+					list_del(&lvl->list);
 				}
 			}
 		}