lvm2/tools/pvck.c

/*
 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
 * Copyright (C) 2007 Red Hat, Inc. All rights reserved.
 *
 * This file is part of LVM2.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU Lesser General Public License v.2.1.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "base/memory/zalloc.h"
#include "tools.h"
#include "lib/format_text/format-text.h"
#include "lib/format_text/layout.h"
#include "lib/mm/xlate.h"
#include "lib/misc/crc.h"
#include "lib/device/device_id.h"

#define ONE_MB_IN_BYTES 1048576

#define PRINT_CURRENT 1
#define PRINT_ALL 2

#define ID_STR_SIZE 40 /* uuid formatted with dashes is 38 chars */

/*
 * command line input from --settings
 */
struct settings {
	uint64_t metadata_offset;  /* bytes, start of text metadata (from start of disk) */
	uint64_t mda_offset;       /* bytes, start of mda_header (from start of disk) */
	uint64_t mda_size;         /* bytes, size of metadata area (mda_header + text area) */
	uint64_t mda2_offset;      /* bytes */
	uint64_t mda2_size;        /* bytes */
	uint64_t device_size;      /* bytes */
	uint64_t data_offset;      /* bytes, start of data (pe_start) */
	uint32_t seqno;
	struct id pvid;

	int mda_num;               /* 1 or 2 for first or second mda */
	char *backup_file;

	unsigned metadata_offset_set:1;
	unsigned mda_offset_set:1;
	unsigned mda_size_set:1;
	unsigned mda2_offset_set;
	unsigned mda2_size_set;
	unsigned device_size_set:1;
	unsigned data_offset_set:1;
	unsigned seqno_set:1;
	unsigned pvid_set:1;
};

/*
 * command line input from --file
 */
struct metadata_file {
	const char *filename;
	char *text_buf;
	uint64_t text_size; /* bytes */
	uint32_t text_crc;
	char vgid_str[ID_STR_SIZE];
};

static char *_chars_to_str(const void *in, void *out, int num, int max, const char *field)
{
	const char *i = in;
	char *o = out;
	int n;

	memset(out, 0, max);

	if (num > max-1) {
		log_print("CHECK: abbreviating output for %s", field);
		num = max - 1;
	}

	for (n = 0; n < num; n++) {
		if (isprint((int)*i))
			*o = *i;
		else
			*o = '?';
		i++;
		o++;
	}

	return out;
}

/* 
 * This is used to print mda_header.magic as a series of hex values
 * since it only contains some printable chars.
 */
static char *_chars_to_hexstr(const void *in, void *out, int num, int max, const char *field)
{
	char *tmp;
	const char *i = in;
	int n;
	int off = 0;
	int ret;

	if (!(tmp = zalloc(max))) {
		log_print("CHECK: no mem for printing %s", field);
		return out;
	}

	memset(out, 0, max);
	memset(tmp, 0, max);

	if (num > max-1) {
		log_print("CHECK: abbreviating output for %s", field);
		num = max - 1;
	}

	for (n = 0; n < num; n++) {
		ret = sprintf(tmp+off, "%x", *i & 0xFF);
		off += ret;
		i++;
	}

	memcpy(out, tmp, 256);

	free(tmp);

	return out;
}

static int _check_vgname_start(char *buf, int *len)
{
	int chars = 0;
	int space = 0;
	int i;
	char c;

	/*
	 * Valid metadata begins: 'vgname {'
	 */
	for (i = 0; i <= NAME_LEN + 2; i++) {
		c = buf[i];

		if (isalnum(c) || c == '.' || c == '_' || c == '-' || c == '+') {
			if (space)
				return 0;
			chars++;
			continue;
		}

		if (c == ' ') {
			if (!chars || space)
				return 0;
			space++;
			continue;
		}

		if (c == '{') {
			if (chars && space) {
				*len = chars;
				return 1;
			}
			return 0;
		}

		return 0;
	}
	return 0;
}

/* all sizes and offsets in bytes */

static void _copy_out_metadata(char *buf, uint32_t start, uint32_t first_start, uint64_t mda_size, char **meta_buf, uint64_t *meta_size, int *bad_end)
{
	char *new_buf;
	uint64_t i;
	uint64_t new_len;
	uint64_t len_a = 0, len_b = 0;
	uint32_t stop;
	int found_end;

	/*
	 * If we wrap around the buffer searching for the
	 * end of some metadata, either stop when we reach
	 * where we began (start), or stop where we found
	 * the first copy of metadata (first_start).
	 */
	if (!first_start)
		stop = start;
	else
		stop = first_start;

	found_end = 0;
	for (i = start; i < mda_size; i++) {
		if (buf[i] == '\0') {
			found_end = 1;
			break;
		}
	}

	if (found_end) {
		new_len = i - start;
	} else {
		len_a = i - start;

		found_end = 0;
		for (i = 512; i < stop; i++) {
			if (buf[i] == '\0') {
				found_end = 1;
				break;
			}
		}

		if (!found_end)
			return;

		len_b = i - 512;
		new_len = len_a + len_b;
	}

	if (new_len < 256) {
		log_print("skip invalid metadata with len %llu at %llu",
			  (unsigned long long)new_len, (unsigned long long)start);
		return;
	}

	/* terminating 0 byte */
	new_len++;

	if (!(new_buf = zalloc(new_len)))
		return;

	if (len_a) {
		memcpy(new_buf, buf+start, len_a);
		memcpy(new_buf+len_a, buf+512, len_b);
	} else {
		memcpy(new_buf, buf+start, new_len);
	}

	/* \0 should be preceded by \n\n (0x0a0a) */
	if (new_buf[new_len-1] != 0 || new_buf[new_len-2] != 0x0a || new_buf[new_len-3] != 0x0a)
		*bad_end = 1;

	*meta_buf = new_buf;
	*meta_size = new_len;
}

/* all sizes and offsets in bytes */

static int _text_buf_parse(char *text_buf, uint64_t text_size, struct dm_config_tree **cft_out)
{
	struct dm_config_tree *cft;

	*cft_out = NULL;

	if (!(cft = config_open(CONFIG_FILE_SPECIAL, NULL, 0))) {
		return 0;
	}

	if (!dm_config_parse_without_dup_node_check(cft, text_buf, text_buf + text_size)) {
		config_destroy(cft);
		return 0;
	}

	*cft_out = cft;
	return 1;
}

/* all sizes and offsets in bytes */

static int _text_buf_parsable(char *text_buf, uint64_t text_size)
{
	struct dm_config_tree *cft = NULL;

	if (!_text_buf_parse(text_buf, text_size, &cft))
		return 0;

	config_destroy(cft);
	return 1;
}

#define MAX_LINE_CHECK 128

#define MAX_DESC 1024
char desc_line[MAX_DESC];

static void _copy_line(char *in, char *out, int *len, int linesize)
{
	int i;

	*len = 0;

	for (i = 0; i < linesize; i++) {
		out[i] = in[i];
		if ((in[i] == '\n') || (in[i] == '\0'))
			break;
	}
	*len = i+1;
}

static uint64_t mda2_offset_from_size(struct device *dev, uint64_t mda2_size)
{
	uint64_t dev_sectors = 0;
	uint64_t dev_bytes;
	uint64_t extra_bytes;
	uint64_t mda2_offset;

	if (dev_get_size(dev, &dev_sectors))
		stack;

	dev_bytes = dev_sectors * 512;
	extra_bytes = dev_bytes % ONE_MB_IN_BYTES;

	if (dev_bytes < (2 * ONE_MB_IN_BYTES))
		return_0;

	mda2_offset = dev_bytes - extra_bytes - mda2_size;

	return mda2_offset;
}

static uint64_t mda2_size_from_offset(struct device *dev, uint64_t mda2_offset)
{
	uint64_t dev_sectors = 0;
	uint64_t dev_bytes;
	uint64_t extra_bytes;
	uint64_t mda2_size;

	if (dev_get_size(dev, &dev_sectors))
		stack;

	dev_bytes = dev_sectors * 512;
	extra_bytes = dev_bytes % ONE_MB_IN_BYTES;

	if (dev_bytes < (2 * ONE_MB_IN_BYTES))
		return_0;

	mda2_size = dev_bytes - extra_bytes - mda2_offset;

	return mda2_size;
}

struct devicefile {
	char path[PATH_MAX];
	int fd;
};

static struct devicefile *get_devicefile(const char *path)
{
	struct stat sb;
	struct devicefile *def;

	if (stat(path, &sb))
		return_NULL;

	if ((sb.st_mode & S_IFMT) != S_IFREG)
		return_NULL;

	if (!(def = malloc(sizeof(struct devicefile))))
		return_NULL;

	if (dm_snprintf(def->path, PATH_MAX, "%s", path) < 0) {
		free(def);
		return_NULL;
	}

	if ((def->fd = open(path, O_RDONLY)) < 0) {
		free(def);
		return_NULL;
	}

	return def;
}

static bool _read_bytes(struct device *dev, struct devicefile *def, uint64_t start, size_t len, void *data)
{
	off_t off;
	ssize_t rv;

	if (dev)
		return dev_read_bytes(dev, start, len, data);

	off = lseek(def->fd, start, SEEK_SET);
	if (off != start)
		return false;

	rv = read(def->fd, data, len);
	if (rv < 0)
		return false;
	if (rv != len)
		return false;
	return true;
}

/* all sizes and offsets in bytes */

