* [Qemu-devel] [PATCH V19 01/12] quorum: Create quorum.c, add QuorumChildRequest and QuorumAIOCB.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 02/12] quorum: Create BDRVQuorumState and BlkDriver and do init Benoît Canet
` (12 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
Quorum is a block filter mirroring writes to num_children children.
For reads quorum reads each children and does a vote.
If more than vote_threshold versions are identical the quorum is reached and
this winning version is returned to the guest. So quorum prevents bit corruption.
For high availability purpose minority errors are reported via QMP but the guest
does not see them.
This patch creates the driver C source file and introduces the structures that
will be used in asynchronous reads and writes.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/Makefile.objs | 1 +
block/quorum.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 54 insertions(+)
create mode 100644 block/quorum.c
diff --git a/block/Makefile.objs b/block/Makefile.objs
index e254a21..716556f 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -3,6 +3,7 @@ block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-c
block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o
block-obj-y += qed-check.o
block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o vhdx-log.o
+block-obj-y += quorum.o
block-obj-y += parallels.o blkdebug.o blkverify.o
block-obj-y += snapshot.o qapi.o
block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o
diff --git a/block/quorum.c b/block/quorum.c
new file mode 100644
index 0000000..950f5cc
--- /dev/null
+++ b/block/quorum.c
@@ -0,0 +1,53 @@
+/*
+ * Quorum Block filter
+ *
+ * Copyright (C) 2012-2014 Nodalink, EURL.
+ *
+ * Author:
+ * Benoît Canet <benoit.canet@irqsave.net>
+ *
+ * Based on the design and code of blkverify.c (Copyright (C) 2010 IBM, Corp)
+ * and blkmirror.c (Copyright (C) 2011 Red Hat, Inc).
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "block/block_int.h"
+
+typedef struct QuorumAIOCB QuorumAIOCB;
+
+/* Quorum will create one instance of the following structure per operation it
+ * performs on its children.
+ * So for each read/write operation coming from the upper layer there will be
+ * $children_count QuorumChildRequest.
+ */
+typedef struct QuorumChildRequest {
+ BlockDriverAIOCB *aiocb;
+ QEMUIOVector qiov;
+ uint8_t *buf;
+ int ret;
+ QuorumAIOCB *parent;
+} QuorumChildRequest;
+
+/* Quorum will use the following structure to track progress of each read/write
+ * operation received by the upper layer.
+ * This structure hold pointers to the QuorumChildRequest structures instances
+ * used to do operations on each children and track overall progress.
+ */
+struct QuorumAIOCB {
+ BlockDriverAIOCB common;
+
+ /* Request metadata */
+ uint64_t sector_num;
+ int nb_sectors;
+
+ QEMUIOVector *qiov; /* calling IOV */
+
+ QuorumChildRequest *qcrs; /* individual child requests */
+ int count; /* number of completed AIOCB */
+ int success_count; /* number of successfully completed AIOCB */
+
+ bool is_read;
+ int vote_ret;
+};
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 02/12] quorum: Create BDRVQuorumState and BlkDriver and do init.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 01/12] quorum: Create quorum.c, add QuorumChildRequest and QuorumAIOCB Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 03/12] quorum: Add quorum_aio_writev and its dependencies Benoît Canet
` (11 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
Create the structure holding the quorum settings and write the minimal block
driver instanciation boilerplate.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 31 +++++++++++++++++++++++++++++++
1 file changed, 31 insertions(+)
diff --git a/block/quorum.c b/block/quorum.c
index 950f5cc..375ffd5 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -15,6 +15,23 @@
#include "block/block_int.h"
+/* the following structure holds the state of one quorum instance */
+typedef struct BDRVQuorumState {
+ BlockDriverState **bs; /* children BlockDriverStates */
+ int num_children; /* children count */
+ int threshold; /* if less than threshold children reads gave the
+ * same result a quorum error occurs.
+ */
+ bool is_blkverify; /* true if the driver is in blkverify mode
+ * Writes are mirrored on two children devices.
+ * On reads the two children devices' contents are
+ * compared and if a difference is spotted its
+ * location is printed and the code aborts.
+ * It is useful to debug other block drivers by
+ * comparing them with a reference one.
+ */
+} BDRVQuorumState;
+
typedef struct QuorumAIOCB QuorumAIOCB;
/* Quorum will create one instance of the following structure per operation it
@@ -51,3 +68,17 @@ struct QuorumAIOCB {
bool is_read;
int vote_ret;
};
+
+static BlockDriver bdrv_quorum = {
+ .format_name = "quorum",
+ .protocol_name = "quorum",
+
+ .instance_size = sizeof(BDRVQuorumState),
+};
+
+static void bdrv_quorum_init(void)
+{
+ bdrv_register(&bdrv_quorum);
+}
+
+block_init(bdrv_quorum_init);
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 03/12] quorum: Add quorum_aio_writev and its dependencies.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 01/12] quorum: Create quorum.c, add QuorumChildRequest and QuorumAIOCB Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 02/12] quorum: Create BDRVQuorumState and BlkDriver and do init Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 04/12] blkverify: Extract qemu_iovec_clone() and qemu_iovec_compare() from blkverify Benoît Canet
` (10 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
Writes are mirrored num_children times on num_children devices.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 103 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 103 insertions(+)
diff --git a/block/quorum.c b/block/quorum.c
index 375ffd5..99e0e03 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -69,11 +69,114 @@ struct QuorumAIOCB {
int vote_ret;
};
+static void quorum_aio_cancel(BlockDriverAIOCB *blockacb)
+{
+ QuorumAIOCB *acb = container_of(blockacb, QuorumAIOCB, common);
+ BDRVQuorumState *s = acb->common.bs->opaque;
+ int i;
+
+ /* cancel all callbacks */
+ for (i = 0; i < s->num_children; i++) {
+ bdrv_aio_cancel(acb->qcrs[i].aiocb);
+ }
+
+ g_free(acb->qcrs);
+ qemu_aio_release(acb);
+}
+
+static AIOCBInfo quorum_aiocb_info = {
+ .aiocb_size = sizeof(QuorumAIOCB),
+ .cancel = quorum_aio_cancel,
+};
+
+static void quorum_aio_finalize(QuorumAIOCB *acb)
+{
+ int ret = 0;
+
+ acb->common.cb(acb->common.opaque, ret);
+
+ g_free(acb->qcrs);
+ qemu_aio_release(acb);
+}
+
+static QuorumAIOCB *quorum_aio_get(BDRVQuorumState *s,
+ BlockDriverState *bs,
+ QEMUIOVector *qiov,
+ uint64_t sector_num,
+ int nb_sectors,
+ BlockDriverCompletionFunc *cb,
+ void *opaque)
+{
+ QuorumAIOCB *acb = qemu_aio_get(&quorum_aiocb_info, bs, cb, opaque);
+ int i;
+
+ acb->common.bs->opaque = s;
+ acb->sector_num = sector_num;
+ acb->nb_sectors = nb_sectors;
+ acb->qiov = qiov;
+ acb->qcrs = g_new0(QuorumChildRequest, s->num_children);
+ acb->count = 0;
+ acb->success_count = 0;
+ acb->is_read = false;
+ acb->vote_ret = 0;
+
+ for (i = 0; i < s->num_children; i++) {
+ acb->qcrs[i].buf = NULL;
+ acb->qcrs[i].ret = 0;
+ acb->qcrs[i].parent = acb;
+ }
+
+ return acb;
+}
+
+static void quorum_aio_cb(void *opaque, int ret)
+{
+ QuorumChildRequest *sacb = opaque;
+ QuorumAIOCB *acb = sacb->parent;
+ BDRVQuorumState *s = acb->common.bs->opaque;
+
+ sacb->ret = ret;
+ acb->count++;
+ if (ret == 0) {
+ acb->success_count++;
+ }
+ assert(acb->count <= s->num_children);
+ assert(acb->success_count <= s->num_children);
+ if (acb->count < s->num_children) {
+ return;
+ }
+
+ quorum_aio_finalize(acb);
+}
+
+static BlockDriverAIOCB *quorum_aio_writev(BlockDriverState *bs,
+ int64_t sector_num,
+ QEMUIOVector *qiov,
+ int nb_sectors,
+ BlockDriverCompletionFunc *cb,
+ void *opaque)
+{
+ BDRVQuorumState *s = bs->opaque;
+ QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num, nb_sectors,
+ cb, opaque);
+ int i;
+
+ for (i = 0; i < s->num_children; i++) {
+ acb->qcrs[i].aiocb = bdrv_aio_writev(s->bs[i], sector_num, qiov,
+ nb_sectors, &quorum_aio_cb,
+ &acb->qcrs[i]);
+ }
+
+ return &acb->common;
+}
+
static BlockDriver bdrv_quorum = {
.format_name = "quorum",
.protocol_name = "quorum",
.instance_size = sizeof(BDRVQuorumState),
+
+ .bdrv_aio_writev = quorum_aio_writev,
};
static void bdrv_quorum_init(void)
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 04/12] blkverify: Extract qemu_iovec_clone() and qemu_iovec_compare() from blkverify.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (2 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 03/12] quorum: Add quorum_aio_writev and its dependencies Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 05/12] quorum: Add quorum_aio_readv Benoît Canet
` (9 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
qemu_iovec_compare() will be used to compare IOs vectors in quorum blkverify
mode. The patch extracts these functions in order to factorize the code.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/blkverify.c | 108 +-------------------------------------------------
include/qemu-common.h | 2 +
util/iov.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 110 insertions(+), 106 deletions(-)
diff --git a/block/blkverify.c b/block/blkverify.c
index 0e28502..b98b08b 100644
--- a/block/blkverify.c
+++ b/block/blkverify.c
@@ -173,110 +173,6 @@ static int64_t blkverify_getlength(BlockDriverState *bs)
return bdrv_getlength(s->test_file);
}
-/**
- * Check that I/O vector contents are identical
- *
- * @a: I/O vector
- * @b: I/O vector
- * @ret: Offset to first mismatching byte or -1 if match
- */
-static ssize_t blkverify_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
-{
- int i;
- ssize_t offset = 0;
-
- assert(a->niov == b->niov);
- for (i = 0; i < a->niov; i++) {
- size_t len = 0;
- uint8_t *p = (uint8_t *)a->iov[i].iov_base;
- uint8_t *q = (uint8_t *)b->iov[i].iov_base;
-
- assert(a->iov[i].iov_len == b->iov[i].iov_len);
- while (len < a->iov[i].iov_len && *p++ == *q++) {
- len++;
- }
-
- offset += len;
-
- if (len != a->iov[i].iov_len) {
- return offset;
- }
- }
- return -1;
-}
-
-typedef struct {
- int src_index;
- struct iovec *src_iov;
- void *dest_base;
-} IOVectorSortElem;
-
-static int sortelem_cmp_src_base(const void *a, const void *b)
-{
- const IOVectorSortElem *elem_a = a;
- const IOVectorSortElem *elem_b = b;
-
- /* Don't overflow */
- if (elem_a->src_iov->iov_base < elem_b->src_iov->iov_base) {
- return -1;
- } else if (elem_a->src_iov->iov_base > elem_b->src_iov->iov_base) {
- return 1;
- } else {
- return 0;
- }
-}
-
-static int sortelem_cmp_src_index(const void *a, const void *b)
-{
- const IOVectorSortElem *elem_a = a;
- const IOVectorSortElem *elem_b = b;
-
- return elem_a->src_index - elem_b->src_index;
-}
-
-/**
- * Copy contents of I/O vector
- *
- * The relative relationships of overlapping iovecs are preserved. This is
- * necessary to ensure identical semantics in the cloned I/O vector.
- */
-static void blkverify_iovec_clone(QEMUIOVector *dest, const QEMUIOVector *src,
- void *buf)
-{
- IOVectorSortElem sortelems[src->niov];
- void *last_end;
- int i;
-
- /* Sort by source iovecs by base address */
- for (i = 0; i < src->niov; i++) {
- sortelems[i].src_index = i;
- sortelems[i].src_iov = &src->iov[i];
- }
- qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_base);
-
- /* Allocate buffer space taking into account overlapping iovecs */
- last_end = NULL;
- for (i = 0; i < src->niov; i++) {
- struct iovec *cur = sortelems[i].src_iov;
- ptrdiff_t rewind = 0;
-
- /* Detect overlap */
- if (last_end && last_end > cur->iov_base) {
- rewind = last_end - cur->iov_base;
- }
-
- sortelems[i].dest_base = buf - rewind;
- buf += cur->iov_len - MIN(rewind, cur->iov_len);
- last_end = MAX(cur->iov_base + cur->iov_len, last_end);
- }
-
- /* Sort by source iovec index and build destination iovec */
- qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_index);
- for (i = 0; i < src->niov; i++) {
- qemu_iovec_add(dest, sortelems[i].dest_base, src->iov[i].iov_len);
- }
-}
-
static BlkverifyAIOCB *blkverify_aio_get(BlockDriverState *bs, bool is_write,
int64_t sector_num, QEMUIOVector *qiov,
int nb_sectors,
@@ -340,7 +236,7 @@ static void blkverify_aio_cb(void *opaque, int ret)
static void blkverify_verify_readv(BlkverifyAIOCB *acb)
{
- ssize_t offset = blkverify_iovec_compare(acb->qiov, &acb->raw_qiov);
+ ssize_t offset = qemu_iovec_compare(acb->qiov, &acb->raw_qiov);
if (offset != -1) {
blkverify_err(acb, "contents mismatch in sector %" PRId64,
acb->sector_num + (int64_t)(offset / BDRV_SECTOR_SIZE));
@@ -358,7 +254,7 @@ static BlockDriverAIOCB *blkverify_aio_readv(BlockDriverState *bs,
acb->verify = blkverify_verify_readv;
acb->buf = qemu_blockalign(bs->file, qiov->size);
qemu_iovec_init(&acb->raw_qiov, acb->qiov->niov);
- blkverify_iovec_clone(&acb->raw_qiov, qiov, acb->buf);
+ qemu_iovec_clone(&acb->raw_qiov, qiov, acb->buf);
bdrv_aio_readv(s->test_file, sector_num, qiov, nb_sectors,
blkverify_aio_cb, acb);
diff --git a/include/qemu-common.h b/include/qemu-common.h
index b0e34b2..20ace93 100644
--- a/include/qemu-common.h
+++ b/include/qemu-common.h
@@ -338,6 +338,8 @@ size_t qemu_iovec_from_buf(QEMUIOVector *qiov, size_t offset,
const void *buf, size_t bytes);
size_t qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
int fillc, size_t bytes);
+ssize_t qemu_iovec_compare(QEMUIOVector *a, QEMUIOVector *b);
+void qemu_iovec_clone(QEMUIOVector *dest, const QEMUIOVector *src, void *buf);
bool buffer_is_zero(const void *buf, size_t len);
diff --git a/util/iov.c b/util/iov.c
index bb46c04..03934da 100644
--- a/util/iov.c
+++ b/util/iov.c
@@ -378,6 +378,112 @@ size_t qemu_iovec_memset(QEMUIOVector *qiov, size_t offset,
return iov_memset(qiov->iov, qiov->niov, offset, fillc, bytes);
}
+/**
+ * Check that I/O vector contents are identical
+ *
+ * The IO vectors must have the same structure (same length of all parts).
+ * A typical usage is to compare vectors created with qemu_iovec_clone().
+ *
+ * @a: I/O vector
+ * @b: I/O vector
+ * @ret: Offset to first mismatching byte or -1 if match
+ */
+ssize_t qemu_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
+{
+ int i;
+ ssize_t offset = 0;
+
+ assert(a->niov == b->niov);
+ for (i = 0; i < a->niov; i++) {
+ size_t len = 0;
+ uint8_t *p = (uint8_t *)a->iov[i].iov_base;
+ uint8_t *q = (uint8_t *)b->iov[i].iov_base;
+
+ assert(a->iov[i].iov_len == b->iov[i].iov_len);
+ while (len < a->iov[i].iov_len && *p++ == *q++) {
+ len++;
+ }
+
+ offset += len;
+
+ if (len != a->iov[i].iov_len) {
+ return offset;
+ }
+ }
+ return -1;
+}
+
+typedef struct {
+ int src_index;
+ struct iovec *src_iov;
+ void *dest_base;
+} IOVectorSortElem;
+
+static int sortelem_cmp_src_base(const void *a, const void *b)
+{
+ const IOVectorSortElem *elem_a = a;
+ const IOVectorSortElem *elem_b = b;
+
+ /* Don't overflow */
+ if (elem_a->src_iov->iov_base < elem_b->src_iov->iov_base) {
+ return -1;
+ } else if (elem_a->src_iov->iov_base > elem_b->src_iov->iov_base) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+static int sortelem_cmp_src_index(const void *a, const void *b)
+{
+ const IOVectorSortElem *elem_a = a;
+ const IOVectorSortElem *elem_b = b;
+
+ return elem_a->src_index - elem_b->src_index;
+}
+
+/**
+ * Copy contents of I/O vector
+ *
+ * The relative relationships of overlapping iovecs are preserved. This is
+ * necessary to ensure identical semantics in the cloned I/O vector.
+ */
+void qemu_iovec_clone(QEMUIOVector *dest, const QEMUIOVector *src, void *buf)
+{
+ IOVectorSortElem sortelems[src->niov];
+ void *last_end;
+ int i;
+
+ /* Sort by source iovecs by base address */
+ for (i = 0; i < src->niov; i++) {
+ sortelems[i].src_index = i;
+ sortelems[i].src_iov = &src->iov[i];
+ }
+ qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_base);
+
+ /* Allocate buffer space taking into account overlapping iovecs */
+ last_end = NULL;
+ for (i = 0; i < src->niov; i++) {
+ struct iovec *cur = sortelems[i].src_iov;
+ ptrdiff_t rewind = 0;
+
+ /* Detect overlap */
+ if (last_end && last_end > cur->iov_base) {
+ rewind = last_end - cur->iov_base;
+ }
+
+ sortelems[i].dest_base = buf - rewind;
+ buf += cur->iov_len - MIN(rewind, cur->iov_len);
+ last_end = MAX(cur->iov_base + cur->iov_len, last_end);
+ }
+
+ /* Sort by source iovec index and build destination iovec */
+ qsort(sortelems, src->niov, sizeof(sortelems[0]), sortelem_cmp_src_index);
+ for (i = 0; i < src->niov; i++) {
+ qemu_iovec_add(dest, sortelems[i].dest_base, src->iov[i].iov_len);
+ }
+}
+
size_t iov_discard_front(struct iovec **iov, unsigned int *iov_cnt,
size_t bytes)
{
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 05/12] quorum: Add quorum_aio_readv.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (3 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 04/12] blkverify: Extract qemu_iovec_clone() and qemu_iovec_compare() from blkverify Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism Benoît Canet
` (8 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
Add code to do num_children reads in parallel and cleanup the structures
afterwards.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 39 ++++++++++++++++++++++++++++++++++++++-
1 file changed, 38 insertions(+), 1 deletion(-)
diff --git a/block/quorum.c b/block/quorum.c
index 99e0e03..fd19662 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -91,10 +91,18 @@ static AIOCBInfo quorum_aiocb_info = {
static void quorum_aio_finalize(QuorumAIOCB *acb)
{
- int ret = 0;
+ BDRVQuorumState *s = acb->common.bs->opaque;
+ int i, ret = 0;
acb->common.cb(acb->common.opaque, ret);
+ if (acb->is_read) {
+ for (i = 0; i < s->num_children; i++) {
+ qemu_vfree(acb->qcrs[i].buf);
+ qemu_iovec_destroy(&acb->qcrs[i].qiov);
+ }
+ }
+
g_free(acb->qcrs);
qemu_aio_release(acb);
}
@@ -149,6 +157,34 @@ static void quorum_aio_cb(void *opaque, int ret)
quorum_aio_finalize(acb);
}
+static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs,
+ int64_t sector_num,
+ QEMUIOVector *qiov,
+ int nb_sectors,
+ BlockDriverCompletionFunc *cb,
+ void *opaque)
+{
+ BDRVQuorumState *s = bs->opaque;
+ QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num,
+ nb_sectors, cb, opaque);
+ int i;
+
+ acb->is_read = true;
+
+ for (i = 0; i < s->num_children; i++) {
+ acb->qcrs[i].buf = qemu_blockalign(s->bs[i], qiov->size);
+ qemu_iovec_init(&acb->qcrs[i].qiov, qiov->niov);
+ qemu_iovec_clone(&acb->qcrs[i].qiov, qiov, acb->qcrs[i].buf);
+ }
+
+ for (i = 0; i < s->num_children; i++) {
+ bdrv_aio_readv(s->bs[i], sector_num, qiov, nb_sectors,
+ quorum_aio_cb, &acb->qcrs[i]);
+ }
+
+ return &acb->common;
+}
+
static BlockDriverAIOCB *quorum_aio_writev(BlockDriverState *bs,
int64_t sector_num,
QEMUIOVector *qiov,
@@ -176,6 +212,7 @@ static BlockDriver bdrv_quorum = {
.instance_size = sizeof(BDRVQuorumState),
+ .bdrv_aio_readv = quorum_aio_readv,
.bdrv_aio_writev = quorum_aio_writev,
};
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (4 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 05/12] quorum: Add quorum_aio_readv Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 22:09 ` Eric Blake
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 07/12] quorum: Add quorum_getlength() Benoît Canet
` (7 subsequent siblings)
13 siblings, 1 reply; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
This patchset enables the core of the quorum mechanism.
The num_children reads are compared to get the majority version and if this
version exists more than threshold times the guest won't see the error at all.
If a block is corrupted or if an error occurs during an IO or if the quorum
cannot be established QMP events are used to report to the management.
Use gnutls's SHA-256 to compare versions.
--enable-quorum must be used to enable the feature.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/Makefile.objs | 2 +-
block/quorum.c | 391 +++++++++++++++++++++++++++++++++++++++++++++-
configure | 36 +++++
docs/qmp/qmp-events.txt | 36 +++++
include/monitor/monitor.h | 2 +
monitor.c | 2 +
6 files changed, 467 insertions(+), 2 deletions(-)
diff --git a/block/Makefile.objs b/block/Makefile.objs
index 716556f..425d7fb 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -3,7 +3,7 @@ block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-c
block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o
block-obj-y += qed-check.o
block-obj-$(CONFIG_VHDX) += vhdx.o vhdx-endian.o vhdx-log.o
-block-obj-y += quorum.o
+block-obj-$(CONFIG_QUORUM) += quorum.o
block-obj-y += parallels.o blkdebug.o blkverify.o
block-obj-y += snapshot.o qapi.o
block-obj-$(CONFIG_WIN32) += raw-win32.o win32-aio.o
diff --git a/block/quorum.c b/block/quorum.c
index fd19662..4beee96 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -13,7 +13,43 @@
* See the COPYING file in the top-level directory.
*/
+#include <gnutls/gnutls.h>
+#include <gnutls/crypto.h>
#include "block/block_int.h"
+#include "qapi/qmp/qjson.h"
+
+#define HASH_LENGTH 32
+
+/* This union holds a vote hash value */
+typedef union QuorumVoteValue {
+ char h[HASH_LENGTH]; /* SHA-256 hash */
+ int64_t l; /* simpler 64 bits hash */
+} QuorumVoteValue;
+
+/* A vote item */
+typedef struct QuorumVoteItem {
+ int index;
+ QLIST_ENTRY(QuorumVoteItem) next;
+} QuorumVoteItem;
+
+/* this structure is a vote version. A version is the set of votes sharing the
+ * same vote value.
+ * The set of votes will be tracked with the items field and its cardinality is
+ * vote_count.
+ */
+typedef struct QuorumVoteVersion {
+ QuorumVoteValue value;
+ int index;
+ int vote_count;
+ QLIST_HEAD(, QuorumVoteItem) items;
+ QLIST_ENTRY(QuorumVoteVersion) next;
+} QuorumVoteVersion;
+
+/* this structure holds a group of vote versions together */
+typedef struct QuorumVotes {
+ QLIST_HEAD(, QuorumVoteVersion) vote_list;
+ bool (*compare)(QuorumVoteValue *a, QuorumVoteValue *b);
+} QuorumVotes;
/* the following structure holds the state of one quorum instance */
typedef struct BDRVQuorumState {
@@ -65,10 +101,14 @@ struct QuorumAIOCB {
int count; /* number of completed AIOCB */
int success_count; /* number of successfully completed AIOCB */
+ QuorumVotes votes;
+
bool is_read;
int vote_ret;
};
+static void quorum_vote(QuorumAIOCB *acb);
+
static void quorum_aio_cancel(BlockDriverAIOCB *blockacb)
{
QuorumAIOCB *acb = container_of(blockacb, QuorumAIOCB, common);
@@ -94,6 +134,10 @@ static void quorum_aio_finalize(QuorumAIOCB *acb)
BDRVQuorumState *s = acb->common.bs->opaque;
int i, ret = 0;
+ if (acb->vote_ret) {
+ ret = acb->vote_ret;
+ }
+
acb->common.cb(acb->common.opaque, ret);
if (acb->is_read) {
@@ -107,6 +151,16 @@ static void quorum_aio_finalize(QuorumAIOCB *acb)
qemu_aio_release(acb);
}
+static bool quorum_sha256_compare(QuorumVoteValue *a, QuorumVoteValue *b)
+{
+ return !memcmp(a->h, b->h, HASH_LENGTH);
+}
+
+static bool quorum_64bits_compare(QuorumVoteValue *a, QuorumVoteValue *b)
+{
+ return a->l == b->l;
+}
+
static QuorumAIOCB *quorum_aio_get(BDRVQuorumState *s,
BlockDriverState *bs,
QEMUIOVector *qiov,
@@ -125,6 +179,8 @@ static QuorumAIOCB *quorum_aio_get(BDRVQuorumState *s,
acb->qcrs = g_new0(QuorumChildRequest, s->num_children);
acb->count = 0;
acb->success_count = 0;
+ acb->votes.compare = quorum_sha256_compare;
+ QLIST_INIT(&acb->votes.vote_list);
acb->is_read = false;
acb->vote_ret = 0;
@@ -137,6 +193,48 @@ static QuorumAIOCB *quorum_aio_get(BDRVQuorumState *s,
return acb;
}
+static void quorum_report_bad(QuorumAIOCB *acb, char *node_name, int ret)
+{
+ QObject *data;
+ assert(node_name);
+ data = qobject_from_jsonf("{ 'ret': %d"
+ ", 'node-name': %s"
+ ", 'sector-num': %" PRId64
+ ", 'sectors-count': %d }",
+ ret, node_name, acb->sector_num, acb->nb_sectors);
+ monitor_protocol_event(QEVENT_QUORUM_REPORT_BAD, data);
+ qobject_decref(data);
+}
+
+static void quorum_report_failure(QuorumAIOCB *acb)
+{
+ QObject *data;
+ const char *reference = acb->common.bs->device_name[0] ?
+ acb->common.bs->device_name :
+ acb->common.bs->node_name;
+ data = qobject_from_jsonf("{ 'reference': %s"
+ ", 'sector-num': %" PRId64
+ ", 'sectors-count': %d }",
+ reference, acb->sector_num, acb->nb_sectors);
+ monitor_protocol_event(QEVENT_QUORUM_FAILURE, data);
+ qobject_decref(data);
+}
+
+static int quorum_vote_error(QuorumAIOCB *acb);
+
+static bool quorum_has_too_much_io_failed(QuorumAIOCB *acb)
+{
+ BDRVQuorumState *s = acb->common.bs->opaque;
+
+ if (acb->success_count < s->threshold) {
+ acb->vote_ret = quorum_vote_error(acb);
+ quorum_report_failure(acb);
+ return true;
+ }
+
+ return false;
+}
+
static void quorum_aio_cb(void *opaque, int ret)
{
QuorumChildRequest *sacb = opaque;
@@ -147,6 +245,8 @@ static void quorum_aio_cb(void *opaque, int ret)
acb->count++;
if (ret == 0) {
acb->success_count++;
+ } else {
+ quorum_report_bad(acb, sacb->aiocb->bs->node_name, ret);
}
assert(acb->count <= s->num_children);
assert(acb->success_count <= s->num_children);
@@ -154,9 +254,298 @@ static void quorum_aio_cb(void *opaque, int ret)
return;
}
+ /* Do the vote on read */
+ if (acb->is_read) {
+ quorum_vote(acb);
+ } else {
+ quorum_has_too_much_io_failed(acb);
+ }
+
quorum_aio_finalize(acb);
}
+static void quorum_report_bad_versions(BDRVQuorumState *s,
+ QuorumAIOCB *acb,
+ QuorumVoteValue *value)
+{
+ QuorumVoteVersion *version;
+ QuorumVoteItem *item;
+
+ QLIST_FOREACH(version, &acb->votes.vote_list, next) {
+ if (acb->votes.compare(&version->value, value)) {
+ continue;
+ }
+ QLIST_FOREACH(item, &version->items, next) {
+ quorum_report_bad(acb, s->bs[item->index]->node_name, 0);
+ }
+ }
+}
+
+static void quorum_copy_qiov(QEMUIOVector *dest, QEMUIOVector *source)
+{
+ int i;
+ assert(dest->niov == source->niov);
+ assert(dest->size == source->size);
+ for (i = 0; i < source->niov; i++) {
+ assert(dest->iov[i].iov_len == source->iov[i].iov_len);
+ memcpy(dest->iov[i].iov_base,
+ source->iov[i].iov_base,
+ source->iov[i].iov_len);
+ }
+}
+
+static void quorum_count_vote(QuorumVotes *votes,
+ QuorumVoteValue *value,
+ int index)
+{
+ QuorumVoteVersion *v = NULL, *version = NULL;
+ QuorumVoteItem *item;
+
+ /* look if we have something with this hash */
+ QLIST_FOREACH(v, &votes->vote_list, next) {
+ if (votes->compare(&v->value, value)) {
+ version = v;
+ break;
+ }
+ }
+
+ /* It's a version not yet in the list add it */
+ if (!version) {
+ version = g_new0(QuorumVoteVersion, 1);
+ QLIST_INIT(&version->items);
+ memcpy(&version->value, value, sizeof(version->value));
+ version->index = index;
+ version->vote_count = 0;
+ QLIST_INSERT_HEAD(&votes->vote_list, version, next);
+ }
+
+ version->vote_count++;
+
+ item = g_new0(QuorumVoteItem, 1);
+ item->index = index;
+ QLIST_INSERT_HEAD(&version->items, item, next);
+}
+
+static void quorum_free_vote_list(QuorumVotes *votes)
+{
+ QuorumVoteVersion *version, *next_version;
+ QuorumVoteItem *item, *next_item;
+
+ QLIST_FOREACH_SAFE(version, &votes->vote_list, next, next_version) {
+ QLIST_REMOVE(version, next);
+ QLIST_FOREACH_SAFE(item, &version->items, next, next_item) {
+ QLIST_REMOVE(item, next);
+ g_free(item);
+ }
+ g_free(version);
+ }
+}
+
+static int quorum_compute_hash(QuorumAIOCB *acb, int i, QuorumVoteValue *hash)
+{
+ int j, ret;
+ gnutls_hash_hd_t dig;
+ QEMUIOVector *qiov = &acb->qcrs[i].qiov;
+
+ ret = gnutls_hash_init(&dig, GNUTLS_DIG_SHA256);
+
+ if (ret < 0) {
+ return ret;
+ }
+
+ for (j = 0; j < qiov->niov; j++) {
+ ret = gnutls_hash(dig, qiov->iov[j].iov_base, qiov->iov[j].iov_len);
+ if (ret < 0) {
+ break;
+ }
+ }
+
+ gnutls_hash_deinit(dig, (void *) hash);
+ return ret;
+}
+
+static QuorumVoteVersion *quorum_get_vote_winner(QuorumVotes *votes)
+{
+ int max = 0;
+ QuorumVoteVersion *candidate, *winner = NULL;
+
+ QLIST_FOREACH(candidate, &votes->vote_list, next) {
+ if (candidate->vote_count > max) {
+ max = candidate->vote_count;
+ winner = candidate;
+ }
+ }
+
+ return winner;
+}
+
+/* qemu_iovec_compare is handy for blkverify mode because it returns the first
+ * differing byte location. Yet it is handcoded to compare vectors one byte
+ * after another so it does not benefit from the libc SIMD optimizations.
+ * quorum_iovec_compare is written for speed and should be used in the non
+ * blkverify mode of quorum.
+ */
+static bool quorum_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
+{
+ int i;
+ int result;
+
+ assert(a->niov == b->niov);
+ for (i = 0; i < a->niov; i++) {
+ assert(a->iov[i].iov_len == b->iov[i].iov_len);
+ result = memcmp(a->iov[i].iov_base,
+ b->iov[i].iov_base,
+ a->iov[i].iov_len);
+ if (result) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static void GCC_FMT_ATTR(2, 3) quorum_err(QuorumAIOCB *acb,
+ const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ fprintf(stderr, "quorum: sector_num=%" PRId64 " nb_sectors=%d ",
+ acb->sector_num, acb->nb_sectors);
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+ exit(1);
+}
+
+static bool quorum_compare(QuorumAIOCB *acb,
+ QEMUIOVector *a,
+ QEMUIOVector *b)
+{
+ BDRVQuorumState *s = acb->common.bs->opaque;
+ ssize_t offset;
+
+ /* This driver will replace blkverify in this particular case */
+ if (s->is_blkverify) {
+ offset = qemu_iovec_compare(a, b);
+ if (offset != -1) {
+ quorum_err(acb, "contents mismatch in sector %" PRId64,
+ acb->sector_num +
+ (uint64_t)(offset / BDRV_SECTOR_SIZE));
+ }
+ return true;
+ }
+
+ return quorum_iovec_compare(a, b);
+}
+
+/* Do a vote to get the error code */
+static int quorum_vote_error(QuorumAIOCB *acb)
+{
+ BDRVQuorumState *s = acb->common.bs->opaque;
+ QuorumVoteVersion *winner = NULL;
+ QuorumVotes error_votes;
+ QuorumVoteValue result_value;
+ int i, ret = 0;
+ bool error = false;
+
+ QLIST_INIT(&error_votes.vote_list);
+ error_votes.compare = quorum_64bits_compare;
+
+ for (i = 0; i < s->num_children; i++) {
+ ret = acb->qcrs[i].ret;
+ if (ret) {
+ error = true;
+ result_value.l = ret;
+ quorum_count_vote(&error_votes, &result_value, i);
+ }
+ }
+
+ if (error) {
+ winner = quorum_get_vote_winner(&error_votes);
+ ret = winner->value.l;
+ }
+
+ quorum_free_vote_list(&error_votes);
+
+ return ret;
+}
+
+static void quorum_vote(QuorumAIOCB *acb)
+{
+ bool quorum = true;
+ int i, j, ret;
+ QuorumVoteValue hash;
+ BDRVQuorumState *s = acb->common.bs->opaque;
+ QuorumVoteVersion *winner;
+
+ if (quorum_has_too_much_io_failed(acb)) {
+ return;
+ }
+
+ /* get the index of the first successful read */
+ for (i = 0; i < s->num_children; i++) {
+ if (!acb->qcrs[i].ret) {
+ break;
+ }
+ }
+
+ assert(i < s->num_children);
+
+ /* compare this read with all other successful reads stopping at quorum
+ * failure
+ */
+ for (j = i + 1; j < s->num_children; j++) {
+ if (acb->qcrs[j].ret) {
+ continue;
+ }
+ quorum = quorum_compare(acb, &acb->qcrs[i].qiov, &acb->qcrs[j].qiov);
+ if (!quorum) {
+ break;
+ }
+ }
+
+ /* Every successful read agrees */
+ if (quorum) {
+ quorum_copy_qiov(acb->qiov, &acb->qcrs[i].qiov);
+ return;
+ }
+
+ /* compute hashes for each successful read, also store indexes */
+ for (i = 0; i < s->num_children; i++) {
+ if (acb->qcrs[i].ret) {
+ continue;
+ }
+ ret = quorum_compute_hash(acb, i, &hash);
+ /* if ever the hash computation failed */
+ if (ret < 0) {
+ acb->vote_ret = ret;
+ goto free_exit;
+ }
+ quorum_count_vote(&acb->votes, &hash, i);
+ }
+
+ /* vote to select the most represented version */
+ winner = quorum_get_vote_winner(&acb->votes);
+
+ /* if the winner count is smaller than threshold the read fails */
+ if (winner->vote_count < s->threshold) {
+ quorum_report_failure(acb);
+ acb->vote_ret = -EIO;
+ goto free_exit;
+ }
+
+ /* we have a winner: copy it */
+ quorum_copy_qiov(acb->qiov, &acb->qcrs[winner->index].qiov);
+
+ /* some versions are bad print them */
+ quorum_report_bad_versions(s, acb, &winner->value);
+
+free_exit:
+ /* free lists */
+ quorum_free_vote_list(&acb->votes);
+}
+
static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs,
int64_t sector_num,
QEMUIOVector *qiov,
@@ -178,7 +567,7 @@ static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs,
}
for (i = 0; i < s->num_children; i++) {
- bdrv_aio_readv(s->bs[i], sector_num, qiov, nb_sectors,
+ bdrv_aio_readv(s->bs[i], sector_num, &acb->qcrs[i].qiov, nb_sectors,
quorum_aio_cb, &acb->qcrs[i]);
}
diff --git a/configure b/configure
index 39f2a1a..6143acb 100755
--- a/configure
+++ b/configure
@@ -264,6 +264,7 @@ gtkabi="2.0"
tpm="no"
libssh2=""
vhdx=""
+quorum="no"
# parse CC options first
for opt do
@@ -1005,6 +1006,10 @@ for opt do
;;
--disable-vhdx) vhdx="no"
;;
+ --disable-quorum) quorum="no"
+ ;;
+ --enable-quorum) quorum="yes"
+ ;;
*) echo "ERROR: unknown option $opt"; show_help="yes"
;;
esac
@@ -1261,6 +1266,8 @@ Advanced options (experts only):
--enable-libssh2 enable ssh block device support
--disable-vhdx disables support for the Microsoft VHDX image format
--enable-vhdx enable support for the Microsoft VHDX image format
+ --disable-quorum disable quorum block filter support
+ --enable-quorum enable quorum block filter support
NOTE: The object files are built at the place where configure is launched
EOF
@@ -1937,6 +1944,30 @@ EOF
fi
##########################################
+# Quorum probe (check for gnutls)
+if test "$quorum" != "no" ; then
+cat > $TMPC <<EOF
+#include <gnutls/gnutls.h>
+#include <gnutls/crypto.h>
+int main(void) {char data[4096], digest[32];
+gnutls_hash_fast(GNUTLS_DIG_SHA256, data, 4096, digest);
+return 0;
+}
+EOF
+quorum_tls_cflags=`$pkg_config --cflags gnutls 2> /dev/null`
+quorum_tls_libs=`$pkg_config --libs gnutls 2> /dev/null`
+if compile_prog "$quorum_tls_cflags" "$quorum_tls_libs" ; then
+ qcow_tls=yes
+ libs_softmmu="$quorum_tls_libs $libs_softmmu"
+ libs_tools="$quorum_tls_libs $libs_softmmu"
+ QEMU_CFLAGS="$QEMU_CFLAGS $quorum_tls_cflags"
+else
+ echo "gnutls > 2.10.0 required to compile Quorum"
+ exit 1
+fi
+fi
+
+##########################################
# VNC SASL detection
if test "$vnc" = "yes" -a "$vnc_sasl" != "no" ; then
cat > $TMPC <<EOF
@@ -3893,6 +3924,7 @@ echo "libssh2 support $libssh2"
echo "TPM passthrough $tpm_passthrough"
echo "QOM debugging $qom_cast_debug"
echo "vhdx $vhdx"
+echo "Quorum $quorum"
if test "$sdl_too_old" = "yes"; then
echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -4295,6 +4327,10 @@ if test "$libssh2" = "yes" ; then
echo "CONFIG_LIBSSH2=y" >> $config_host_mak
fi
+if test "$quorum" = "yes" ; then
+ echo "CONFIG_QUORUM=y" >> $config_host_mak
+fi
+
if test "$virtio_blk_data_plane" = "yes" ; then
echo 'CONFIG_VIRTIO_BLK_DATA_PLANE=$(CONFIG_VIRTIO)' >> $config_host_mak
fi
diff --git a/docs/qmp/qmp-events.txt b/docs/qmp/qmp-events.txt
index a378c87..00f9515 100644
--- a/docs/qmp/qmp-events.txt
+++ b/docs/qmp/qmp-events.txt
@@ -500,3 +500,39 @@ Example:
Note: If action is "reset", "shutdown", or "pause" the WATCHDOG event is
followed respectively by the RESET, SHUTDOWN, or STOP events.
+
+QUORUM_FAILURE
+--------------
+
+Emitted by the Quorum block driver if it fails to establish a quorum.
+
+Data:
+
+- "reference": device name if defined else node name.
+- "sector-num": Number of the first sector of the failed read operation.
+- "sector-count": Failed read operation sector count.
+
+Example:
+
+{ "event": "QUORUM_FAILURE",
+ "data": { "reference": "usr1", "sector-num": 345435, "sector-count": 5 },
+ "timestamp": { "seconds": 1344522075, "microseconds": 745528 } }
+
+QUORUM_REPORT_BAD
+-----------------
+
+Emitted to report a corruption of a Quorum file.
+
+Data:
+
+- "ret": The IO return code.
+- "node-name": The graph node name of the block driver state.
+- "sector-num": Number of the first sector of the failed read operation.
+- "sector-count": Failed read operation sector count.
+
+Example:
+
+{ "event": "QUORUM_REPORT_BAD",
+ "data": { "ret": 0, "node-name": "1.raw", "sector-num": 345435,
+ "sector-count": 5 },
+ "timestamp": { "seconds": 1344522075, "microseconds": 745528 } }
diff --git a/include/monitor/monitor.h b/include/monitor/monitor.h
index 7e5f752..a49ea11 100644
--- a/include/monitor/monitor.h
+++ b/include/monitor/monitor.h
@@ -49,6 +49,8 @@ typedef enum MonitorEvent {
QEVENT_SPICE_MIGRATE_COMPLETED,
QEVENT_GUEST_PANICKED,
QEVENT_BLOCK_IMAGE_CORRUPTED,
+ QEVENT_QUORUM_FAILURE,
+ QEVENT_QUORUM_REPORT_BAD,
/* Add to 'monitor_event_names' array in monitor.c when
* defining new events here */
diff --git a/monitor.c b/monitor.c
index de90fba..8ae095f 100644
--- a/monitor.c
+++ b/monitor.c
@@ -508,6 +508,8 @@ static const char *monitor_event_names[] = {
[QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",
[QEVENT_GUEST_PANICKED] = "GUEST_PANICKED",
[QEVENT_BLOCK_IMAGE_CORRUPTED] = "BLOCK_IMAGE_CORRUPTED",
+ [QEVENT_QUORUM_FAILURE] = "QUORUM_FAILURE",
+ [QEVENT_QUORUM_REPORT_BAD] = "QUORUM_REPORT_BAD",
};
QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism Benoît Canet
@ 2014-02-21 22:09 ` Eric Blake
2014-02-21 22:30 ` Benoît Canet
0 siblings, 1 reply; 24+ messages in thread
From: Eric Blake @ 2014-02-21 22:09 UTC (permalink / raw)
To: Benoît Canet, qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
[-- Attachment #1: Type: text/plain, Size: 1638 bytes --]
On 02/21/2014 02:21 PM, Benoît Canet wrote:
> From: Benoît Canet <benoit@irqsave.net>
>
> This patchset enables the core of the quorum mechanism.
> The num_children reads are compared to get the majority version and if this
> version exists more than threshold times the guest won't see the error at all.
> +++ b/docs/qmp/qmp-events.txt
> @@ -500,3 +500,39 @@ Example:
>
> Note: If action is "reset", "shutdown", or "pause" the WATCHDOG event is
> followed respectively by the RESET, SHUTDOWN, or STOP events.
> +
> +QUORUM_FAILURE
> +--------------
This should have been inserted in sorted order to match the rest of the
file, rather than at the end. Can be rearranged in a followup patch,
now that this series is queued.
> +
> +Emitted by the Quorum block driver if it fails to establish a quorum.
> +
> +Data:
> +
> +- "reference": device name if defined else node name.
> +- "sector-num": Number of the first sector of the failed read operation.
I'm assuming sector-num is relative to the guest's view of the data?
> +
> +QUORUM_REPORT_BAD
> +-----------------
> +
> +Emitted to report a corruption of a Quorum file.
> +
> +Data:
> +
> +- "ret": The IO return code.
What values is this likely to contain? Is it a finite set, in which
case it would be nice to have a QAPI enum that describes the set of
return codes, rather than a raw number?
I'd like to make sure we are happy with the wire format of this QMP
event before it gets baked into 2.0.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 22:09 ` Eric Blake
@ 2014-02-21 22:30 ` Benoît Canet
2014-02-21 22:38 ` Kevin Wolf
2014-02-21 22:41 ` Eric Blake
0 siblings, 2 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 22:30 UTC (permalink / raw)
To: Eric Blake; +Cc: Benoît Canet, kwolf, qemu-devel, stefanha, mreitz
The Friday 21 Feb 2014 à 15:09:42 (-0700), Eric Blake wrote :
> On 02/21/2014 02:21 PM, Benoît Canet wrote:
> > From: Benoît Canet <benoit@irqsave.net>
> >
> > This patchset enables the core of the quorum mechanism.
> > The num_children reads are compared to get the majority version and if this
> > version exists more than threshold times the guest won't see the error at all.
>
> > +++ b/docs/qmp/qmp-events.txt
> > @@ -500,3 +500,39 @@ Example:
> >
> > Note: If action is "reset", "shutdown", or "pause" the WATCHDOG event is
> > followed respectively by the RESET, SHUTDOWN, or STOP events.
> > +
> > +QUORUM_FAILURE
> > +--------------
>
> This should have been inserted in sorted order to match the rest of the
> file, rather than at the end. Can be rearranged in a followup patch,
> now that this series is queued.
>
> > +
> > +Emitted by the Quorum block driver if it fails to establish a quorum.
> > +
> > +Data:
> > +
> > +- "reference": device name if defined else node name.
> > +- "sector-num": Number of the first sector of the failed read operation.
>
> I'm assuming sector-num is relative to the guest's view of the data?
Yes,
>
> > +
> > +QUORUM_REPORT_BAD
> > +-----------------
> > +
> > +Emitted to report a corruption of a Quorum file.
> > +
> > +Data:
> > +
> > +- "ret": The IO return code.
>
> What values is this likely to contain? Is it a finite set, in which
> case it would be nice to have a QAPI enum that describes the set of
> return codes, rather than a raw number?
It's anything that the block stack could return as an error.
>
> I'd like to make sure we are happy with the wire format of this QMP
> event before it gets baked into 2.0.
Ok
>
> --
> Eric Blake eblake redhat com +1-919-301-3266
> Libvirt virtualization library http://libvirt.org
>
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 22:30 ` Benoît Canet
@ 2014-02-21 22:38 ` Kevin Wolf
2014-02-21 22:44 ` Eric Blake
2014-02-21 22:41 ` Eric Blake
1 sibling, 1 reply; 24+ messages in thread
From: Kevin Wolf @ 2014-02-21 22:38 UTC (permalink / raw)
To: Benoît Canet; +Cc: qemu-devel, stefanha, mreitz
Am 21.02.2014 um 23:30 hat Benoît Canet geschrieben:
> The Friday 21 Feb 2014 à 15:09:42 (-0700), Eric Blake wrote :
> > On 02/21/2014 02:21 PM, Benoît Canet wrote:
> > > From: Benoît Canet <benoit@irqsave.net>
> > >
> > > This patchset enables the core of the quorum mechanism.
> > > The num_children reads are compared to get the majority version and if this
> > > version exists more than threshold times the guest won't see the error at all.
> >
> > > +++ b/docs/qmp/qmp-events.txt
> > > @@ -500,3 +500,39 @@ Example:
> > >
> > > Note: If action is "reset", "shutdown", or "pause" the WATCHDOG event is
> > > followed respectively by the RESET, SHUTDOWN, or STOP events.
> > > +
> > > +QUORUM_FAILURE
> > > +--------------
> >
> > This should have been inserted in sorted order to match the rest of the
> > file, rather than at the end. Can be rearranged in a followup patch,
> > now that this series is queued.
> >
> > > +
> > > +Emitted by the Quorum block driver if it fails to establish a quorum.
> > > +
> > > +Data:
> > > +
> > > +- "reference": device name if defined else node name.
> > > +- "sector-num": Number of the first sector of the failed read operation.
> >
> > I'm assuming sector-num is relative to the guest's view of the data?
> Yes,
To be more precise: It's the sector number specified by the layer above
quorum. This can be the guest, but in a different configuration it could
be another block driver.
> > > +
> > > +QUORUM_REPORT_BAD
> > > +-----------------
> > > +
> > > +Emitted to report a corruption of a Quorum file.
> > > +
> > > +Data:
> > > +
> > > +- "ret": The IO return code.
> >
> > What values is this likely to contain? Is it a finite set, in which
> > case it would be nice to have a QAPI enum that describes the set of
> > return codes, rather than a raw number?
>
> It's anything that the block stack could return as an error.
In other words, it's meaning depends on the host and the value is only
suitable for human readers. Perhaps we could change this to strerror(),
which is, I believe, the same as error_setg_errno() does.
Kevin
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 22:38 ` Kevin Wolf
@ 2014-02-21 22:44 ` Eric Blake
2014-02-21 22:50 ` Benoît Canet
0 siblings, 1 reply; 24+ messages in thread
From: Eric Blake @ 2014-02-21 22:44 UTC (permalink / raw)
To: Kevin Wolf, Benoît Canet; +Cc: qemu-devel, stefanha, mreitz
[-- Attachment #1: Type: text/plain, Size: 928 bytes --]
On 02/21/2014 03:38 PM, Kevin Wolf wrote:
>>>> +- "ret": The IO return code.
>>>
>>> What values is this likely to contain? Is it a finite set, in which
>>> case it would be nice to have a QAPI enum that describes the set of
>>> return codes, rather than a raw number?
>>
>> It's anything that the block stack could return as an error.
>
> In other words, it's meaning depends on the host and the value is only
> suitable for human readers. Perhaps we could change this to strerror(),
> which is, I believe, the same as error_setg_errno() does.
Ah, so you're saying that 'ret' would be a '-errno' value - in that
case, yes, converting it to string, and documenting this field as a
human-only strerror() representation of the error would also work (using
'str', rather than an enum type).
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 22:44 ` Eric Blake
@ 2014-02-21 22:50 ` Benoît Canet
2014-02-21 23:32 ` Eric Blake
0 siblings, 1 reply; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 22:50 UTC (permalink / raw)
To: Eric Blake; +Cc: Kevin Wolf, Benoît Canet, qemu-devel, stefanha, mreitz
The Friday 21 Feb 2014 à 15:44:06 (-0700), Eric Blake wrote :
> On 02/21/2014 03:38 PM, Kevin Wolf wrote:
> >>>> +- "ret": The IO return code.
> >>>
> >>> What values is this likely to contain? Is it a finite set, in which
> >>> case it would be nice to have a QAPI enum that describes the set of
> >>> return codes, rather than a raw number?
> >>
> >> It's anything that the block stack could return as an error.
> >
> > In other words, it's meaning depends on the host and the value is only
> > suitable for human readers. Perhaps we could change this to strerror(),
> > which is, I believe, the same as error_setg_errno() does.
>
> Ah, so you're saying that 'ret' would be a '-errno' value - in that
> case, yes, converting it to string, and documenting this field as a
> human-only strerror() representation of the error would also work (using
> 'str', rather than an enum type).
How do I proceed ?
Should I respin the serie ? Or do a follow up patch ?
>
> --
> Eric Blake eblake redhat com +1-919-301-3266
> Libvirt virtualization library http://libvirt.org
>
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 22:50 ` Benoît Canet
@ 2014-02-21 23:32 ` Eric Blake
0 siblings, 0 replies; 24+ messages in thread
From: Eric Blake @ 2014-02-21 23:32 UTC (permalink / raw)
To: Benoît Canet; +Cc: Kevin Wolf, qemu-devel, stefanha, mreitz
[-- Attachment #1: Type: text/plain, Size: 1225 bytes --]
On 02/21/2014 03:50 PM, Benoît Canet wrote:
> The Friday 21 Feb 2014 à 15:44:06 (-0700), Eric Blake wrote :
>> On 02/21/2014 03:38 PM, Kevin Wolf wrote:
>>>>>> +- "ret": The IO return code.
>>>>>
>>>>> What values is this likely to contain? Is it a finite set, in which
>>>>> case it would be nice to have a QAPI enum that describes the set of
>>>>> return codes, rather than a raw number?
>>>>
>>>> It's anything that the block stack could return as an error.
>>>
>>> In other words, it's meaning depends on the host and the value is only
>>> suitable for human readers. Perhaps we could change this to strerror(),
>>> which is, I believe, the same as error_setg_errno() does.
>>
>> Ah, so you're saying that 'ret' would be a '-errno' value - in that
>> case, yes, converting it to string, and documenting this field as a
>> human-only strerror() representation of the error would also work (using
>> 'str', rather than an enum type).
>
> How do I proceed ?
>
> Should I respin the serie ? Or do a follow up patch ?
Followup is fine, as long as we get it done before 2.0.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism.
2014-02-21 22:30 ` Benoît Canet
2014-02-21 22:38 ` Kevin Wolf
@ 2014-02-21 22:41 ` Eric Blake
1 sibling, 0 replies; 24+ messages in thread
From: Eric Blake @ 2014-02-21 22:41 UTC (permalink / raw)
To: Benoît Canet; +Cc: kwolf, qemu-devel, stefanha, mreitz
[-- Attachment #1: Type: text/plain, Size: 1872 bytes --]
On 02/21/2014 03:30 PM, Benoît Canet wrote:
>>> +
>>> +- "ret": The IO return code.
>>
>> What values is this likely to contain? Is it a finite set, in which
>> case it would be nice to have a QAPI enum that describes the set of
>> return codes, rather than a raw number?
>
> It's anything that the block stack could return as an error.
Yes, but returning a raw integer is not friendly. What do those
integers mean? In this patch, I found only two callers that set this
parameter:
quorum_report_bad_versions:
+ quorum_report_bad(acb, s->bs[item->index]->node_name, 0);
So the code means nothing there, because you always pass 0.
quroum_aio_cb:
if (ret == 0) {
acb->success_count++;
+ } else {
+ quorum_report_bad(acb, sacb->aiocb->bs->node_name, ret);
Here, ret is non-zero - but will it ever be anything other than -1?
Seriously, I think you should change this to NOT be an integer, but
instead be an enum value where the enum is tracked in qapi-schema.json.
Change the signature of quorum_report_bad to take the enum value,
rather than a raw int. And over the wire, the QMP event will appear
with a string encoding of the enum name, where we can add named errors
to the enum type as we come up with what different error codes we want
to distinguish. I'm opposed to the current nebulous "it's whatever the
block stack wanted to report" without knowing what it means. If you
can't switch to an enum, it may be better to just delete the field
entirely, if you can't justify what it is doing. QMP-wise, we can
always add more information later, but once the release happens, we
can't take away information, even if later refactoring makes it harder
to support.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* [Qemu-devel] [PATCH V19 07/12] quorum: Add quorum_getlength().
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (5 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 06/12] quorum: Add quorum mechanism Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 08/12] quorum: Add quorum_invalidate_cache() Benoît Canet
` (6 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
Check that every bs file returns the same length.
Otherwise, return -EIO to disable the quorum and
avoid length discrepancy.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 26 ++++++++++++++++++++++++++
1 file changed, 26 insertions(+)
diff --git a/block/quorum.c b/block/quorum.c
index 4beee96..c6ea862 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -595,12 +595,38 @@ static BlockDriverAIOCB *quorum_aio_writev(BlockDriverState *bs,
return &acb->common;
}
+static int64_t quorum_getlength(BlockDriverState *bs)
+{
+ BDRVQuorumState *s = bs->opaque;
+ int64_t result;
+ int i;
+
+ /* check that all file have the same length */
+ result = bdrv_getlength(s->bs[0]);
+ if (result < 0) {
+ return result;
+ }
+ for (i = 1; i < s->num_children; i++) {
+ int64_t value = bdrv_getlength(s->bs[i]);
+ if (value < 0) {
+ return value;
+ }
+ if (value != result) {
+ return -EIO;
+ }
+ }
+
+ return result;
+}
+
static BlockDriver bdrv_quorum = {
.format_name = "quorum",
.protocol_name = "quorum",
.instance_size = sizeof(BDRVQuorumState),
+ .bdrv_getlength = quorum_getlength,
+
.bdrv_aio_readv = quorum_aio_readv,
.bdrv_aio_writev = quorum_aio_writev,
};
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 08/12] quorum: Add quorum_invalidate_cache().
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (6 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 07/12] quorum: Add quorum_getlength() Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 09/12] quorum: Add quorum_co_flush() Benoît Canet
` (5 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
We really want that live migration works with quorum so implement
quorum_invalidate_cache().
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/block/quorum.c b/block/quorum.c
index c6ea862..38bc217 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -619,6 +619,16 @@ static int64_t quorum_getlength(BlockDriverState *bs)
return result;
}
+static void quorum_invalidate_cache(BlockDriverState *bs)
+{
+ BDRVQuorumState *s = bs->opaque;
+ int i;
+
+ for (i = 0; i < s->num_children; i++) {
+ bdrv_invalidate_cache(s->bs[i]);
+ }
+}
+
static BlockDriver bdrv_quorum = {
.format_name = "quorum",
.protocol_name = "quorum",
@@ -629,6 +639,7 @@ static BlockDriver bdrv_quorum = {
.bdrv_aio_readv = quorum_aio_readv,
.bdrv_aio_writev = quorum_aio_writev,
+ .bdrv_invalidate_cache = quorum_invalidate_cache,
};
static void bdrv_quorum_init(void)
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 09/12] quorum: Add quorum_co_flush().
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (7 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 08/12] quorum: Add quorum_invalidate_cache() Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 10/12] quorum: Implement recursive .bdrv_recurse_is_first_non_filter in quorum Benoît Canet
` (4 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
Makes a vote to select error if any.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/block/quorum.c b/block/quorum.c
index 38bc217..840afda 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -629,12 +629,40 @@ static void quorum_invalidate_cache(BlockDriverState *bs)
}
}
+static coroutine_fn int quorum_co_flush(BlockDriverState *bs)
+{
+ BDRVQuorumState *s = bs->opaque;
+ QuorumVoteVersion *winner = NULL;
+ QuorumVotes error_votes;
+ QuorumVoteValue result_value;
+ int i;
+ int result = 0;
+
+ QLIST_INIT(&error_votes.vote_list);
+ error_votes.compare = quorum_64bits_compare;
+
+ for (i = 0; i < s->num_children; i++) {
+ result = bdrv_co_flush(s->bs[i]);
+ result_value.l = result;
+ quorum_count_vote(&error_votes, &result_value, i);
+ }
+
+ winner = quorum_get_vote_winner(&error_votes);
+ result = winner->value.l;
+
+ quorum_free_vote_list(&error_votes);
+
+ return result;
+}
+
static BlockDriver bdrv_quorum = {
.format_name = "quorum",
.protocol_name = "quorum",
.instance_size = sizeof(BDRVQuorumState),
+ .bdrv_co_flush_to_disk = quorum_co_flush,
+
.bdrv_getlength = quorum_getlength,
.bdrv_aio_readv = quorum_aio_readv,
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 10/12] quorum: Implement recursive .bdrv_recurse_is_first_non_filter in quorum.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (8 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 09/12] quorum: Add quorum_co_flush() Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 11/12] quorum: Add quorum_open() and quorum_close() Benoît Canet
` (3 subsequent siblings)
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
This is used to activate quorum snapshot.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/block/quorum.c b/block/quorum.c
index 840afda..1b2b56f 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -655,6 +655,23 @@ static coroutine_fn int quorum_co_flush(BlockDriverState *bs)
return result;
}
+static bool quorum_recurse_is_first_non_filter(BlockDriverState *bs,
+ BlockDriverState *candidate)
+{
+ BDRVQuorumState *s = bs->opaque;
+ int i;
+
+ for (i = 0; i < s->num_children; i++) {
+ bool perm = bdrv_recurse_is_first_non_filter(s->bs[i],
+ candidate);
+ if (perm) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
static BlockDriver bdrv_quorum = {
.format_name = "quorum",
.protocol_name = "quorum",
@@ -668,6 +685,8 @@ static BlockDriver bdrv_quorum = {
.bdrv_aio_readv = quorum_aio_readv,
.bdrv_aio_writev = quorum_aio_writev,
.bdrv_invalidate_cache = quorum_invalidate_cache,
+
+ .bdrv_recurse_is_first_non_filter = quorum_recurse_is_first_non_filter,
};
static void bdrv_quorum_init(void)
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* [Qemu-devel] [PATCH V19 11/12] quorum: Add quorum_open() and quorum_close().
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (9 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 10/12] quorum: Implement recursive .bdrv_recurse_is_first_non_filter in quorum Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:57 ` Eric Blake
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 12/12] quorum: Add unit test Benoît Canet
` (2 subsequent siblings)
13 siblings, 1 reply; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
From: Benoît Canet <benoit@irqsave.net>
Example of command line:
-drive if=virtio,driver=quorum,\
children.0.file.filename=1.raw,\
children.0.node-name=1.raw,\
children.0.driver=raw,\
children.1.file.filename=2.raw,\
children.1.node-name=2.raw,\
children.1.driver=raw,\
children.2.file.filename=3.raw,\
children.2.node-name=3.raw,\
children.2.driver=raw,\
vote-threshold=2
blkverify=on with vote-threshold=2 and two files can be passed to
emulate blkverify.
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
block/quorum.c | 161 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
monitor.c | 3 ++
qapi-schema.json | 21 +++++++-
3 files changed, 184 insertions(+), 1 deletion(-)
diff --git a/block/quorum.c b/block/quorum.c
index 1b2b56f..73dd45b 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -20,6 +20,9 @@
#define HASH_LENGTH 32
+#define QUORUM_OPT_VOTE_THRESHOLD "vote-threshold"
+#define QUORUM_OPT_BLKVERIFY "blkverify"
+
/* This union holds a vote hash value */
typedef union QuorumVoteValue {
char h[HASH_LENGTH]; /* SHA-256 hash */
@@ -672,12 +675,170 @@ static bool quorum_recurse_is_first_non_filter(BlockDriverState *bs,
return false;
}
+static int quorum_valid_threshold(int threshold, int num_children, Error **errp)
+{
+
+ if (threshold < 1) {
+ error_set(errp, QERR_INVALID_PARAMETER_VALUE,
+ "vote-threshold", "value >= 1");
+ return -ERANGE;
+ }
+
+ if (threshold > num_children) {
+ error_setg(errp, "threshold may not exceed children count");
+ return -ERANGE;
+ }
+
+ return 0;
+}
+
+static QemuOptsList quorum_runtime_opts = {
+ .name = "quorum",
+ .head = QTAILQ_HEAD_INITIALIZER(quorum_runtime_opts.head),
+ .desc = {
+ {
+ .name = QUORUM_OPT_VOTE_THRESHOLD,
+ .type = QEMU_OPT_NUMBER,
+ .help = "The number of vote needed for reaching quorum",
+ },
+ {
+ .name = QUORUM_OPT_BLKVERIFY,
+ .type = QEMU_OPT_BOOL,
+ .help = "Trigger block verify mode if set",
+ },
+ { /* end of list */ }
+ },
+};
+
+static int quorum_open(BlockDriverState *bs, QDict *options, int flags,
+ Error **errp)
+{
+ BDRVQuorumState *s = bs->opaque;
+ Error *local_err = NULL;
+ QemuOpts *opts;
+ bool *opened;
+ QDict *sub = NULL;
+ QList *list = NULL;
+ const QListEntry *lentry;
+ const QDictEntry *dentry;
+ int i;
+ int ret = 0;
+
+ qdict_flatten(options);
+ qdict_extract_subqdict(options, &sub, "children.");
+ qdict_array_split(sub, &list);
+
+ /* count how many different children are present and validate
+ * qdict_size(sub) address the open by reference case
+ */
+ s->num_children = !qlist_size(list) ? qdict_size(sub) : qlist_size(list);
+ if (s->num_children < 2) {
+ error_setg(&local_err,
+ "Number of provided children must be greater than 1");
+ ret = -EINVAL;
+ goto exit;
+ }
+
+ opts = qemu_opts_create(&quorum_runtime_opts, NULL, 0, &error_abort);
+ qemu_opts_absorb_qdict(opts, options, &local_err);
+ if (error_is_set(&local_err)) {
+ ret = -EINVAL;
+ goto exit;
+ }
+
+ s->threshold = qemu_opt_get_number(opts, QUORUM_OPT_VOTE_THRESHOLD, 0);
+
+ /* and validate it against s->num_children */
+ ret = quorum_valid_threshold(s->threshold, s->num_children, &local_err);
+ if (ret < 0) {
+ goto exit;
+ }
+
+ /* is the driver in blkverify mode */
+ if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false) &&
+ s->num_children == 2 && s->threshold == 2) {
+ s->is_blkverify = true;
+ } else if (qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false)) {
+ fprintf(stderr, "blkverify mode is set by setting blkverify=on "
+ "and using two files with vote_threshold=2\n");
+ }
+
+ /* allocate the children BlockDriverState array */
+ s->bs = g_new0(BlockDriverState *, s->num_children);
+ opened = g_new0(bool, s->num_children);
+
+ /* Open by file name or options dict (command line or QMP) */
+ if (s->num_children == qlist_size(list)) {
+ for (i = 0, lentry = qlist_first(list); lentry;
+ lentry = qlist_next(lentry), i++) {
+ QDict *d = qobject_to_qdict(lentry->value);
+ QINCREF(d);
+ ret = bdrv_open(&s->bs[i], NULL, NULL, d, flags, NULL, &local_err);
+ if (ret < 0) {
+ goto close_exit;
+ }
+ opened[i] = true;
+ }
+ /* Open by QMP references */
+ } else {
+ for (i = 0, dentry = qdict_first(sub); dentry;
+ dentry = qdict_next(sub, dentry), i++) {
+ QString *string = qobject_to_qstring(dentry->value);
+ ret = bdrv_open(&s->bs[i], NULL, qstring_get_str(string), NULL,
+ flags, NULL, &local_err);
+ if (ret < 0) {
+ goto close_exit;
+ }
+ opened[i] = true;
+ }
+ }
+
+ g_free(opened);
+ goto exit;
+
+close_exit:
+ /* cleanup on error */
+ for (i = 0; i < s->num_children; i++) {
+ if (!opened[i]) {
+ continue;
+ }
+ bdrv_unref(s->bs[i]);
+ }
+ g_free(s->bs);
+ g_free(opened);
+exit:
+ /* propagate error */
+ if (error_is_set(&local_err)) {
+ error_propagate(errp, local_err);
+ }
+ QDECREF(list);
+ QDECREF(sub);
+ return ret;
+}
+
+static void quorum_close(BlockDriverState *bs)
+{
+ BDRVQuorumState *s = bs->opaque;
+ int i;
+
+ for (i = 0; i < s->num_children; i++) {
+ bdrv_unref(s->bs[i]);
+ }
+
+ g_free(s->bs);
+}
+
static BlockDriver bdrv_quorum = {
.format_name = "quorum",
.protocol_name = "quorum",
.instance_size = sizeof(BDRVQuorumState),
+ .bdrv_file_open = quorum_open,
+ .bdrv_close = quorum_close,
+
+ .authorizations = { true, true },
+
.bdrv_co_flush_to_disk = quorum_co_flush,
.bdrv_getlength = quorum_getlength,
diff --git a/monitor.c b/monitor.c
index 8ae095f..aebcbd8 100644
--- a/monitor.c
+++ b/monitor.c
@@ -640,6 +640,9 @@ static void monitor_protocol_event_init(void)
monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
+ /* limit the rate of quorum events to avoid hammering the management */
+ monitor_protocol_event_throttle(QEVENT_QUORUM_REPORT_BAD, 1000);
+ monitor_protocol_event_throttle(QEVENT_QUORUM_FAILURE, 1000);
}
/**
diff --git a/qapi-schema.json b/qapi-schema.json
index 473c096..fcb22800 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -4432,6 +4432,24 @@
'raw': 'BlockdevRef' } }
##
+# @BlockdevOptionsQuorum
+#
+# Driver specific block device options for Quorum
+#
+# @blkverify: #optional true if the driver must print content mismatch
+#
+# @children: the children block device to use
+#
+# @vote_threshold: the vote limit under which a read will fail
+#
+# Since: 2.0
+##
+{ 'type': 'BlockdevOptionsQuorum',
+ 'data': { '*blkverify': 'bool',
+ 'children': [ 'BlockdevRef' ],
+ 'vote-threshold': 'int' } }
+
+##
# @BlockdevOptions
#
# Options for creating a block device.
@@ -4470,7 +4488,8 @@
'vdi': 'BlockdevOptionsGenericFormat',
'vhdx': 'BlockdevOptionsGenericFormat',
'vmdk': 'BlockdevOptionsGenericCOWFormat',
- 'vpc': 'BlockdevOptionsGenericFormat'
+ 'vpc': 'BlockdevOptionsGenericFormat',
+ 'quorum': 'BlockdevOptionsQuorum'
} }
##
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [Qemu-devel] [PATCH V19 11/12] quorum: Add quorum_open() and quorum_close().
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 11/12] quorum: Add quorum_open() and quorum_close() Benoît Canet
@ 2014-02-21 21:57 ` Eric Blake
0 siblings, 0 replies; 24+ messages in thread
From: Eric Blake @ 2014-02-21 21:57 UTC (permalink / raw)
To: Benoît Canet, qemu-devel; +Cc: kwolf, Benoît Canet, stefanha, mreitz
[-- Attachment #1: Type: text/plain, Size: 1394 bytes --]
On 02/21/2014 02:21 PM, Benoît Canet wrote:
> From: Benoît Canet <benoit@irqsave.net>
>
> Example of command line:
>
> -drive if=virtio,driver=quorum,\
> children.0.file.filename=1.raw,\
> children.0.node-name=1.raw,\
> children.0.driver=raw,\
> children.1.file.filename=2.raw,\
> children.1.node-name=2.raw,\
> children.1.driver=raw,\
> children.2.file.filename=3.raw,\
> children.2.node-name=3.raw,\
> children.2.driver=raw,\
> vote-threshold=2
>
> +++ b/qapi-schema.json
> @@ -4432,6 +4432,24 @@
> 'raw': 'BlockdevRef' } }
>
> ##
> +# @BlockdevOptionsQuorum
> +#
> +# Driver specific block device options for Quorum
> +#
> +# @blkverify: #optional true if the driver must print content mismatch
> +#
I might have mentioned it defaults to false.
> +# @children: the children block device to use
s/device/devices/
> +#
> +# @vote_threshold: the vote limit under which a read will fail
s/_/-/ to match the schema below
> +#
> +# Since: 2.0
> +##
> +{ 'type': 'BlockdevOptionsQuorum',
> + 'data': { '*blkverify': 'bool',
> + 'children': [ 'BlockdevRef' ],
> + 'vote-threshold': 'int' } }
As this series is already queued, we may need a followup patch to fix
these nits.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread
* [Qemu-devel] [PATCH V19 12/12] quorum: Add unit test.
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (10 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 11/12] quorum: Add quorum_open() and quorum_close() Benoît Canet
@ 2014-02-21 21:21 ` Benoît Canet
2014-02-21 21:39 ` [Qemu-devel] [PATCH V19 00/12] Quorum block filter Kevin Wolf
2014-02-21 22:49 ` Eric Blake
13 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 21:21 UTC (permalink / raw)
To: qemu-devel; +Cc: kwolf, Benoît Canet, Benoit Canet, stefanha, mreitz
Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
tests/qemu-iotests/081 | 95 ++++++++++++++++++++++++++++++++++++++++++++++
tests/qemu-iotests/081.out | 34 +++++++++++++++++
tests/qemu-iotests/group | 1 +
3 files changed, 130 insertions(+)
create mode 100755 tests/qemu-iotests/081
create mode 100644 tests/qemu-iotests/081.out
diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
new file mode 100755
index 0000000..be34544
--- /dev/null
+++ b/tests/qemu-iotests/081
@@ -0,0 +1,95 @@
+#!/bin/bash
+#
+# Test Quorum block driver
+#
+# Copyright (C) 2013 Nodalink, SARL.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+# creator
+owner=benoit@irqsave.net
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+tmp=/tmp/$$
+status=1 # failure is the default!
+
+_cleanup()
+{
+ rm -rf $TEST_DIR/1.raw
+ rm -rf $TEST_DIR/2.raw
+ rm -rf $TEST_DIR/3.raw
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt raw
+_supported_proto generic
+_supported_os Linux
+
+quorum="file.driver=quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
+quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
+quorum="$quorum,file.children.2.file.filename=$TEST_DIR/3.raw,file.vote-threshold=2"
+
+echo
+echo "== creating quorum files =="
+
+size=10M
+
+TEST_IMG="$TEST_DIR/1.raw" _make_test_img $size
+TEST_IMG="$TEST_DIR/2.raw" _make_test_img $size
+TEST_IMG="$TEST_DIR/3.raw" _make_test_img $size
+
+echo
+echo "== writing images =="
+
+$QEMU_IO -c "open -o $quorum" -c "write -P 0x32 0 $size" | _filter_qemu_io
+
+echo
+echo "== checking quorum write =="
+
+$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/1.raw" | _filter_qemu_io
+$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io
+$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/3.raw" | _filter_qemu_io
+
+echo
+echo "== corrupting image =="
+
+$QEMU_IO -c "write -P 0x42 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io
+
+echo
+echo "== checking quorum correction =="
+
+$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
+
+echo
+echo "== breaking quorum =="
+
+$QEMU_IO -c "write -P 0x41 0 $size" "$TEST_DIR/1.raw" | _filter_qemu_io
+echo
+echo "== checking that quorum is broken =="
+
+$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io
+
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/081.out b/tests/qemu-iotests/081.out
new file mode 100644
index 0000000..b5b55ab
--- /dev/null
+++ b/tests/qemu-iotests/081.out
@@ -0,0 +1,34 @@
+QA output created by 081
+
+== creating quorum files ==
+Formatting 'TEST_DIR/1.IMGFMT', fmt=IMGFMT size=10485760
+Formatting 'TEST_DIR/2.IMGFMT', fmt=IMGFMT size=10485760
+Formatting 'TEST_DIR/3.IMGFMT', fmt=IMGFMT size=10485760
+
+== writing images ==
+wrote 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== checking quorum write ==
+read 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== corrupting image ==
+wrote 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== checking quorum correction ==
+read 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== breaking quorum ==
+wrote 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== checking that quorum is broken ==
+qemu-io: can't open device (null): Could not read image for determining its format: Input/output error
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index 80b181f..db127d9 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -83,4 +83,5 @@
074 rw auto
077 rw auto
079 rw auto
+081 rw auto
082 rw auto quick
--
1.8.3.2
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [Qemu-devel] [PATCH V19 00/12] Quorum block filter
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (11 preceding siblings ...)
2014-02-21 21:21 ` [Qemu-devel] [PATCH V19 12/12] quorum: Add unit test Benoît Canet
@ 2014-02-21 21:39 ` Kevin Wolf
2014-02-21 22:49 ` Eric Blake
13 siblings, 0 replies; 24+ messages in thread
From: Kevin Wolf @ 2014-02-21 21:39 UTC (permalink / raw)
To: Benoît Canet; +Cc: qemu-devel, stefanha, mreitz
Am 21.02.2014 um 22:21 hat Benoît Canet geschrieben:
> Hi this is the latest version of the quorum block filter.
>
> This version fix the qmp events and a small rebase conflict.
>
> tested:
>
> tested that json qmp string are correct and parse well with python
>
> Ran qemu-iotest including 081 ok
>
> quorum command line ok
> quorum command line snapshot transaction ok
> quorum QMP by reference ok
> quorum QMP by reference and snapshot transaction ok
> quorum QMP at once ok
> quorum QMP at once and snapshot transaction ok
Thanks, applied to the block branch.
Kevin
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [Qemu-devel] [PATCH V19 00/12] Quorum block filter
2014-02-21 21:21 [Qemu-devel] [PATCH V19 00/12] Quorum block filter Benoît Canet
` (12 preceding siblings ...)
2014-02-21 21:39 ` [Qemu-devel] [PATCH V19 00/12] Quorum block filter Kevin Wolf
@ 2014-02-21 22:49 ` Eric Blake
2014-02-21 22:58 ` Benoît Canet
13 siblings, 1 reply; 24+ messages in thread
From: Eric Blake @ 2014-02-21 22:49 UTC (permalink / raw)
To: Benoît Canet, qemu-devel; +Cc: kwolf, stefanha, mreitz
[-- Attachment #1: Type: text/plain, Size: 1110 bytes --]
On 02/21/2014 02:21 PM, Benoît Canet wrote:
> Hi this is the latest version of the quorum block filter.
>
> This version fix the qmp events and a small rebase conflict.
>
> tested:
>
> tested that json qmp string are correct and parse well with python
>
> Ran qemu-iotest including 081 ok
>
> quorum command line ok
> quorum command line snapshot transaction ok
> quorum QMP by reference ok
> quorum QMP by reference and snapshot transaction ok
> quorum QMP at once ok
> quorum QMP at once and snapshot transaction ok
Generic question:
When the quorum detects mismatch but there was still a majority, is
there a way to request that the quorum correct the odd man out? That
is, if I have a 2/3 quorum, and files A and B read '1' while C reads
'2', can the mere act of reading that sector be used to write '1' into C?
Obviously, this should be an optional mode, not enabled by default; but
I could envision creating a self-healing redundant array via this method.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [Qemu-devel] [PATCH V19 00/12] Quorum block filter
2014-02-21 22:49 ` Eric Blake
@ 2014-02-21 22:58 ` Benoît Canet
0 siblings, 0 replies; 24+ messages in thread
From: Benoît Canet @ 2014-02-21 22:58 UTC (permalink / raw)
To: Eric Blake; +Cc: Benoît Canet, kwolf, qemu-devel, stefanha, mreitz
The Friday 21 Feb 2014 à 15:49:15 (-0700), Eric Blake wrote :
> On 02/21/2014 02:21 PM, Benoît Canet wrote:
> > Hi this is the latest version of the quorum block filter.
> >
> > This version fix the qmp events and a small rebase conflict.
> >
> > tested:
> >
> > tested that json qmp string are correct and parse well with python
> >
> > Ran qemu-iotest including 081 ok
> >
> > quorum command line ok
> > quorum command line snapshot transaction ok
> > quorum QMP by reference ok
> > quorum QMP by reference and snapshot transaction ok
> > quorum QMP at once ok
> > quorum QMP at once and snapshot transaction ok
>
> Generic question:
>
> When the quorum detects mismatch but there was still a majority, is
> there a way to request that the quorum correct the odd man out? That
> is, if I have a 2/3 quorum, and files A and B read '1' while C reads
> '2', can the mere act of reading that sector be used to write '1' into C?
>
> Obviously, this should be an optional mode, not enabled by default; but
> I could envision creating a self-healing redundant array via this method.
That's part of the optional features I want to add.
I choose to start small to get it merged faster.
I also plan to modify drive-mirror to do a bdrv_swap when the mirroring is
finished in order to replace a faultly quorum file.
Best regards
Benoît
>
> --
> Eric Blake eblake redhat com +1-919-301-3266
> Libvirt virtualization library http://libvirt.org
>
^ permalink raw reply [flat|nested] 24+ messages in thread