static int _dump_all_text(struct cmd_context *cmd, struct settings *set, const char *tofile,
			  struct device *dev, struct devicefile *def,
			  int mda_num, uint64_t mda_offset, uint64_t mda_size, char *buf)
{
	FILE *fp = NULL;
	char line[MAX_LINE_CHECK];
	char vgname[NAME_LEN+1];
	char id_str[ID_STR_SIZE];
	char id_first[ID_STR_SIZE];
	char *text_buf = NULL;
	char *p;
	uint32_t buf_off; /* offset with buf which begins with mda_header, bytes */
	uint32_t buf_off_first = 0;
	uint32_t seqno;
	uint32_t crc;
	uint64_t text_size; /* bytes */
	uint64_t meta_size; /* bytes */
	int print_count = 0;
	int one_found = 0;
	int multiple_vgs = 0;
	int bad_end;
	int vgnamelen;
	int count;
	int len;

	if (tofile) {
		if (!(fp = fopen(tofile, "wx"))) {
			log_error("Failed to create file %s", tofile);
			return 0;
		}
	}

	/*
	 * If metadata has not wrapped, and the metadata area beginning
	 * has not been damaged, the text area will begin with vgname {.
	 * Wrapping or damage would mean we find no metadata starting at
	 * the start of the area.
	 *
	 * Try looking at each 512 byte offset within the area for the start
	 * of another copy of metadata.  Metadata copies have begun at 512
	 * aligned offsets since very early lvm2 code in 2002.
	 *
	 * (We could also search for something definitive like
	 * "# Generated by LVM2" in the area, and then work backward to find
	 * a likely beginning.)
	 *
	 * N.B. This relies on VG metadata first having the id = "..." field
	 * followed by the "seqno = N" field.
	 */

	memset(id_first, 0, sizeof(id_str));

	/*
	 * A count of 512 byte chunks within the metadata area.
	 */
	count = 0;

	meta_size = mda_size - 512;

	/*
	 * Search 512 byte boundaries for the start of new metadata copies.
	 */
	while (count < (meta_size / 512)) {
		memset(vgname, 0, sizeof(vgname));
		memset(id_str, 0, sizeof(id_str));
		seqno = 0;
		vgnamelen = 0;
		text_size = 0;
		bad_end = 0;

		if (one_found)
			break;

		/*
		 * Check for a new metadata copy at each 512 offset
		 * (after skipping 512 bytes for mda_header at the
		 * start of the buf).
		 *
		 * If a line looks like it begins with a vgname
		 * it could be a new copy of metadata, but it could
		 * also be a random bit of metadata that looks like
		 * a vgname, so confirm it's the start of metadata
		 * by looking for id and seqno lines following the
		 * possible vgname.
		 */
		buf_off = 512 + (count * 512);
		p = buf + buf_off;

		/*
		 * user specified metadata in one location
		 */
		if (set->metadata_offset_set && (set->metadata_offset != (mda_offset + buf_off))) {
			count++;
			continue;
		}
		if (set->metadata_offset_set)
			one_found = 1;

		/*
		 * copy line of possible metadata to check for vgname
		 */
		memset(line, 0, sizeof(line));
		_copy_line(p, line, &len, sizeof(line)-1);
		p += len;

		if (!_check_vgname_start(line, &vgnamelen)) {
			count++;
			continue;
		}

		memcpy(vgname, line, vgnamelen);

		/*
		 * copy next line of metadata, which should contain id
		 */
		memset(line, 0, sizeof(line));
		_copy_line(p, line, &len, sizeof(line)-1);
		p += len;

		if (strncmp(line, "id = ", 5)) {
			count++;
			continue;
		}

		memcpy(id_str, line + 6, 38);

		/*
		 * copy next line of metadata, which should contain seqno
		 */
		memset(line, 0, sizeof(line));
		_copy_line(p, line, &len, sizeof(line)-1);
		p += len;

		if (strncmp(line, "seqno = ", 8)) {
			count++;
			continue;
		}
		if (sscanf(line, "seqno = %u", &seqno) != 1) {
			count++;
			continue;
		}

		/*
		 * user specified metadata with one seqno
		 * (this is not good practice since multiple old copies of metadata
		 * can have the same seqno; this is mostly to simplify testing)
		 */
		if (set->seqno_set && (set->seqno != seqno)) {
			count++;
			continue;
		}
		if (set->seqno_set)
			one_found = 1;

		/*
		 * The first three lines look like metadata with
		 * vgname/id/seqno, so copy out the full metadata.
		 *
		 * If this reaches the end of buf without reaching the
		 * end marker of metadata, it will wrap around to the
		 * start of buf and continue copying until it reaches
		 * a NL or until it reaches buf_off_first (which is
		 * where we've already taken text from.)
		 */
		_copy_out_metadata(buf, buf_off, buf_off_first, mda_size, &text_buf, &text_size, &bad_end);

		if (!text_buf) {
			log_warn("Failed to extract full metadata text at %llu, skipping.",
				 (unsigned long long)(mda_offset + buf_off));
			count++;
			continue;
		}

		/*
		 * check if it's finding metadata from different vgs
		 */
		if (!id_first[0])
			memcpy(id_first, id_str, sizeof(id_first));
		else if (memcmp(id_first, id_str, sizeof(id_first)))
			multiple_vgs = 1;

		crc = calc_crc(INITIAL_CRC, (uint8_t *)text_buf, text_size);

		log_print("metadata at %llu length %llu crc %08x vg %s seqno %u id %s",
			  (unsigned long long)(mda_offset + buf_off),
			  (unsigned long long)text_size,
			  crc, vgname, seqno, id_str);

		/*
		 * save the location of the first metadata we've found so
		 * we know where to stop after wrapping buf.
		 */
		if (!buf_off_first)
			buf_off_first = buf_off;

		/*
		 * check if the full metadata is parsable
		 */

		if (!_text_buf_parsable(text_buf, text_size))
			log_warn("WARNING: parse error for metadata at %llu", (unsigned long long)(mda_offset + buf_off));
		if (bad_end)
			log_warn("WARNING: unexpected terminating bytes for metadata at %llu", (unsigned long long)(mda_offset + buf_off));

		if (arg_is_set(cmd, verbose_ARG)) {
			char *str1, *str2;
			if ((str1 = strstr(text_buf, "description = "))) {
				memset(desc_line, 0, sizeof(desc_line));
				_copy_line(str1, desc_line, &len, sizeof(desc_line)-1);
				if ((p = strchr(desc_line, '\n')))
					*p = '\0';
				log_print("%s", desc_line);
			}
			if (str1 && (str2 = strstr(str1, "creation_time = "))) {
				memset(desc_line, 0, sizeof(desc_line));
				_copy_line(str2, desc_line, &len, sizeof(desc_line)-1);
				if ((p = strchr(desc_line, '\n')))
					*p = '\0';
				log_print("%s\n", desc_line);
			}
		}

		if (fp) {
			if (print_count++)
				fprintf(fp, "\n--\n");
			fprintf(fp, "%s", text_buf);
		}

		free(text_buf);
		text_buf = NULL;

		if (text_size < 512)
			count++;
		else if (!(text_size % 512))
			count += (text_size / 512);
		else
			count += ((text_size / 512) + 1);
	}

	if (multiple_vgs)
		log_warn("WARNING: metadata from multiple VGs was found.");

	if (fp) {
		if (fflush(fp))
			stack;
		if (fclose(fp))
			stack;
	}

	return 1;
}

/* all sizes and offsets in bytes */

static int _check_label_header(struct label_header *lh, uint64_t labelsector,
			       int *found_label)
{
	uint32_t crc;
	int good_id = 1, good_type = 1;
	int bad = 0;

	if (memcmp(lh->id, LABEL_ID, sizeof(lh->id))) {
		log_print("CHECK: label_header.id expected %s", LABEL_ID);
		good_id = 0;
		bad++;
	}

	if (xlate64(lh->sector_xl) != labelsector) {
		log_print("CHECK: label_header.sector expected %d", (int)labelsector);
		bad++;
	}

	crc = calc_crc(INITIAL_CRC, (uint8_t *)&lh->offset_xl,
		       LABEL_SIZE - ((uint8_t *) &lh->offset_xl - (uint8_t *) lh));

	if (crc != xlate32(lh->crc_xl)) {
		log_print("CHECK: label_header.crc expected 0x%x", crc);
		bad++;
	}

	if (xlate32(lh->offset_xl) != 32) {
		log_print("CHECK: label_header.offset expected 32");
		bad++;
	}

	if (memcmp(lh->type, LVM2_LABEL, sizeof(lh->type))) {
		log_print("CHECK: label_header.type expected %s", LVM2_LABEL);
		good_type = 0;
		bad++;
	}

	/* Report a label is found if at least id and type are correct. */
	if (found_label && good_id && good_type)
		*found_label = 1;

	if (bad)
		return 0;
	return 1;
}

static int _check_pv_header(struct pv_header *ph)
{
	struct id id;
	int bad = 0;

	if (!id_read_format_try(&id, (char *)&ph->pv_uuid)) {
		log_print("CHECK: pv_header.pv_uuid invalid format");
		bad++;
	}

	if (bad)
		return 0;
	return 1;
}

/*
 * all sizes and offsets in bytes
 *
 * mda_offset/mda_size are from the pv_header/disk_locn and could
 * be incorrect.
 */
static int _check_mda_header(struct mda_header *mh, int mda_num, uint64_t mda_offset, uint64_t mda_size, int *found_header)
{
	char str[256];
	uint32_t crc;
	int good_magic = 1;
	int bad = 0;

	crc = calc_crc(INITIAL_CRC, (uint8_t *)mh->magic,
		       MDA_HEADER_SIZE - sizeof(mh->checksum_xl));

	if (crc != xlate32(mh->checksum_xl)) {
		log_print("CHECK: mda_header_%d.checksum expected 0x%x", mda_num, crc);
		bad++;
	}

	if (memcmp(mh->magic, FMTT_MAGIC, sizeof(mh->magic))) {
		log_print("CHECK: mda_header_%d.magic expected 0x%s", mda_num, _chars_to_hexstr((const void *)&FMTT_MAGIC, str, 16, 256, "mda_header.magic"));
		good_magic = 0;
		bad++;
	}

	if (xlate32(mh->version) != FMTT_VERSION) {
		log_print("CHECK: mda_header_%d.version expected %u", mda_num, FMTT_VERSION);
		bad++;
	}

	if (xlate64(mh->start) != mda_offset) {
		log_print("CHECK: mda_header_%d.start does not match pv_header.disk_locn.offset %llu", mda_num, (unsigned long long)mda_offset);
		bad++;
	}

	if (xlate64(mh->size) != mda_size) {
		log_print("CHECK: mda_header_%d.size does not match pv_header.disk_locn.size %llu", mda_num, (unsigned long long)mda_size);
		bad++;
	}

	/* Report a header is found if at least magic is correct. */
	if (found_header && good_magic)
		*found_header = 1;

	if (bad)
		return 0;
	return 1;
}

/*
 * all sizes and offsets in bytes
 *
 * mda_offset, mda_size are from pv_header.disk_locn
 * (the location of the metadata area.)
 *
 * meta_offset, meta_size, meta_checksum are from mda_header.raw_locn
 * (the location of the metadata text in the metadata area.)
 */

static int _dump_raw_locn(struct device *dev, struct devicefile *def, int print_fields,
			  struct raw_locn *rlocn, int rlocn_index, uint64_t rlocn_offset,
			  int mda_num, uint64_t mda_offset, uint64_t mda_size,
			  uint64_t *meta_offset_ret,
			  uint64_t *meta_size_ret,
			  uint32_t *meta_checksum_ret)
{
	uint64_t meta_offset, meta_size;
	uint32_t meta_checksum;
	uint32_t meta_flags;
	int bad = 0;
	int mn = mda_num; /* 1 or 2 */
	int ri = rlocn_index; /* 0 or 1 */
	int wrapped = 0;

	meta_offset = xlate64(rlocn->offset);
	meta_size = xlate64(rlocn->size);
	meta_checksum = xlate32(rlocn->checksum);
	meta_flags = xlate32(rlocn->flags);

	if (meta_offset + meta_size > mda_size)
		wrapped = 1;

	if (print_fields) {
		log_print("mda_header_%d.raw_locn[%d] at %llu # %s%s", mn, ri, (unsigned long long)rlocn_offset, (ri == 0) ? "commit" : "precommit", wrapped ? " wrapped" : "");
		log_print("mda_header_%d.raw_locn[%d].offset %llu", mn, ri, (unsigned long long)meta_offset);
		log_print("mda_header_%d.raw_locn[%d].size %llu", mn, ri, (unsigned long long)meta_size);
		log_print("mda_header_%d.raw_locn[%d].checksum 0x%x", mn, ri, meta_checksum);

		if (meta_flags & RAW_LOCN_IGNORED)
			log_print("mda_header_%d.raw_locn[%d].flags 0x%x # RAW_LOCN_IGNORED", mn, ri, meta_flags);
		else
			log_print("mda_header_%d.raw_locn[%d].flags 0x%x", mn, ri, meta_flags);
	}

	/* The precommit pointer will usually be empty. */
	if ((rlocn_index == 1) && meta_offset)
		log_print("CHECK: mda_header_%d.raw_locn[%d] for precommit not empty", mn, ri);

	/* This metadata area is not being used to hold text metadata. */
	/* Old, out of date text metadata may exist if the area was once used. */
	if (meta_flags & RAW_LOCN_IGNORED)
		return 1;

	/*
	 * A valid meta_size can be no larger than the metadata area size minus
	 * the 512 bytes used by the mda_header sector.
	 */
	if (meta_size > (mda_size - 512)) {
		log_print("CHECK: mda_header_%d.raw_locn[%d].size larger than metadata area size", mn, ri);
		/* If meta_size is bad, try to continue using a reasonable value */
		meta_size = (mda_size - 512);
	}

	if (meta_offset_ret)
		*meta_offset_ret = meta_offset;
	if (meta_size_ret)
		*meta_size_ret = meta_size;
	if (meta_checksum_ret)
		*meta_checksum_ret = meta_checksum;

	/* No text metadata exists in this metadata area. */
	if (!meta_offset)
		return 1;

	if (bad)
		return 0;
	return 1;
}

static int _dump_meta_area(struct device *dev, struct devicefile *def, const char *tofile,
			   uint64_t mda_offset, uint64_t mda_size)
{
	FILE *fp;
	char *meta_buf;
	int ret = 1;

	if (!tofile)
		return_0;

	if (!(meta_buf = zalloc(mda_size)))
		return_0;

	if (!_read_bytes(dev, def, mda_offset, mda_size, meta_buf)) {
		log_print("CHECK: failed to read metadata area at offset %llu size %llu",
			  (unsigned long long)mda_offset, (unsigned long long)mda_size);
		free(meta_buf);
		return 0;
	}

	if (!(fp = fopen(tofile, "wx"))) {
		log_error("Failed to create file %s", tofile);
		free(meta_buf);
		return 0;
	}

	if (fwrite(meta_buf, mda_size - 512, 1, fp) != 1) {
		log_error("Failed to write file %s metadata area size %llu.",
			  tofile, (unsigned long long)mda_size);
		ret = 0;
	}

	free(meta_buf);

	if (fflush(fp))
		stack;
	if (fclose(fp))
		stack;
	return ret;
}

/* all sizes and offsets in bytes */

static int _dump_current_text(struct device *dev, struct devicefile *def,
			      int print_fields, int print_metadata, const char *tofile,
			      int mda_num, int rlocn_index,
			      uint64_t mda_offset, uint64_t mda_size,
			      uint64_t meta_offset, uint64_t meta_size,
			      uint32_t meta_checksum)
{
	char *meta_buf;
	struct dm_config_tree *cft;
	char *vgname = NULL;
	uint32_t crc;
	uint32_t seqno = 0;
	int mn = mda_num; /* 1 or 2 */
	int ri = rlocn_index; /* 0 or 1 */
	int bad = 0;

	if (!(meta_buf = zalloc(meta_size))) {
		log_print("CHECK: mda_header_%d.raw_locn[%d] no mem for metadata text size %llu", mn, ri,
			  (unsigned long long)meta_size);
		return 0;
	}

	/*
	 * Read the metadata text specified by the raw_locn so we can
	 * check the raw_locn values.
	 *
	 * meta_offset is the offset from the start of the mda_header,
	 * so the text location from the start of the disk is
	 * mda_offset + meta_offset.
	 */
	if (meta_offset + meta_size > mda_size) {
		/* text metadata wraps to start of text metadata area */
		uint32_t wrap = (uint32_t) ((meta_offset + meta_size) - mda_size);
		off_t offset_a = mda_offset + meta_offset;
		uint32_t size_a = meta_size - wrap;
		off_t offset_b = mda_offset + 512; /* continues after mda_header sector */
		uint32_t size_b = wrap;

		if (!_read_bytes(dev, def, offset_a, size_a, meta_buf)) {
			log_print("CHECK: failed to read metadata text at mda_header_%d.raw_locn[%d].offset %llu size %llu part_a %llu %llu", mn, ri,
				  (unsigned long long)meta_offset, (unsigned long long)meta_size,
				  (unsigned long long)offset_a, (unsigned long long)size_a);
			free(meta_buf);
			return 0;
		}

		if (!_read_bytes(dev, def, offset_b, size_b, meta_buf + size_a)) {
			log_print("CHECK: failed to read metadata text at mda_header_%d.raw_locn[%d].offset %llu size %llu part_b %llu %llu", mn, ri,
				  (unsigned long long)meta_offset, (unsigned long long)meta_size,
				  (unsigned long long)offset_b, (unsigned long long)size_b);
			free(meta_buf);
			return 0;
		}
	} else {
		if (!_read_bytes(dev, def, mda_offset + meta_offset, meta_size, meta_buf)) {
			log_print("CHECK: failed to read metadata text at mda_header_%d.raw_locn[%d].offset %llu size %llu", mn, ri,
				  (unsigned long long)meta_offset, (unsigned long long)meta_size);
			free(meta_buf);
			return 0;
		}
	}

	crc = calc_crc(INITIAL_CRC, (uint8_t *)meta_buf, meta_size);
	if (crc != meta_checksum) {
		log_print("CHECK: metadata text at %llu crc does not match mda_header_%d.raw_locn[%d].checksum",
			  (unsigned long long)(mda_offset + meta_offset), mn, ri);
		bad++;
	}

	if (!(cft = config_open(CONFIG_FILE_SPECIAL, NULL, 0))) {
		log_print("CHECK: failed to set up metadata parsing");
		bad++;
	} else {
		if (!dm_config_parse_without_dup_node_check(cft, meta_buf, meta_buf + meta_size)) {
			log_print("CHECK: failed to parse metadata text at %llu size %llu",
				  (unsigned long long)(mda_offset + meta_offset),
				   (unsigned long long)meta_size);
			bad++;
		} else {
			if (cft->root && cft->root->key)
				vgname = strdup(cft->root->key);
			if (cft->root && cft->root->child)
				dm_config_get_uint32(cft->root->child, "seqno", &seqno);
		}
		config_destroy(cft);
	}

	if (print_fields || print_metadata)
		log_print("metadata text at %llu crc 0x%x # vgname %s seqno %u",
			  (unsigned long long)(mda_offset + meta_offset), crc,
			  vgname ? vgname : "?", seqno);

	if (!print_metadata)
		goto out;

	if (!tofile) {
		log_print("---");
		printf("%s\n", meta_buf);
		log_print("---");
	} else {
		FILE *fp;
		if (!(fp = fopen(tofile, "wx"))) {
			log_error("Failed to create file %s", tofile);
			goto out;
		}

		fprintf(fp, "%s", meta_buf);

		if (fflush(fp))
			stack;
		if (fclose(fp))
			stack;
	}

 out:
	free(meta_buf);
	free(vgname);
	if (bad)
		return 0;
	return 1;
}

/* all sizes and offsets in bytes */

static int _dump_label_and_pv_header(struct cmd_context *cmd, uint64_t labelsector,
				     struct device *dev, struct devicefile *def,
				     int print_fields,
				     int *found_label,
				     uint64_t *mda1_offset, uint64_t *mda1_size,
				     uint64_t *mda2_offset, uint64_t *mda2_size,
				     int *mda_count_out)
{
	char buf[512];
	char str[256];
	struct label_header *lh;
	struct pv_header *pvh;
	struct pv_header_extension *pvhe;
	struct disk_locn *dlocn;
	uint64_t lh_offset;     /* bytes */
	uint64_t pvh_offset;    /* bytes */
	uint64_t pvhe_offset;   /* bytes */
	uint64_t dlocn_offset;  /* bytes */
	uint64_t tmp;
	int mda_count = 0;
	int bad = 0;
	int di;

	lh_offset = labelsector * 512; /* from start of disk */

	if (!_read_bytes(dev, def, lh_offset, 512, buf)) {
		log_print("CHECK: failed to read label_header at %llu",
			  (unsigned long long)lh_offset);
		return 0;
	}

	lh = (struct label_header *)buf;

	if (print_fields) {
		log_print("label_header at %llu", (unsigned long long)lh_offset);
		log_print("label_header.id %s", _chars_to_str(lh->id, str, 8, 256, "label_header.id"));
		log_print("label_header.sector %llu", (unsigned long long)xlate64(lh->sector_xl));
		log_print("label_header.crc 0x%x", xlate32(lh->crc_xl));
		log_print("label_header.offset %u", xlate32(lh->offset_xl));
		log_print("label_header.type %s", _chars_to_str(lh->type, str, 8, 256, "label_header.type"));
	}

	if (!_check_label_header(lh, labelsector, found_label))
		bad++;

	/*
	 * The label_header is 32 bytes in size (size of struct label_header).
	 * The pv_header should begin immediately after the label_header.
	 * The label_header.offset gives the offset of pv_header from the
	 * start of the label_header, which should always be 32.
	 *
	 * If label_header.offset is corrupted, then we should print a
	 * warning about the bad value, and read the pv_header from the
	 * correct location instead of the bogus location.
	 */

	pvh = (struct pv_header *)(buf + 32);
	pvh_offset = lh_offset + 32; /* from start of disk */

	/* sanity check */
	if ((void *)pvh != (void *)(buf + pvh_offset - lh_offset))
		log_print("CHECK: problem with pv_header offset calculation");

	if (print_fields) {
		log_print("pv_header at %llu", (unsigned long long)pvh_offset);
		log_print("pv_header.pv_uuid %s", _chars_to_str(pvh->pv_uuid, str, ID_LEN, 256, "pv_header.pv_uuid"));
		log_print("pv_header.device_size %llu", (unsigned long long)xlate64(pvh->device_size_xl));
	}

	if (!_check_pv_header(pvh))
		bad++;

	/*
	 * The pv_header is 40 bytes, excluding disk_locn's.
	 * disk_locn structs immediately follow the pv_header.
	 * Each disk_locn is 16 bytes.
	 */
	di = 0;
	dlocn = pvh->disk_areas_xl;
	dlocn_offset = pvh_offset + 40; /* from start of disk */

	/* sanity check */
	if ((void *)dlocn != (void *)(buf + dlocn_offset - lh_offset))
		log_print("CHECK: problem with pv_header.disk_locn[%d] offset calculation", di);

	while ((tmp = xlate64(dlocn->offset))) {
		if (print_fields) {
			log_print("pv_header.disk_locn[%d] at %llu # location of data area", di,
				  (unsigned long long)dlocn_offset);
			log_print("pv_header.disk_locn[%d].offset %llu", di,
				  (unsigned long long)xlate64(dlocn->offset));
			log_print("pv_header.disk_locn[%d].size %llu", di,
				  (unsigned long long)xlate64(dlocn->size));
		}
		di++;
		dlocn++;
		dlocn_offset += 16;
	}

	/* all-zero dlocn struct is area list end */
	if (print_fields) {
		log_print("pv_header.disk_locn[%d] at %llu # location list end", di,
			  (unsigned long long) dlocn_offset);
		log_print("pv_header.disk_locn[%d].offset %llu", di,
			  (unsigned long long)xlate64(dlocn->offset));
		log_print("pv_header.disk_locn[%d].size %llu", di,
			  (unsigned long long)xlate64(dlocn->size));
	}

	/* advance past the all-zero dlocn struct */
	di++;
	dlocn++;
	dlocn_offset += 16;

	/* sanity check */
	if ((void *)dlocn != (void *)(buf + dlocn_offset - lh_offset))
		log_print("CHECK: problem with pv_header.disk_locn[%d] offset calculation", di);

	while ((tmp = xlate64(dlocn->offset))) {
		if (print_fields) {
			log_print("pv_header.disk_locn[%d] at %llu # location of metadata area", di,
				  (unsigned long long)dlocn_offset);
			log_print("pv_header.disk_locn[%d].offset %llu", di,
				  (unsigned long long)xlate64(dlocn->offset));
			log_print("pv_header.disk_locn[%d].size %llu", di,
				  (unsigned long long)xlate64(dlocn->size));
		}

		if (!mda_count) {
			*mda1_offset = xlate64(dlocn->offset);
			*mda1_size = xlate64(dlocn->size);

			/*
			 * mda1 offset is page size from machine that created it,
			 * warn if it's not one of the expected page sizes.
			 */
			if ((*mda1_offset != 4096) && (*mda1_offset != 8192) && (*mda1_offset != 65536)) {
				log_print("WARNING: pv_header.disk_locn[%d].offset %llu is unexpected # for first mda",
					  di, (unsigned long long)*mda1_offset);
			}
		} else {
			*mda2_offset = xlate64(dlocn->offset);
			*mda2_size = xlate64(dlocn->size);

			/*
			 * No fixed location for second mda, so we have to look for
			 * mda_header at this offset to see if it's correct.
			 */
		}

		di++;
		dlocn++;
		dlocn_offset += 16;
		mda_count++;
	}

	*mda_count_out = mda_count;

	/* all-zero dlocn struct is area list end */
	if (print_fields) {
		log_print("pv_header.disk_locn[%d] at %llu # location list end", di,
			  (unsigned long long) dlocn_offset);
		log_print("pv_header.disk_locn[%d].offset %llu", di,
			  (unsigned long long)xlate64(dlocn->offset));
		log_print("pv_header.disk_locn[%d].size %llu", di,
			  (unsigned long long)xlate64(dlocn->size));
	}

	/* advance past the all-zero dlocn struct */
	di++;
	dlocn++;
	dlocn_offset += 16;

	/*
	 * pv_header_extension follows the last disk_locn
	 * terminating struct, so it's not always at the
	 * same location.
	 */

	pvhe = (struct pv_header_extension *)dlocn;
	pvhe_offset = dlocn_offset; /* from start of disk */

	/* sanity check */
	if ((void *)pvhe != (void *)(buf + pvhe_offset - lh_offset))
		log_print("CHECK: problem with pv_header_extension offset calculation");

	if (print_fields) {
		log_print("pv_header_extension at %llu", (unsigned long long)pvhe_offset);
		log_print("pv_header_extension.version %u", xlate32(pvhe->version));
		log_print("pv_header_extension.flags %u", xlate32(pvhe->flags));
	}

	/*
	 * The pv_header_extension is 8 bytes, excluding disk_locn's.
	 * disk_locn structs immediately follow the pv_header_extension.
	 * Each disk_locn is 16 bytes.
	 */
	di = 0;
	dlocn = pvhe->bootloader_areas_xl;
	dlocn_offset = pvhe_offset + 8;

	while ((tmp = xlate64(dlocn->offset))) {
		if (print_fields) {
			log_print("pv_header_extension.disk_locn[%d] at %llu # bootloader area", di,
				  (unsigned long long)dlocn_offset);
			log_print("pv_header_extension.disk_locn[%d].offset %llu", di,
				  (unsigned long long)xlate64(dlocn->offset));
			log_print("pv_header_extension.disk_locn[%d].size %llu", di,
				  (unsigned long long)xlate64(dlocn->size));
		}

		di++;
		dlocn++;
		dlocn_offset += 16;
	}

	/* all-zero dlocn struct is area list end */
	if (print_fields) {
		log_print("pv_header_extension.disk_locn[%d] at %llu # location list end", di,
			  (unsigned long long) dlocn_offset);
		log_print("pv_header_extension.disk_locn[%d].offset %llu", di,
			  (unsigned long long)xlate64(dlocn->offset));
		log_print("pv_header_extension.disk_locn[%d].size %llu", di,
			  (unsigned long long)xlate64(dlocn->size));
	}

	if (bad)
		return 0;
	return 1;
}

/*
 * all sizes and offsets in bytes
 *
 * mda_offset and mda_size are the location/size of the metadata area,
 * which starts with the mda_header and continues through the circular
 * buffer of text.
 *
 * mda_offset and mda_size values come from the pv_header/disk_locn,
 * which could be incorrect.
 *
 * We know that the first mda_offset will always be 4096, so we use
 * that value regardless of what the first mda_offset value in the
 * pv_header is.
 */

static int _dump_mda_header(struct cmd_context *cmd, struct settings *set,
			    int print_fields, int print_metadata, int print_area,
			    const char *tofile,
			    struct device *dev, struct devicefile *def,
			    uint64_t mda_offset, uint64_t mda_size,
			    uint32_t *checksum0_ret,
			    int *found_header)
{
	char buf[512];
	char str[256];
	char *mda_buf;
	struct mda_header *mh;
	struct raw_locn *rlocn0, *rlocn1;
	uint64_t rlocn0_offset, rlocn1_offset;
	uint64_t meta_offset = 0; /* bytes */
	uint64_t meta_size = 0;   /* bytes */
	uint32_t meta_checksum = 0;
	int mda_num = (mda_offset == 4096) ? 1 : 2;
	int bad = 0;

	*checksum0_ret = 0; /* checksum from raw_locn[0] */

	/*
	 * The first mda_header is 4096 bytes from the start
	 * of the device.  Each mda_header is 512 bytes.
	 *
	 * The start/size values in the mda_header should
	 * match the mda_offset/mda_size values that came
	 * from the pv_header/disk_locn.
	 *
	 * (Why was mda_header magic made only partially printable?)
	 */

	if (!_read_bytes(dev, def, mda_offset, 512, buf)) {
		log_print("CHECK: failed to read mda_header at %llu", (unsigned long long)mda_offset);
		return 0;
	}

	mh = (struct mda_header *)buf;

	if (print_fields) {
		log_print("mda_header_%d at %llu # metadata area", mda_num, (unsigned long long)mda_offset);
		log_print("mda_header_%d.checksum 0x%x", mda_num, xlate32(mh->checksum_xl));
		log_print("mda_header_%d.magic 0x%s", mda_num, _chars_to_hexstr(mh->magic, str, 16, 256, "mda_header.magic"));
		log_print("mda_header_%d.version %u", mda_num, xlate32(mh->version));
		log_print("mda_header_%d.start %llu", mda_num, (unsigned long long)xlate64(mh->start));
		log_print("mda_header_%d.size %llu", mda_num, (unsigned long long)xlate64(mh->size));
	}

	if (!_check_mda_header(mh, mda_num, mda_offset, mda_size, found_header))
		bad++;

	if (print_area) {
		if (!_dump_meta_area(dev, def, tofile, mda_offset, mda_size))
			bad++;
		goto out;
	}

	/*
	 * mda_header is 40 bytes, the raw_locn structs
	 * follow immediately after, each raw_locn struct
	 * is 24 bytes.
	 */

	rlocn0 = mh->raw_locns;
	rlocn0_offset = mda_offset + 40; /* from start of disk */

	/* sanity check */
	if ((void *)rlocn0 != (void *)(buf + rlocn0_offset - mda_offset))
		log_print("CHECK: problem with rlocn0 offset calculation");

	meta_offset = 0;
	meta_size = 0;
	meta_checksum = 0;

	if (!_dump_raw_locn(dev, def, print_fields, rlocn0, 0, rlocn0_offset, mda_num, mda_offset, mda_size,
			    &meta_offset, &meta_size, &meta_checksum))
		bad++;

	*checksum0_ret = meta_checksum;

	rlocn1 = (struct raw_locn *)((char *)mh->raw_locns + 24);
	rlocn1_offset = rlocn0_offset + 24;

	/* sanity check */
	if ((void *)rlocn1 != (void *)(buf + rlocn1_offset - mda_offset))
		log_print("CHECK: problem with rlocn1 offset calculation");

	if (!_dump_raw_locn(dev, def, print_fields, rlocn1, 1, rlocn1_offset, mda_num, mda_offset, mda_size,
			   NULL, NULL, NULL))
		bad++;

	if (!meta_offset)
		goto out;

	/*
	 * looking at the current copy of metadata referenced by raw_locn
	 */
	if (print_metadata <= PRINT_CURRENT) {
		if (!_dump_current_text(dev, def, print_fields, print_metadata, tofile, mda_num, 0, mda_offset, mda_size, meta_offset, meta_size, meta_checksum))
			bad++;
	}

	/*
	 * looking at all copies of the metadata in the area
	 */
	if (print_metadata == PRINT_ALL) {
		if (!(mda_buf = zalloc(mda_size)))
			goto_out;

		if (!_read_bytes(dev, def, mda_offset, mda_size, mda_buf)) {
			log_print("CHECK: failed to read metadata area at offset %llu size %llu",
				  (unsigned long long)mda_offset, (unsigned long long)mda_size);
			bad++;
			free(mda_buf);
			goto out;
		}

		_dump_all_text(cmd, set, tofile, dev, def, mda_num, mda_offset, mda_size, mda_buf);
		free(mda_buf);
	}

	/* Should we also check text metadata if it exists in rlocn1? */
 out:
	if (bad)
		return 0;
	return 1;
}

/* all sizes and offsets in bytes */

static int _dump_headers(struct cmd_context *cmd, const char *dump, struct settings *set,
			 uint64_t labelsector, struct device *dev, struct devicefile *def)
{
	uint64_t mda1_offset = 0, mda1_size = 0, mda2_offset = 0, mda2_size = 0; /* bytes */
	uint32_t mda1_checksum, mda2_checksum;
	int mda_count = 0;
	int bad = 0;

	if (!_dump_label_and_pv_header(cmd, labelsector, dev, def, 1, NULL,
			&mda1_offset, &mda1_size, &mda2_offset, &mda2_size, &mda_count))
		bad++;

	if (!mda_count) {
		log_print("zero metadata copies");
		return 1;
	}

	/*
	 * The first mda is usually 4096 bytes from the start of the device.
	 * (If created by a machine with larger pages it could be 8k/16k/64k.)
	 */
	if (!_dump_mda_header(cmd, set, 1, 0, 0, NULL, dev, def, mda1_offset, mda1_size, &mda1_checksum, NULL))
		bad++;

	if (mda2_offset) {
		if (!_dump_mda_header(cmd, set, 1, 0, 0, NULL, dev, def, mda2_offset, mda2_size, &mda2_checksum, NULL))
			bad++;

		/* This probably indicates that one was committed and the other not. */
		if (mda1_checksum && mda2_checksum && (mda1_checksum != mda2_checksum))
			log_print("CHECK: mdas have different raw_locn[0].checksum values");
	}

	if (bad) {
		log_error("Found bad header or metadata values.");
		return 0;
	}
	return 1;
}

/* all sizes and offsets in bytes */

static int _dump_metadata(struct cmd_context *cmd, const char *dump, struct settings *set,
			 uint64_t labelsector, struct device *dev, struct devicefile *def,
			 int print_metadata, int print_area)
{
	const char *tofile = NULL;
	uint64_t mda1_offset = 0, mda1_size = 0, mda2_offset = 0, mda2_size = 0; /* bytes */
	uint32_t mda1_checksum, mda2_checksum;
	int mda_count = 0;
	int mda_num = 1;
	int bad = 0;

	if (arg_is_set(cmd, file_ARG)) {
		if (!(tofile = arg_str_value(cmd, file_ARG, NULL)))
			return 0;
	}

	if (set->mda_num)
		mda_num = set->mda_num;
	else if (arg_is_set(cmd, pvmetadatacopies_ARG))
		mda_num = arg_int_value(cmd, pvmetadatacopies_ARG, 1);

	if (!_dump_label_and_pv_header(cmd, labelsector, dev, def, 0, NULL,
			&mda1_offset, &mda1_size, &mda2_offset, &mda2_size, &mda_count))
		bad++;

	if (!mda_count) {
		log_print("zero metadata copies");
		return 1;
	}

	/*
	 * The first mda is always 4096 bytes from the start of the device.
	 */
	if (mda_num == 1) {
		if (!_dump_mda_header(cmd, set, 0, print_metadata, print_area, tofile, dev, def, mda1_offset, mda1_size, &mda1_checksum, NULL))
			bad++;
	} else if (mda_num == 2) {
		if (!mda2_offset) {
			log_print("CHECK: second mda not found");
			bad++;
		} else {
			if (!_dump_mda_header(cmd, set, 0, print_metadata, print_area, tofile, dev, def, mda2_offset, mda2_size, &mda2_checksum, NULL))
				bad++;
		}
	}

	if (bad) {
		log_error("Found bad header or metadata values.");
		return 0;
	}
	return 1;
}

/* all sizes and offsets in bytes */

static int _dump_found(struct cmd_context *cmd, struct settings *set, uint64_t labelsector, struct device *dev)
{
	uint64_t mda1_offset = 0, mda1_size = 0, mda2_offset = 0, mda2_size = 0; /* bytes */
	uint32_t mda1_checksum = 0, mda2_checksum = 0;
	int found_label = 0, found_header1 = 0, found_header2 = 0;
	int mda_count = 0;
	int bad = 0;

	if (!_dump_label_and_pv_header(cmd, labelsector, dev, NULL, 0, &found_label,
			&mda1_offset, &mda1_size, &mda2_offset, &mda2_size, &mda_count))
		bad++;

	if (found_label && mda1_offset) {
		if (!_dump_mda_header(cmd, set, 0, 0, 0, NULL, dev, NULL, mda1_offset, mda1_size, &mda1_checksum, &found_header1))
			bad++;
	}

	if (found_label && mda2_offset) {
		if (!_dump_mda_header(cmd, set, 0, 0, 0, NULL, dev, NULL, mda2_offset, mda2_size, &mda2_checksum, &found_header2))
			bad++;
	}

	if (found_label)
		log_print("Found label on %s, sector %llu, type=LVM2 001",
			  dev_name(dev), (unsigned long long)labelsector);
	else {
		log_error("Could not find LVM label on %s", dev_name(dev));
		return 0;
	}

	if (found_header1)
		log_print("Found text metadata area: offset=%llu, size=%llu",
			  (unsigned long long)mda1_offset,
			  (unsigned long long)mda1_size);

	if (found_header2)
		log_print("Found text metadata area: offset=%llu, size=%llu",
			  (unsigned long long)mda2_offset,
			  (unsigned long long)mda2_size);

	if (bad)
		return 0;
	return 1;
}

/*
 * all sizes and offsets in bytes (except dev_sectors from dev_get_size)
 *
 * Look for metadata text in common locations, without using any headers
 * (pv_header/mda_header) to find the location, since the headers may be
 * zeroed/damaged.
 */

static int _dump_search(struct cmd_context *cmd, const char *dump, struct settings *set,
			uint64_t labelsector, struct device *dev, struct devicefile *def)
{
	const char *tofile = NULL;
	char *buf;
	uint64_t mda1_offset = 0, mda1_size = 0, mda2_offset = 0, mda2_size = 0; /* bytes */
	uint64_t mda_offset = 0, mda_size = 0; /* bytes */
	int mda_num = 0;
	int found_label = 0;
	int mda_count = 0;
	int set_vals = 0;

	if (arg_is_set(cmd, file_ARG)) {
		if (!(tofile = arg_str_value(cmd, file_ARG, NULL)))
			return_0;
	}

	_dump_label_and_pv_header(cmd, labelsector, dev, def, 0, &found_label,
			&mda1_offset, &mda1_size, &mda2_offset, &mda2_size, &mda_count);

	/*
	 * For mda1, mda_offset is always 4096 bytes from the start of
	 * device, and mda_size is the space between mda_offset and
	 * the first PE which is usually at 1MB.
	 *
	 * For mda2, take the dev_size, reduce that to be a 1MB
	 * multiple.  The mda_offset is then 1MB prior to that,
	 * and mda_size is the amount of space between that offset
	 * and the end of the device.
	 *
	 * The second mda is generally 4K larger (at least) than the
	 * first mda because the first mda begins at a 4K offset from
	 * the start of the device and ends on a 1MB boundary.
	 * The second mda begins on a 1MB boundary (no 4K offset like
	 * mda1), then goes to the end of the device.  Extra space
	 * at the end of device (mod 1MB extra) can make mda2 even
	 * larger.
	 */

	/*
	 * When mda offset or size is set in command line settings,
	 * use what is set and calculate an unspecified value.
	 */
	if (set->mda_offset_set || set->mda_size_set) {
		if (set->mda_offset_set) {
			mda_offset = set->mda_offset;
			set_vals++;
		}
		if (set->mda_size_set) {
			mda_size = set->mda_size;
			set_vals++;
		}
		if ((mda_num = set->mda_num))
			set_vals++;

		if (mda_offset && mda_size)
			goto search;

		if (set_vals < 2) {
			log_error("Specify at least two values from: mda_num, mda_offset, mda_size.");
			return 0;
		}

		if (!mda_size) {
			if ((mda_num == 1) && mda1_size)
				mda_size = mda1_size; /* from headers */
			else if ((mda_num == 2) && mda2_size)
				mda_size = mda2_size; /* from headers */
			else if (mda_num == 1)
				mda_size = ONE_MB_IN_BYTES - 4096;
			else if (mda_num == 2)
				mda_size = mda2_size_from_offset(dev, mda_offset);
		}
		if (!mda_offset) {
			if (mda_num == 1)
				mda_offset = 4096;
			else if (mda_num == 2)
				mda_offset = mda2_offset_from_size(dev, mda_size);
		}

		if (set->mda2_offset_set || set->mda2_size_set)
			log_print("Ignoring mda2 values from settings.");

		goto search;
	}
	if (set->mda2_offset_set || set->mda2_size_set) {
		if (set->mda2_offset_set) {
			mda_offset = set->mda2_offset;
			set_vals++;
		}
		if (set->mda_size_set) {
			mda_size = set->mda2_size;
			set_vals++;
		}
		if ((mda_num = set->mda_num))
			set_vals++;

		if (mda_offset && mda_size)
			goto search;

		if (set_vals < 2) {
			log_error("Specify at least two values from: mda_num, mda2_offset, mda2_size.");
			return 0;
		}

		if (mda_num == 1) {
			log_error("Invalid mda_num=1 and mda2 settings.");
			return 0;
		}

		if (!mda_size) {
			if (mda2_size)
				mda_size = mda2_size; /* from headers */
			else
				mda_size = mda2_size_from_offset(dev, mda_offset);
		}
		if (!mda_offset) {
			if (mda2_offset)
				mda_offset = mda2_offset; /* from headers */
			else
				mda_offset = mda2_offset_from_size(dev, mda_size);
		}

		goto search;
	}

	/*
	 * When no mda offset or size is set in command line settings,
	 * the user can just set mda_num=1|2 to control if we pick defaults
	 * for mda1 or mda2.  If unspecified, we search in the first mda.
	 */
	if (set->mda_num)
		mda_num = set->mda_num;
	else if (arg_is_set(cmd, pvmetadatacopies_ARG))
		mda_num = arg_int_value(cmd, pvmetadatacopies_ARG, 1);
	else
		mda_num = 1;

	/*
	 * No mda offset or size was set in command line settings,
	 * so we use what's in the headers or defaults.
	 */
	if ((mda_num == 1) && found_label && mda1_offset && mda1_size) {
		/* use header values when available */
		mda_offset = mda1_offset;
		mda_size = mda1_size;

	} else if (mda_num == 1) {
		/* use default values when header values are not available */
		mda_offset = 4096;
		mda_size = ONE_MB_IN_BYTES - 4096;

		log_print("Using common defaults for first mda: offset %llu size %llu.",
			  (unsigned long long)mda_offset, (unsigned long long)mda_size);
		log_print("Override defaults with --settings \"mda_offset=<bytes> mda_size=<bytes>\"");

	} else if ((mda_num == 2) && found_label && mda2_offset && mda2_size) {
		/* use header values when available */
		mda_offset = mda2_offset;
		mda_size = mda2_size;

	} else if (mda_num == 2) {
		/* use default values when header values are not available */
		uint64_t dev_sectors = 0;
		uint64_t dev_bytes;
		uint64_t extra_bytes;

		if (dev_get_size(dev, &dev_sectors))
			stack;

		dev_bytes = dev_sectors * 512;
		extra_bytes = dev_bytes % ONE_MB_IN_BYTES;

		if (dev_bytes < (2 * ONE_MB_IN_BYTES))
			return_0;

		mda_offset = dev_bytes - extra_bytes - ONE_MB_IN_BYTES;
		mda_size = dev_bytes - mda_offset;

		log_print("Using defaults for second mda: offset %llu size %llu.",
			  (unsigned long long)mda_offset, (unsigned long long)mda_size);
		log_print("Override defaults with --settings \"mda_offset=<bytes> mda_size=<bytes>\"");
	} else {
		log_error("No mda location.");
		return 0;
	}

 search:
	if ((mda_num == 1) && ((mda1_offset && mda1_offset != mda_offset) || (mda1_size && mda1_size != mda_size))) {
		log_print("Ignoring mda1_offset %llu mda1_size %llu from pv_header.",
			  (unsigned long long)mda1_offset,
			  (unsigned long long)mda1_size);
	}

	if ((mda_num == 2) && ((mda2_offset && mda2_offset != mda_offset) || (mda2_size && mda2_size != mda_size))) {
		log_print("Ignoring mda2_offset %llu mda2_size %llu from pv_header.",
			  (unsigned long long)mda2_offset,
			  (unsigned long long)mda2_size);
	}

	log_print("Searching for metadata at offset %llu size %llu",
		  (unsigned long long)mda_offset, (unsigned long long)mda_size);

	if (!(buf = zalloc(mda_size)))
		return_0;

	if (!_read_bytes(dev, def, mda_offset, mda_size, buf)) {
		log_print("CHECK: failed to read metadata area at offset %llu size %llu",
			   (unsigned long long)mda_offset, (unsigned long long)mda_size);
		free(buf);
		return 0;
	}

	_dump_all_text(cmd, set, tofile, dev, def, mda_num, mda_offset, mda_size, buf);

	free(buf);
	return 1;
}

/* all sizes and offsets in bytes */

static int _get_one_setting(struct cmd_context *cmd, struct settings *set, char *key, char *val)
{
	if (!strncmp(key, "metadata_offset", strlen("metadata_offset"))) {
		if (sscanf(val, "%llu", (unsigned long long *)&set->metadata_offset) != 1)
			goto_bad;
		set->metadata_offset_set = 1;
		return 1;
	}

	if (!strncmp(key, "seqno", strlen("seqno"))) {
		if (sscanf(val, "%u", &set->seqno) != 1)
			goto_bad;
		set->seqno_set = 1;
		return 1;
	}

	if (!strncmp(key, "backup_file", strlen("backup_file"))) {
		if ((set->backup_file = strdup(val)))
			return 1;
		return 0;
	}

	if (!strncmp(key, "mda_offset", strlen("mda_offset"))) {
		if (sscanf(val, "%llu", (unsigned long long *)&set->mda_offset) != 1)
			goto_bad;
		set->mda_offset_set = 1;
		return 1;
	}

	if (!strncmp(key, "mda_size", strlen("mda_size"))) {
		if (sscanf(val, "%llu", (unsigned long long *)&set->mda_size) != 1)
			goto_bad;
		set->mda_size_set = 1;
		return 1;
	}

	if (!strncmp(key, "mda2_offset", strlen("mda2_offset"))) {
		if (sscanf(val, "%llu", (unsigned long long *)&set->mda2_offset) != 1)
			goto_bad;
		set->mda2_offset_set = 1;
		return 1;
	}

	if (!strncmp(key, "mda2_size", strlen("mda2_size"))) {
		if (sscanf(val, "%llu", (unsigned long long *)&set->mda2_size) != 1)
			goto_bad;
		set->mda2_size_set = 1;
		return 1;
	}

	if (!strncmp(key, "device_size", strlen("device_size"))) {
		if (sscanf(val, "%llu", (unsigned long long *)&set->device_size) != 1)
			goto_bad;
		set->device_size_set = 1;
		return 1;
	}

	if (!strncmp(key, "data_offset", strlen("data_offset"))) {
		if (sscanf(val, "%llu", (unsigned long long *)&set->data_offset) != 1)
			goto_bad;
		set->data_offset_set = 1;
		return 1;
	}

	if (!strncmp(key, "pv_uuid", strlen("pv_uuid"))) {
		if (strchr(val, '-') && (strlen(val) == 32)) {
			memcpy(&set->pvid, val, 32);
			set->pvid_set = 1;
			return 1;
		} else if (id_read_format_try(&set->pvid, val)) {
			set->pvid_set = 1;
			return 1;
		} else {
			log_error("Failed to parse UUID from pv_uuid setting.");
			goto bad;
		}
	}

	if (!strncmp(key, "mda_num", strlen("mda_num"))) {
		if (sscanf(val, "%u", (int *)&set->mda_num) != 1)
			goto_bad;
		return 1;
	}
bad:
	log_error("Invalid setting: %s", key);
	return 0;
}

static int _get_settings(struct cmd_context *cmd, struct settings *set)
{
	struct arg_value_group_list *group;
	const char *str;
	char key[64];
	char val[64];
	int num;
	int pos;

	/*
	 * "grouped" means that multiple --settings options can be used.
	 * Each option is also allowed to contain multiple key = val pairs.
	 */

	dm_list_iterate_items(group, &cmd->arg_value_groups) {
		if (!grouped_arg_is_set(group->arg_values, settings_ARG))
			continue;

		if (!(str = grouped_arg_str_value(group->arg_values, settings_ARG, NULL)))
			break;

		pos = 0;

		while (pos < strlen(str)) {
			/* scan for "key1=val1 key2 = val2  key3= val3" */

			memset(key, 0, sizeof(key));
			memset(val, 0, sizeof(val));

			if (sscanf(str + pos, " %63[^=]=%63s %n", key, val, &num) != 2) {
				log_error("Invalid setting at: %s", str+pos);
				return 0;
			}

			pos += num;

			if (!_get_one_setting(cmd, set, key, val))
				return_0;
		}
	}

	return 1;
}

/*
 * pvck --repairtype label_header
 *
 * Writes new label_header without changing pv_header fields.
 * All constant values except for recalculated crc.
 *
 * all sizes and offsets in bytes
 */

static int _repair_label_header(struct cmd_context *cmd, const char *repair,
			        struct settings *set, uint64_t labelsector, struct device *dev)
{
	char buf[512];
	struct label_header *lh;
	struct pv_header *pvh;
	uint64_t mda1_offset = 0, mda1_size = 0, mda2_offset = 0, mda2_size = 0; /* bytes */
	uint64_t lh_offset;  /* bytes */
	uint64_t pvh_offset; /* bytes */
	uint32_t crc;
	int mda_count;
	int found_label = 0;

	lh_offset = labelsector * 512; /* from start of disk */

	_dump_label_and_pv_header(cmd, labelsector, dev, NULL, 0, &found_label,
			&mda1_offset, &mda1_size, &mda2_offset, &mda2_size, &mda_count);

	if (!found_label) {
		log_warn("WARNING: No LVM label found on %s.  It may not be an LVM device.", dev_name(dev));
		if (!arg_count(cmd, yes_ARG) &&
		    yes_no_prompt("Write LVM header to device? ") == 'n')
			return 0;
	}

	if (!dev_read_bytes(dev, lh_offset, 512, buf)) {
	        log_error("Failed to read label_header at %llu", (unsigned long long)lh_offset);
	        return 0;
	}

	lh = (struct label_header *)buf;
	pvh = (struct pv_header *)(buf + 32);
	pvh_offset = lh_offset + 32; /* from start of disk */

	/* sanity check */
	if ((void *)pvh != (void *)(buf + pvh_offset - lh_offset)) {
	        log_error("Problem with pv_header offset calculation");
	        return 0;
	}

	memcpy(lh->id, LABEL_ID, sizeof(lh->id));
	memcpy(lh->type, LVM2_LABEL, sizeof(lh->type));
	lh->sector_xl =  xlate64(labelsector);
	lh->offset_xl = xlate32(32);

	crc = calc_crc(INITIAL_CRC, (uint8_t *)&lh->offset_xl,
	               LABEL_SIZE - ((uint8_t *) &lh->offset_xl - (uint8_t *) lh));

	lh->crc_xl = xlate32(crc);
       
	log_print("Writing label_header.crc 0x%08x", crc);

	if (arg_is_set(cmd, test_ARG)) {
		log_warn("Skip writing in test mode.");
		return 1;
	}

	if (!arg_count(cmd, yes_ARG) &&
	    yes_no_prompt("Write new LVM header to %s? ", dev_name(dev)) == 'n')
		return 0;

	if (!dev_write_bytes(dev, lh_offset, 512, buf)) {
	        log_error("Failed to write new header");
	        return 0;
	}
	return 1;
}

static int _get_pv_info_from_metadata(struct cmd_context *cmd, struct settings *set,
				     struct device *dev,
				     struct pv_header *pvh, int found_label,
				     char *text_buf, uint64_t text_size,
				     char *pvid,
				     uint64_t *device_size_sectors,
				     uint64_t *pe_start_sectors)
{
	int8_t pvid_cur[ID_LEN+1];  /* found in existing pv_header */
	int8_t pvid_set[ID_LEN+1];  /* set by user in --settings */
	int8_t pvid_use[ID_LEN+1];  /* the pvid chosen to use */
	int pvid_cur_valid = 0;     /* pvid_cur is valid */
	int pvid_use_valid = 0;     /* pvid_use is valid */
	struct dm_config_tree *cft = NULL;
	struct volume_group *vg = NULL;
	struct pv_list *pvl;

	memset(pvid_cur, 0, sizeof(pvid_cur));
	memset(pvid_set, 0, sizeof(pvid_set));
	memset(pvid_use, 0, sizeof(pvid_use));

	/*
	 * Check if there's a valid existing PV UUID at the expected location.
	 */
	if (!id_read_format_try((struct id *)&pvid_cur, (char *)&pvh->pv_uuid))
		memset(&pvid_cur, 0, ID_LEN);
	else {
		memcpy(&pvid_use, &pvid_cur, ID_LEN);
		pvid_use_valid = 1;
		pvid_cur_valid = 1;
	}

	if (set->pvid_set) {
		memcpy(&pvid_set, &set->pvid, ID_LEN);
		memcpy(&pvid_use, &pvid_set, ID_LEN);
		pvid_use_valid = 1;
	}

	if (pvid_cur_valid && set->pvid_set && memcmp(&pvid_cur, &pvid_set, ID_LEN)) {
		log_warn("WARNING: existing PV UUID %s does not match pv_uuid setting %s.",
			 (char *)&pvid_cur, (char *)&pvid_set);

		memcpy(&pvid_use, &pvid_set, ID_LEN);
		pvid_use_valid = 1;
	}

	if (!_text_buf_parse(text_buf, text_size, &cft)) {
		log_error("Invalid metadata file.");
		return 0;
	}

	if (!(vg = vg_from_config_tree(cmd, cft))) {
		config_destroy(cft);
		log_error("Invalid metadata file.");
		return 0;
	}

	config_destroy(cft);

	/*
	 * If pvid_use is set, look for metadata PV section with matching PV UUID.
	 * Otherwise, look for metadata PV section with device name matching dev.
	 *
	 * pvid_use will be empty if there's no valid UUID in the existing
	 * pv_header, and the user did not specify a UUID in --settings.
	 *
	 * Choosing the PV UUID based only on a matching device name is somewhat
	 * weak since device names are dynamic, but we do scan devs to verify the
	 * chosen PV UUID is not in use elsewhere, which should avoid most of the
	 * risk of picking a wrong UUID.
	 */
	if (!pvid_use_valid) {
		dm_list_iterate_items(pvl, &vg->pvs) {
			if (!strcmp(pvl->pv->device_hint, dev_name(dev)))
				goto copy_pv;
		}
	} else {
		dm_list_iterate_items(pvl, &vg->pvs) {
			if (id_equal(&pvl->pv->id, (struct id *)&pvid_use))
				goto copy_pv;
		}
	}

	release_vg(vg);

	/*
	 * Don't know what PV UUID to use, possibly:
	 * . the user set a PV UUID that does not exist in the metadata file
	 * . the UUID in the existing pv_header does not exist in the metadata file
	 * . the metadata has no PV with a device name hint matching this device
	 */
	if (set->pvid_set)
		log_error("PV UUID %s not found in metadata file.", (char *)&pvid_set);
	else if (pvid_cur_valid)
		log_error("PV UUID %s in existing pv_header not found in metadata file.", (char *)&pvid_cur);
	else if (!pvid_use_valid)
		log_error("PV name %s not found in metadata file.", dev_name(dev));

	log_error("No valid PV UUID, specify a PV UUID from metadata in --settings.");
	return 0;

 copy_pv:
	*device_size_sectors = pvl->pv->size;
	*pe_start_sectors = pvl->pv->pe_start;
	memcpy(pvid, &pvl->pv->id, ID_LEN);

	release_vg(vg);
	return 1;
}

/*
 * Checking for mda1 is simple because it's always at the same location,
 * and when a PV is set to use zero metadata areas, this space is just
 * unused.  We could look for any surviving metadata text in mda1
 * containing the VG UUID to confirm that this PV has been used for
 * metadata, but if the start of the disk has been zeroed, then we
 * may not find any.
 */
static int _check_for_mda1(struct cmd_context *cmd, struct device *dev)
{
	char buf[512];
	struct mda_header *mh;

	if (!dev_read_bytes(dev, 4096, 512, buf))
		return_0;

	mh = (struct mda_header *)buf;

	if (!memcmp(mh->magic, FMTT_MAGIC, sizeof(mh->magic)))
		return 1;
	return 0;
}

/*
 * Checking for mda2 is more complicated.  Very often PVs will not use
 * a second mda2, and the location is not quite as predictable.  Also,
 * if we mistakenly conclude that an mda2 belongs on the PV, we'd end
 * up writing into the data area.
 *
 * all sizes and offsets in bytes
 */
static int _check_for_mda2(struct cmd_context *cmd, struct device *dev,
			   uint64_t device_size, struct metadata_file *mf,
			   uint64_t *mda2_offset, uint64_t *mda2_size)
{
	struct mda_header *mh;
	char buf2[256];
	char *buf;
	uint64_t mda_offset, mda_size, extra_bytes; /* bytes */
	int i, found = 0;

	if (device_size < (2 * ONE_MB_IN_BYTES))
		return_0;

	extra_bytes = device_size % ONE_MB_IN_BYTES;
	mda_offset = device_size - extra_bytes - ONE_MB_IN_BYTES;
	mda_size = device_size - mda_offset;

	if (!(buf = malloc(mda_size)))
		return_0;

	if (!dev_read_bytes(dev, mda_offset, mda_size, buf))
		goto fail;

	mh = (struct mda_header *)buf;

	/*
	 * To be certain this is really an mda_header before writing it,
	 * require that magic, version and start are all correct.
	 */

	if (memcmp(mh->magic, FMTT_MAGIC, sizeof(mh->magic)))
		goto fail;

	if (xlate32(mh->version) != FMTT_VERSION) {
		log_print("Skipping mda2 (wrong mda_header.version)");
		goto fail;
	}

	if (xlate64(mh->start) != mda_offset) {
		log_print("Skipping mda2 (wrong mda_header.start)");
		goto fail;
	}

	/*
	 * Search text area for an instance of current metadata before enabling
	 * mda2, in case this mda_header is from a previous generation PV and
	 * is not actually used by the current PV.  An mda_header and metadata
	 * area from a previous PV (in a previous VG) that used mda2 might
	 * still exist, while the current PV does not use an mda2.
	 *
	 * Search for the vgid in the first 256 bytes at each 512 byte boundary
	 * in the first half of the metadata area.
	 */
	for (i = 0; i < (mda_size / 1024); i++) {
		memcpy(buf2, buf + 512 + (i * 512), sizeof(buf2));

		if (strstr(buf2, mf->vgid_str)) {
			log_print("Found mda2 header at offset %llu size %llu",
				  (unsigned long long)mda_offset, (unsigned long long)mda_size);
			*mda2_offset = mda_offset;
			*mda2_size = mda_size;
			found = 1;
			break;
		}
	}
	if (!found) {
		log_print("Skipping mda2 (no matching VG UUID in metadata area)");
		goto fail;
	}

	free(buf);
	return 1;

 fail:
	free(buf);
	*mda2_offset = 0;
	*mda2_size = 0;
	return 0;
}

/*
 * pvck --repairtype pv_header --file input --settings
 *
 * Writes new pv_header and label_header.
 *
 * pv_header.pv_uuid
 * If a uuid is given in --settings, that is used.
 * Else if existing pv_header has a valid uuid, that is used.
 * Else if the metadata file has a matching device name, that uuid is used.
 *
 * pv_header.device_size
 * Use device size from metadata file.
 *
 * pv_header.disk_locn[0].offset (data area start)
 * Use pe_start from metadata file.
 *
 * pv_header.disk_locn[2].offset/size (first metadata area)
 * offset always 4096.  size is pe_start - offset.
 *
 * pv_header.disk_locn[3].offset/size (second metadata area)
 * Look for existing mda_header at expected offset, and if
 * found use that value.  Otherwise second mda is not used.
 *
 * The size/offset variables in sectors have a _sectors suffix,
 * any other size/offset variables in bytes.
 */

static int _repair_pv_header(struct cmd_context *cmd, const char *repair,
			     struct settings *set, struct metadata_file *mf,
			     uint64_t labelsector, struct device *dev)
{
	char head_buf[512];
	int8_t pvid[ID_LEN+1];
	struct device *dev_with_pvid = NULL;
	struct label_header *lh;
	struct pv_header *pvh;
	struct pv_header_extension *pvhe;
	uint64_t mda1_offset = 0, mda1_size = 0, mda2_offset = 0, mda2_size = 0; /* bytes */
	uint64_t lh_offset;               /* in bytes, from start of disk */
	uint64_t device_size = 0;         /* in bytes, as stored in pv_header */
	uint64_t device_size_sectors = 0; /* in sectors, as stored in metadata */
	uint64_t get_size_sectors = 0;    /* in sectors, as dev_get_size returns */
	uint64_t get_size = 0;            /* in bytes */
	uint64_t pe_start_sectors;        /* in sectors, as stored in metadata */
	uint64_t data_offset;             /* in bytes, as stored in pv_header */
	uint32_t head_crc;
	int mda_count = 0;
	int found_label = 0;
	int di;

	memset(&pvid, 0, ID_LEN+1);

	lh_offset = labelsector * 512; /* from start of disk */

	if (!dev_get_size(dev, &get_size_sectors))
		log_warn("WARNING: Cannot get device size.");
	get_size = get_size_sectors << SECTOR_SHIFT;

	_dump_label_and_pv_header(cmd, labelsector, dev, NULL, 0, &found_label,
			&mda1_offset, &mda1_size, &mda2_offset, &mda2_size, &mda_count);

	/*
	 * The header sector may have been zeroed, or the user may have
	 * accidentally given the wrong device.
	 */
	if (!found_label)
		log_warn("WARNING: No LVM label found on %s.  It may not be an LVM device.", dev_name(dev));

	/*
	 * The PV may have had no metadata areas, or one, or two.
	 *
	 * Try to avoid writing new metadata areas where they didn't exist
	 * before.  Writing mda1 when it didn't exist previously would not be
	 * terrible since the space is unused anyway, but wrongly writing mda2
	 * could end up in the data area.
	 *
	 * When the pv_header has no mda1 or mda2 locations, check for evidence
	 * of prior mda headers for mda1 and mda2.
	 *
	 * When the pv_header has an mda1 location and no mda2 location, just
	 * use mda1 and don't look for mda2 (unless requested by user setting)
	 * since it probably did not exist.  (It's very unlikely that only the
	 * mda2 location was zeroed in the pv_header.)
	 */
	if (!mda_count && !mda1_offset && !mda2_offset) {
		if (_check_for_mda1(cmd, dev))
			mda_count = 1;

		if (_check_for_mda2(cmd, dev, get_size, mf, &mda2_offset, &mda2_size))
			mda_count = 2;
	}

	/*
	 * The PV may have had zero metadata areas (not common), or the
	 * pv_header and the mda1 header at 4096 may have been zeroed
	 * (more likely).  Ask the user if metadata in mda1 should be
	 * included; it would usually be yes.  To repair a PV and use
	 * zero metadata areas, require the user to specify
	 * --settings "mda_offset=0 mda_size=0".
	 *
	 * NOTE: mda1 is not written by repair pv_header, this will only
	 * include a pointer to mda1 in the pv_header so that a subsequent
	 * repair metadata will use that to write an mda_header and metadata.
	 */
	if (!mda_count && set->mda_offset_set && set->mda_size_set &&
	    !set->mda_offset && !set->mda_size) {
		log_warn("WARNING: PV will have no metadata with zero metadata areas.");

	} else if (!mda_count) {
		log_warn("WARNING: no previous metadata areas found on device.");

		if (arg_count(cmd, yes_ARG) ||
		    yes_no_prompt("Should a metadata area be included? ") == 'y') {
			/* mda1_offset/mda1_size are set below */
			mda_count = 1;
		} else {
			log_error("To repair with zero metadata areas, use --settings \"mda_offset=0 mda_size=0\".");
			goto fail;
		}
	}

	/*
	 * The user has provided offset or size for mda2.  This would
	 * usually be done when these values do not exist on disk,
	 * but if mda2 *is* found on disk, ensure it agrees with the
	 * user's setting.
	 */
	if (mda_count && (set->mda2_offset_set || set->mda2_size_set)) {
		if (mda2_offset && (mda2_offset != set->mda2_offset)) {
			log_error("mda2_offset setting %llu does not match mda2_offset found on disk %llu.",
				 (unsigned long long)set->mda2_offset, (unsigned long long)mda2_offset);
			goto fail;
		}
		if (mda2_size && (mda2_size != set->mda2_size)) {
			log_error("mda2_size setting %llu does not match mda2_size found on disk %llu.",
				 (unsigned long long)set->mda2_size, (unsigned long long)mda2_size);
			goto fail;
		}
		mda2_offset = set->mda2_offset;
		mda2_size = set->mda2_size;
		mda_count = 2;
	}

	/*
	 * The header sector is read into this buffer.
	 * This same buffer is modified and written back.
	 */
	if (!dev_read_bytes(dev, lh_offset, 512, head_buf)) {
	        log_error("Failed to read label_header at %llu", (unsigned long long)lh_offset);
		goto fail;
	}

	lh = (struct label_header *)head_buf;
	pvh = (struct pv_header *)(head_buf + 32);

	/*
	 * Metadata file is not needed if user provides pvid/device_size/data_offset.
	 * All values in settings are in bytes.
	 */
	if (set->device_size_set && set->pvid_set && set->data_offset_set && !mf->filename) {
		device_size = set->device_size;
		pe_start_sectors = set->data_offset >> SECTOR_SHIFT;
		memcpy(&pvid, &set->pvid, ID_LEN);

		if (get_size && (get_size != device_size)) {
			log_warn("WARNING: device_size setting %llu bytes does not match device size %llu bytes.",
				 (unsigned long long)set->device_size, (unsigned long long)get_size);
		}
		goto scan;
	}

	if (!mf->filename) {
		log_error("Metadata input file is needed for pv_header info.");
		log_error("See pvck --dump to locate and create a metadata file.");
		goto fail;
	}

	/*
	 * Look in the provided copy of VG metadata for info that determines
	 * pv_header fields.
	 *
	 * pv<N> {
	 * 	id = <uuid>
	 * 	device = <path>  # device path hint, set when metadata was last written
	 * 	...
	 * 	dev_size = <num> # in 512 sectors
	 * 	pe_start = <num> # in 512 sectors
	 * }
	 *
	 * Select the right pv entry by matching an existing pv uuid, or the
	 * current device name to the device path hint.  Take the pv uuid,
	 * dev_size and pe_start from the metadata to use in the pv_header.
	 */
	if (!_get_pv_info_from_metadata(cmd, set, dev, pvh, found_label,
					mf->text_buf, mf->text_size, (char *)&pvid,
					&device_size_sectors, &pe_start_sectors))
		goto fail;

	/*
	 * In pv_header, device_size is bytes, but in metadata dev_size is in sectors.
	 */
	device_size = device_size_sectors << SECTOR_SHIFT;

 scan:
	/*
	 * Read all devs to verify the pvid that will be written does not exist
	 * on another device.
	 */
	if (!label_scan_for_pvid(cmd, (char *)&pvid, &dev_with_pvid)) {
		log_error("Failed to scan devices to check PV UUID.");
		goto fail;
	}

	if (dev_with_pvid && (dev_with_pvid != dev)) {
		log_error("Cannot use PV UUID %s which exists on %s", (char *)&pvid, dev_name(dev_with_pvid));
		goto fail;
	}

	/*
	 * Set new label_header and pv_header fields.
	 */

	/* set label_header (except crc) */
	memcpy(lh->id, LABEL_ID, sizeof(lh->id));
	memcpy(lh->type, LVM2_LABEL, sizeof(lh->type));
	lh->sector_xl =  xlate64(labelsector);
	lh->offset_xl = xlate32(32);

	/* set pv_header */
	memcpy(pvh->pv_uuid, &pvid, ID_LEN);
	pvh->device_size_xl = xlate64(device_size);

	/* set data area location */
	data_offset = (pe_start_sectors << SECTOR_SHIFT);
	pvh->disk_areas_xl[0].offset = xlate64(data_offset);
	pvh->disk_areas_xl[0].size = 0;

	/* set end of data areas */
	pvh->disk_areas_xl[1].offset = 0;
	pvh->disk_areas_xl[1].size = 0;

	di = 2;

	/* set first metadata area location */
	if (mda_count > 0) {
		mda1_offset = 4096;
		mda1_size = (pe_start_sectors << SECTOR_SHIFT) - 4096;
		pvh->disk_areas_xl[di].offset = xlate64(mda1_offset);
		pvh->disk_areas_xl[di].size = xlate64(mda1_size);
		di++;
	}

	/* set second metadata area location */
	if (mda_count > 1) {
		pvh->disk_areas_xl[di].offset = xlate64(mda2_offset);
		pvh->disk_areas_xl[di].size = xlate64(mda2_size);
		di++;
	}

	/* set end of metadata areas */
	pvh->disk_areas_xl[di].offset = 0;
	pvh->disk_areas_xl[di].size = 0;
	di++;

	/* set pv_header_extension */
	pvhe = (struct pv_header_extension *)((char *)pvh + sizeof(struct pv_header) + (di * sizeof(struct disk_locn)));
	pvhe->version = xlate32(PV_HEADER_EXTENSION_VSN);
	pvhe->flags = xlate32(PV_EXT_USED);
	pvhe->bootloader_areas_xl[0].offset = 0;
	pvhe->bootloader_areas_xl[0].size = 0;

	head_crc = calc_crc(INITIAL_CRC, (uint8_t *)&lh->offset_xl,
			    LABEL_SIZE - ((uint8_t *) &lh->offset_xl - (uint8_t *) lh));

	/* set label_header crc (last) */
	lh->crc_xl = xlate32(head_crc);

	/*
	 * Write the updated header sector.
	 */

	log_print("Writing label_header.crc 0x%08x pv_header uuid %s device_size %llu",
		  head_crc, (char *)&pvid, (unsigned long long)device_size);

	log_print("Writing data_offset %llu mda1_offset %llu mda1_size %llu mda2_offset %llu mda2_size %llu",
		  (unsigned long long)data_offset,
		  (unsigned long long)mda1_offset,
		  (unsigned long long)mda1_size,
		  (unsigned long long)mda2_offset,
		  (unsigned long long)mda2_size);

	if (arg_is_set(cmd, test_ARG)) {
		log_warn("Skip writing in test mode.");
		return 1;
	}

	if (!arg_count(cmd, yes_ARG) &&
	    yes_no_prompt("Write new LVM header to %s? ", dev_name(dev)) == 'n')
		goto fail;

	if (!dev_write_bytes(dev, lh_offset, 512, head_buf)) {
	        log_error("Failed to write new header");
		goto fail;
	}

	return 1;
fail:
	return 0;
}

/* all sizes and offsets in bytes */

static int _update_mda(struct cmd_context *cmd, struct metadata_file *mf, struct device *dev,
		       int mda_num, uint64_t mda_offset, uint64_t mda_size)
{
	char buf[512];
	struct mda_header *mh;
	struct raw_locn *rlocn0, *rlocn1;
	uint64_t max_size;
	uint64_t text_offset;
	uint32_t crc;

	max_size = ((mda_size - 512) / 2) - 512;
	if (mf->text_size > mda_size) {
		log_error("Metadata text %llu too large for mda_size %llu max %llu",
			  (unsigned long long)mf->text_size,
			  (unsigned long long)mda_size,
			  (unsigned long long)max_size);
		goto fail;
	}

	if (!dev_read_bytes(dev, mda_offset, sizeof(buf), buf)) {
		log_print("CHECK: failed to read mda_header_%d at %llu",
			  mda_num, (unsigned long long)mda_offset);
		goto fail;
	}

	text_offset = mda_offset + 512;

	mh = (struct mda_header *)buf;
	memcpy(mh->magic, FMTT_MAGIC, sizeof(mh->magic));
	mh->version = xlate32(FMTT_VERSION);
	mh->start = xlate64(mda_offset);
	mh->size = xlate64(mda_size);

	rlocn0 = mh->raw_locns;
	rlocn0->flags = 0;
	rlocn0->offset = xlate64(512); /* text begins 512 from start of mda_header */
	rlocn0->size = xlate64(mf->text_size);
	rlocn0->checksum = xlate32(mf->text_crc);

	rlocn1 = (struct raw_locn *)((char *)mh->raw_locns + 24);
	rlocn1->flags = 0;
	rlocn1->offset = 0;
	rlocn1->size = 0;
	rlocn1->checksum = 0;

	crc = calc_crc(INITIAL_CRC, (uint8_t *)mh->magic,
		       MDA_HEADER_SIZE - sizeof(mh->checksum_xl));
	mh->checksum_xl = xlate32(crc);

	log_print("Writing metadata at %llu length %llu crc 0x%08x mda%d",
		  (unsigned long long)(mda_offset + 512),
		  (unsigned long long)mf->text_size, mf->text_crc, mda_num);

	log_print("Writing mda_header at %llu mda%d",
		  (unsigned long long)mda_offset, mda_num);

	if (arg_is_set(cmd, test_ARG)) {
		log_warn("Skip writing in test mode.");
		return 1;
	}

	if (!arg_count(cmd, yes_ARG) &&
	    yes_no_prompt("Write new LVM metadata to %s? ", dev_name(dev)) == 'n')
		goto fail;

	if (!dev_write_bytes(dev, text_offset, mf->text_size, mf->text_buf)) {
		log_error("Failed to write new mda text");
		goto fail;
	}

	if (!dev_write_bytes(dev, mda_offset, 512, buf)) {
		log_error("Failed to write new mda header");
		goto fail;
	}

	return 1;
 fail:
	return 0;
}

/*
 * pvck --repairtype metadata --file input --settings
 *
 * Writes new metadata into the text area and writes new
 * mda_header for it.  Requires valid mda locations in pv_header.
 * Metadata is written immediately after mda_header.
 *
 * all sizes and offsets in bytes
 */

static int _repair_metadata(struct cmd_context *cmd, const char *repair,
			    struct settings *set, struct metadata_file *mf,
			    uint64_t labelsector, struct device *dev)
{
	uint64_t mda1_offset = 0, mda1_size = 0, mda2_offset = 0, mda2_size = 0; /* bytes */
	int found_label = 0;
	int mda_count = 0;
	int mda_num;
	int bad = 0;

	mda_num = set->mda_num;

	if (!mf->filename) {
		log_error("Metadata input file is required.");
		return 0;
	}

	_dump_label_and_pv_header(cmd, labelsector, dev, NULL, 0, &found_label,
			&mda1_offset, &mda1_size, &mda2_offset, &mda2_size, &mda_count);

	if (!found_label) {
		log_error("No lvm label found on device.");
		log_error("See --repairtype pv_header to repair headers.");
		return 0;
	}

	if (!mda_count && set->mda_offset_set && set->mda_size_set &&
	    !set->mda_offset && !set->mda_size) {
		log_print("No metadata areas on device to repair.");
		return 1;
	}

	if (!mda_count) {
		log_error("No metadata areas found on device.");
		log_error("See --repairtype pv_header to repair headers.");
		return 0;
	}

	if ((mda_num == 1) && !mda1_offset) {
		log_error("No mda1 offset found.");
		log_error("See --repairtype pv_header to repair headers.");
		return 0;
	}

	if ((mda_num == 2) && !mda2_offset) {
		log_error("No mda2 offset found.");
		log_error("See --repairtype pv_header to repair headers.");
		return 0;
	}

	if ((!mda_num || mda_num == 1) && mda1_offset) {
		if (!_update_mda(cmd, mf, dev, 1, mda1_offset, mda1_size))
			bad++;
	}

	if ((!mda_num || mda_num == 2) && mda2_offset) {
		if (!_update_mda(cmd, mf, dev, 2, mda2_offset, mda2_size))
			bad++;
	}

	if (bad)
		return 0;

	return 1;
}

static void _strip_backup_line(char *line1, int len1, char *line2, int *len2)
{
	int copying = 0;
	int i, j = 0;

	for (i = 0; i < len1; i++) {
		if (line1[i] == '\0')
			break;

		if (line1[i] == '\n')
			break;

		/* omit tabs at start of line */
		if (!copying && (line1[i] == '\t'))
			continue;

		/* omit tabs and comment at end of line (can tabs occur without comment?) */
		if (copying && (line1[i] == '\t') && strchr(line1 + i, '#'))
			break;

		copying = 1;

		line2[j++] = line1[i];
	}

	line2[j++] = '\n';
	*len2 = j;
}

#define MAX_META_LINE 4096

/* all sizes and offsets in bytes */

static int _backup_file_to_raw_metadata(char *back_buf, uint64_t back_size,
					char **text_buf_out, uint64_t *text_size_out)
{
	char line[MAX_META_LINE];
	char line2[MAX_META_LINE];
	char *p, *text_buf;
	uint32_t text_pos, pre_len = 0, back_pos, text_max;
	int len, len2, vgnamelen;

	text_max = back_size * 2;

	if (!(text_buf = zalloc(text_max)))
		return_0;

	p = back_buf;
	text_pos = 0;
	back_pos = 0;

	while (1) {
		if (back_pos >= back_size)
			break;

		memset(line, 0, sizeof(line));
		len = 0;

		_copy_line(p, line, &len, sizeof(line)-1);
		p += len;
		back_pos += len;

		if (len < 3)
			continue;

		if (_check_vgname_start(line, &vgnamelen)) {
			/* vg name is first line of text_buf */
			memcpy(text_buf, line, len);
			text_pos = len;

			pre_len = back_pos - len;
			break;
		}
	}

	while (1) {
		if (back_pos >= back_size)
			break;

		memset(line, 0, sizeof(line));
		memset(line2, 0, sizeof(line2));
		len = 0;
		len2 = 0;

		_copy_line(p, line, &len, sizeof(line)-1);

		if (line[0] == '\0')
			break;

		p += len;
		back_pos += len;

		/* shouldn't happen */
		if (text_pos + len > text_max) {
			free(text_buf);
			return_0;
		}

		if (len == 1) {
			text_buf[text_pos++] = '\n';
			continue;
		}

		_strip_backup_line(line, len, line2, &len2);

		memcpy(text_buf + text_pos, line2, len2);
		text_pos += len2;
	}

	/* shouldn't happen */
	if (text_pos + pre_len + 3 > text_max) {
		free(text_buf);
		return_0;
	}

	if (pre_len) {
		/* copy first pre_len bytes of back_buf into text_buf */
		memcpy(text_buf + text_pos, back_buf, pre_len);
		text_pos += pre_len;
	}

	text_pos++; /* null termination */

	*text_size_out = text_pos;
	*text_buf_out = text_buf;

	return 1;
}

static int _is_backup_file(struct cmd_context *cmd, char *text_buf, uint64_t text_size)
{
	if ((text_buf[0] == '#') && !strncmp(text_buf, "# Generated", 11))
		return 1;
	return 0;
}

/* all sizes and offsets in bytes */

static int _dump_backup_to_raw(struct cmd_context *cmd, struct settings *set)
{
	const char *input = set->backup_file;
	const char *tofile = NULL;
	struct stat sb;
	char *back_buf, *text_buf;
	uint64_t back_size, text_size;
	int fd, rv, ret;

	if (arg_is_set(cmd, file_ARG)) {
		if (!(tofile = arg_str_value(cmd, file_ARG, NULL)))
			return_0;
	}

	if (!input) {
		log_error("Set backup file in --settings backup_file=path");
		return 0;
	}

	if ((fd = open(input, O_RDONLY)) < 0) {
		log_error("Cannot open file: %s", input);
		return 0;
	}

	if (fstat(fd, &sb)) {
		log_error("Cannot access file: %s", input);
		goto fail_close;
	}

	if (!(back_size = (uint64_t)sb.st_size)) {
		log_error("Empty file: %s", input);
		goto fail_close;
	}

	if (!(back_buf = zalloc(back_size)))
		goto fail_close;

	rv = read(fd, back_buf, back_size);
	if (rv != back_size) {
		log_error("Cannot read file: %s", input);
		free(back_buf);
		goto fail_close;
	}

	if (close(fd))
		stack;

	if (!_is_backup_file(cmd, back_buf, back_size)) {
		log_error("File does not appear to contain a metadata backup.");
		free(back_buf);
		return 0;
	}

	if (!_backup_file_to_raw_metadata(back_buf, back_size, &text_buf, &text_size)) {
		free(back_buf);
		return_0;
	}

	if (!tofile) {
		log_print("---");
		printf("%s\n", text_buf);
		log_print("---");
	} else {
		FILE *fp;
		if (!(fp = fopen(tofile, "wx"))) {
			log_error("Failed to create file %s", tofile);
			ret = 0;
			goto out;
		}

		fprintf(fp, "%s", text_buf);

		if (fflush(fp))
			stack;
		if (fclose(fp))
			stack;
	}
	ret = 1;
out:
	free(back_buf);
	free(text_buf);
	return ret;

fail_close:
	if (close(fd))
		stack;
	return 0;
}

/* all sizes and offsets in bytes */

static int _check_metadata_file(struct cmd_context *cmd, struct metadata_file *mf,
				char *text_buf, int text_size)
{
	char *vgid;
	int namelen;

	if (text_size < NAME_LEN+1) {
		log_error("Invalid raw text metadata in file.  File size is too small.");
		return 0;
	}

	/*
	 * Using pvck --dump metadata output redirected to file may be a common
	 * mistake, so check and warn about that specifically.
	 */
	if (isspace(text_buf[0]) && isspace(text_buf[1]) && strstr(text_buf, "---")) {
		log_error("Invalid raw text metadata in file.");
		log_error("(pvck stdout is not valid input, see pvck -f.)");
		return 0;
	}

	/*
	 * Using a metadata backup file may be another common mistake.
	 */
	if ((text_buf[0] == '#') && !strncmp(text_buf, "# Generated", 11)) {
		log_error("Invalid raw text metadata in file.");
		log_error("(metadata backup file is not valid input.)");
		return 0;
	}

	if (text_buf[text_size-1] != '\0' ||
	    text_buf[text_size-2] != '\n' ||
	    text_buf[text_size-3] != '\n')
		log_warn("WARNING: unexpected final bytes of raw metadata, expected \\n\\n\\0.");

	if (_check_vgname_start(text_buf, &namelen)) {
		if (!(vgid = strstr(text_buf, "id = "))) {
			log_error("Invalid raw text metadata in file.  (No VG UUID found.)");
			return 0;
		}
		memcpy(mf->vgid_str, vgid + 6, 38);
		return 1;
	}

	log_warn("WARNING: file data does not begin with a VG name and may be invalid.");

	if (!arg_count(cmd, yes_ARG) &&
	    yes_no_prompt("Write input file data to disk?") == 'n') {
		log_error("Invalid raw text metadata in file.");
		return 0;
	}

	return 1;
}

/* all sizes and offsets in bytes */

static int _read_metadata_file(struct cmd_context *cmd, struct metadata_file *mf)
{
	struct stat sb;
	char *text_buf;
	uint64_t text_size;
	uint32_t text_crc;
	int fd, rv;

	if ((fd = open(mf->filename, O_RDONLY)) < 0) {
		log_error("Cannot open file: %s", mf->filename);
		return 0;
	}

	if (fstat(fd, &sb)) {
		log_error("Cannot access file: %s", mf->filename);
		goto out;
	}

	if (!(text_size = (uint64_t)sb.st_size)) {
		log_error("Empty file: %s", mf->filename);
		goto out;
	}

	if (!(text_buf = zalloc(text_size + 1)))
		goto_out;

	rv = read(fd, text_buf, text_size);
	if (rv != text_size) {
		log_error("Cannot read file: %s", mf->filename);
		free(text_buf);
		goto out;
	}

	text_size += 1; /* null terminating byte */

	if (close(fd))
		stack;

	if (_is_backup_file(cmd, text_buf, text_size)) {
		char *back_buf = text_buf;
		uint64_t back_size = text_size;
		text_buf = NULL;
		text_size = 0;
		if (!_backup_file_to_raw_metadata(back_buf, back_size, &text_buf, &text_size)) {
			free(back_buf);
			return_0;
		}
		free(back_buf);
	}

	if (!_check_metadata_file(cmd, mf, text_buf, text_size)) {
		free(text_buf);
		return_0;
	}

	text_crc = calc_crc(INITIAL_CRC, (uint8_t *)text_buf, text_size);

	mf->text_size = text_size;
	mf->text_buf = text_buf;
	mf->text_crc = text_crc;
	return 1;

out:
	if (close(fd))
		stack;
	return 0;
}

int pvck(struct cmd_context *cmd, int argc, char **argv)
{
	struct settings set;
	struct metadata_file mf;
	struct device *dev = NULL;
	struct devicefile *def = NULL;
	const char *dump, *repair;
	const char *pv_name = "";
	uint64_t labelsector = 1;
	int bad = 0;
	int ret = 0;
	int i;

	memset(&set, 0, sizeof(set));
	memset(&mf, 0, sizeof(mf));

	/*
	 * By default LVM skips the first sector (sector 0), and writes
	 * the label_header in the second sector (sector 1).
	 * (sector size 512 bytes)
	 */
	if (arg_is_set(cmd, labelsector_ARG))
		labelsector = arg_uint64_value(cmd, labelsector_ARG, UINT64_C(0));

	if (arg_is_set(cmd, repairtype_ARG) || arg_is_set(cmd, repair_ARG)) {
		pv_name = argv[0];

		clear_hint_file(cmd);

		if (!setup_device(cmd, pv_name)) {
			log_error("Failed to set up device %s.", pv_name);
			return ECMD_FAILED;
		}

		if (!(dev = dev_cache_get(cmd, pv_name, NULL))) {
			log_error("Cannot use %s: %s.", pv_name, devname_error_reason(pv_name));
			return ECMD_FAILED;
		}
	}

	if (arg_is_set(cmd, dump_ARG)) {
		struct stat sb;

		pv_name = argv[0];

		if (stat(pv_name, &sb) < 0) {
			log_error("Cannot access %s.", pv_name);
			return ECMD_FAILED;
		}
		if (S_ISREG(sb.st_mode))
			def = get_devicefile(pv_name);
		else if (S_ISBLK(sb.st_mode)) {
			if (!setup_device(cmd, pv_name)) {
				log_error("Failed to set up device %s.", pv_name);
				return ECMD_FAILED;
			}
			dev = dev_cache_get(cmd, pv_name, NULL);
		}
		if (!dev && !def) {
			log_error("Cannot use %s: %s.", pv_name, devname_error_reason(pv_name));
			return ECMD_FAILED;
		}
	}

	if (!_get_settings(cmd, &set))
		return ECMD_FAILED;

	if (arg_is_set(cmd, file_ARG) && (arg_is_set(cmd, repairtype_ARG) || arg_is_set(cmd, repair_ARG))) {
		if (!(mf.filename = arg_str_value(cmd, file_ARG, NULL)))
			return ECMD_FAILED;

		if (!_read_metadata_file(cmd, &mf))
			return ECMD_FAILED;
	}

	label_scan_setup_bcache();

	if (dev) {
		char buf[4096];

		/*
		 * Check nodata filters including device_id filter,
		 * then clear the result so the full filter can be
		 * checked after reading the dev.
		 */
		cmd->filter_nodata_only = 1;
		if (!cmd->filter->passes_filter(cmd, cmd->filter, dev, NULL)) {
			log_error("Cannot use %s: %s.", pv_name, dev_filtered_reason(dev));
			return ECMD_FAILED;
		}
		cmd->filter_nodata_only = 0;
		cmd->filter->wipe(cmd, cmd->filter, dev, NULL);

		/*
		 * This buf is not used, but bcache data is used for subsequent
		 * reads in the filters and by _read_bytes for other disk structs.
		 */
		if (!dev_read_bytes(dev, 0, 4096, buf)) {
	        	log_error("Failed to read the first 4096 bytes of device %s.", dev_name(dev));
			return ECMD_FAILED;
		}

		if (!cmd->filter->passes_filter(cmd, cmd->filter, dev, NULL)) {
			log_error("Cannot use %s: %s.", pv_name, dev_filtered_reason(dev));
			return ECMD_FAILED;
		}
	}

	if ((dump = arg_str_value(cmd, dump_ARG, NULL))) {
		cmd->use_hints = 0;

		if (!strcmp(dump, "metadata"))
			ret = _dump_metadata(cmd, dump, &set, labelsector, dev, def, PRINT_CURRENT, 0);

		else if (!strcmp(dump, "metadata_all"))
			ret = _dump_metadata(cmd, dump, &set, labelsector, dev, def, PRINT_ALL, 0);

		else if (!strcmp(dump, "metadata_area"))
			ret = _dump_metadata(cmd, dump, &set, labelsector, dev, def, 0, 1);

		else if (!strcmp(dump, "metadata_search"))
			ret = _dump_search(cmd, dump, &set, labelsector, dev, def);

		else if (!strcmp(dump, "headers"))
			ret = _dump_headers(cmd, dump, &set, labelsector, dev, def);

		else if (!strcmp(dump, "backup_to_raw")) {
			ret = _dump_backup_to_raw(cmd, &set);

		} else
			log_error("Unknown dump value.");

		if (!ret)
			return ECMD_FAILED;
		return ECMD_PROCESSED;
	}

	if ((repair = arg_str_value(cmd, repairtype_ARG, NULL))) {
		cmd->use_hints = 0;

		if (!strcmp(repair, "label_header"))
			ret = _repair_label_header(cmd, repair, &set, labelsector, dev);

		else if (!strcmp(repair, "pv_header"))
			ret = _repair_pv_header(cmd, repair, &set, &mf, labelsector, dev);

		else if (!strcmp(repair, "metadata"))
			ret = _repair_metadata(cmd, repair, &set, &mf, labelsector, dev);
		else
			log_error("Unknown repair value.");

		if (!ret)
			return ECMD_FAILED;
		return ECMD_PROCESSED;
	}

	if (arg_is_set(cmd, repair_ARG)) {
		cmd->use_hints = 0;

		/* repair is a combination of repairtype pv_header+metadata */

		if (!_repair_pv_header(cmd, "pv_header", &set, &mf, labelsector, dev))
			return ECMD_FAILED;

		if (!_repair_metadata(cmd, "metadata", &set, &mf, labelsector, dev))
			return ECMD_FAILED;

		return ECMD_PROCESSED;
	}

	/*
	 * The old/original form of pvck, which did not do much,
	 * but this is here to preserve the historical output.
	 */

	if (argc == 1)
		setup_device(cmd, argv[0]);
	else
		setup_devices(cmd);

	for (i = 0; i < argc; i++) {
		pv_name = argv[i];

		if (!(dev = dev_cache_get(cmd, argv[i], cmd->filter))) {
			log_error("Cannot use %s: %s.", pv_name, devname_error_reason(pv_name));
			continue;
		}

		if (!_dump_found(cmd, &set, labelsector, dev))
			bad++;
	}

	if (bad)
		return ECMD_FAILED;
	return ECMD_PROCESSED;
}