blob: f2c08050000e8ce8f2ff5d4c60177c23072fa5bc [file] [log] [blame]
Benoît Canet27cec152014-02-21 22:21:10 +01001/*
2 * Quorum Block filter
3 *
4 * Copyright (C) 2012-2014 Nodalink, EURL.
5 *
6 * Author:
7 * Benoît Canet <benoit.canet@irqsave.net>
8 *
9 * Based on the design and code of blkverify.c (Copyright (C) 2010 IBM, Corp)
10 * and blkmirror.c (Copyright (C) 2011 Red Hat, Inc).
11 *
12 * This work is licensed under the terms of the GNU GPL, version 2 or later.
13 * See the COPYING file in the top-level directory.
14 */
15
Peter Maydell80c71a22016-01-18 18:01:42 +000016#include "qemu/osdep.h"
Wen Congyang98292c62016-05-10 15:36:38 +080017#include "qemu/cutils.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020018#include "qemu/module.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010019#include "qemu/option.h"
Benoît Canet27cec152014-02-21 22:21:10 +010020#include "block/block_int.h"
Alberto Garciaef9bba12020-11-13 17:52:31 +010021#include "block/coroutines.h"
Max Reitz609f45e2018-06-14 21:14:28 +020022#include "block/qdict.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010023#include "qapi/error.h"
Markus Armbruster9af23982018-02-11 10:36:01 +010024#include "qapi/qapi-events-block.h"
Max Reitzfafcfe22014-07-18 20:25:00 +020025#include "qapi/qmp/qdict.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010026#include "qapi/qmp/qerror.h"
Max Reitzfafcfe22014-07-18 20:25:00 +020027#include "qapi/qmp/qlist.h"
28#include "qapi/qmp/qstring.h"
Daniel P. Berrange488981a42015-07-01 18:10:35 +010029#include "crypto/hash.h"
Benoît Canet95c6bff2014-02-21 22:21:15 +010030
31#define HASH_LENGTH 32
32
Lukas Straub5eb9a3c2020-08-04 12:46:42 +020033#define INDEXSTR_LEN 32
34
Benoît Canetc88a1de2014-02-21 22:21:20 +010035#define QUORUM_OPT_VOTE_THRESHOLD "vote-threshold"
36#define QUORUM_OPT_BLKVERIFY "blkverify"
Benoît Canetcf29a572014-06-11 15:24:10 +020037#define QUORUM_OPT_REWRITE "rewrite-corrupted"
Liu Yuana9db86b2014-08-18 17:41:05 +080038#define QUORUM_OPT_READ_PATTERN "read-pattern"
Benoît Canetc88a1de2014-02-21 22:21:20 +010039
Benoît Canet95c6bff2014-02-21 22:21:15 +010040/* This union holds a vote hash value */
41typedef union QuorumVoteValue {
Daniel P. Berrange488981a42015-07-01 18:10:35 +010042 uint8_t h[HASH_LENGTH]; /* SHA-256 hash */
Benoît Canet95c6bff2014-02-21 22:21:15 +010043 int64_t l; /* simpler 64 bits hash */
44} QuorumVoteValue;
45
46/* A vote item */
47typedef struct QuorumVoteItem {
48 int index;
49 QLIST_ENTRY(QuorumVoteItem) next;
50} QuorumVoteItem;
51
52/* this structure is a vote version. A version is the set of votes sharing the
53 * same vote value.
54 * The set of votes will be tracked with the items field and its cardinality is
55 * vote_count.
56 */
57typedef struct QuorumVoteVersion {
58 QuorumVoteValue value;
59 int index;
60 int vote_count;
61 QLIST_HEAD(, QuorumVoteItem) items;
62 QLIST_ENTRY(QuorumVoteVersion) next;
63} QuorumVoteVersion;
64
65/* this structure holds a group of vote versions together */
66typedef struct QuorumVotes {
67 QLIST_HEAD(, QuorumVoteVersion) vote_list;
68 bool (*compare)(QuorumVoteValue *a, QuorumVoteValue *b);
69} QuorumVotes;
Benoît Canet27cec152014-02-21 22:21:10 +010070
Benoît Canetcadebd72014-02-21 22:21:11 +010071/* the following structure holds the state of one quorum instance */
72typedef struct BDRVQuorumState {
Kevin Wolf0bd6e912015-06-16 11:29:22 +020073 BdrvChild **children; /* children BlockDriverStates */
Benoît Canetcadebd72014-02-21 22:21:11 +010074 int num_children; /* children count */
Wen Congyang98292c62016-05-10 15:36:38 +080075 unsigned next_child_index; /* the index of the next child that should
76 * be added
77 */
Benoît Canetcadebd72014-02-21 22:21:11 +010078 int threshold; /* if less than threshold children reads gave the
79 * same result a quorum error occurs.
80 */
81 bool is_blkverify; /* true if the driver is in blkverify mode
82 * Writes are mirrored on two children devices.
83 * On reads the two children devices' contents are
84 * compared and if a difference is spotted its
85 * location is printed and the code aborts.
86 * It is useful to debug other block drivers by
87 * comparing them with a reference one.
88 */
Benoît Canetcf29a572014-06-11 15:24:10 +020089 bool rewrite_corrupted;/* true if the driver must rewrite-on-read corrupted
90 * block if Quorum is reached.
91 */
Liu Yuana9db86b2014-08-18 17:41:05 +080092
93 QuorumReadPattern read_pattern;
Benoît Canetcadebd72014-02-21 22:21:11 +010094} BDRVQuorumState;
95
Benoît Canet27cec152014-02-21 22:21:10 +010096typedef struct QuorumAIOCB QuorumAIOCB;
97
98/* Quorum will create one instance of the following structure per operation it
99 * performs on its children.
100 * So for each read/write operation coming from the upper layer there will be
101 * $children_count QuorumChildRequest.
102 */
103typedef struct QuorumChildRequest {
Kevin Wolfce15dc02016-11-08 11:10:14 +0100104 BlockDriverState *bs;
Benoît Canet27cec152014-02-21 22:21:10 +0100105 QEMUIOVector qiov;
106 uint8_t *buf;
107 int ret;
108 QuorumAIOCB *parent;
109} QuorumChildRequest;
110
111/* Quorum will use the following structure to track progress of each read/write
112 * operation received by the upper layer.
113 * This structure hold pointers to the QuorumChildRequest structures instances
114 * used to do operations on each children and track overall progress.
115 */
116struct QuorumAIOCB {
Kevin Wolfce15dc02016-11-08 11:10:14 +0100117 BlockDriverState *bs;
118 Coroutine *co;
Benoît Canet27cec152014-02-21 22:21:10 +0100119
120 /* Request metadata */
Kevin Wolf6847da32016-11-10 17:22:07 +0100121 uint64_t offset;
122 uint64_t bytes;
Max Reitz1b1a9202018-04-21 15:29:25 +0200123 int flags;
Benoît Canet27cec152014-02-21 22:21:10 +0100124
125 QEMUIOVector *qiov; /* calling IOV */
126
127 QuorumChildRequest *qcrs; /* individual child requests */
128 int count; /* number of completed AIOCB */
129 int success_count; /* number of successfully completed AIOCB */
130
Benoît Canetcf29a572014-06-11 15:24:10 +0200131 int rewrite_count; /* number of replica to rewrite: count down to
132 * zero once writes are fired
133 */
134
Benoît Canet95c6bff2014-02-21 22:21:15 +0100135 QuorumVotes votes;
136
Benoît Canet27cec152014-02-21 22:21:10 +0100137 bool is_read;
138 int vote_ret;
Paolo Bonzini86ec2522016-10-05 18:35:26 +0200139 int children_read; /* how many children have been read from */
Benoît Canet27cec152014-02-21 22:21:10 +0100140};
Benoît Canetcadebd72014-02-21 22:21:11 +0100141
Kevin Wolfce15dc02016-11-08 11:10:14 +0100142typedef struct QuorumCo {
143 QuorumAIOCB *acb;
144 int idx;
145} QuorumCo;
146
Benoît Canet13e79562014-02-21 22:21:12 +0100147static void quorum_aio_finalize(QuorumAIOCB *acb)
148{
Benoît Canet13e79562014-02-21 22:21:12 +0100149 g_free(acb->qcrs);
Kevin Wolf0f319772016-11-10 14:24:27 +0100150 g_free(acb);
Benoît Canet13e79562014-02-21 22:21:12 +0100151}
152
Benoît Canet95c6bff2014-02-21 22:21:15 +0100153static bool quorum_sha256_compare(QuorumVoteValue *a, QuorumVoteValue *b)
154{
155 return !memcmp(a->h, b->h, HASH_LENGTH);
156}
157
158static bool quorum_64bits_compare(QuorumVoteValue *a, QuorumVoteValue *b)
159{
160 return a->l == b->l;
161}
162
Kevin Wolf10c85512016-11-07 18:00:29 +0100163static QuorumAIOCB *quorum_aio_get(BlockDriverState *bs,
Benoît Canet13e79562014-02-21 22:21:12 +0100164 QEMUIOVector *qiov,
Kevin Wolf6847da32016-11-10 17:22:07 +0100165 uint64_t offset,
Max Reitz1b1a9202018-04-21 15:29:25 +0200166 uint64_t bytes,
167 int flags)
Benoît Canet13e79562014-02-21 22:21:12 +0100168{
Kevin Wolf10c85512016-11-07 18:00:29 +0100169 BDRVQuorumState *s = bs->opaque;
Kevin Wolfce15dc02016-11-08 11:10:14 +0100170 QuorumAIOCB *acb = g_new(QuorumAIOCB, 1);
Benoît Canet13e79562014-02-21 22:21:12 +0100171 int i;
172
Kevin Wolf7c37f942016-11-22 12:49:49 +0100173 *acb = (QuorumAIOCB) {
174 .co = qemu_coroutine_self(),
175 .bs = bs,
176 .offset = offset,
177 .bytes = bytes,
Max Reitz1b1a9202018-04-21 15:29:25 +0200178 .flags = flags,
Kevin Wolf7c37f942016-11-22 12:49:49 +0100179 .qiov = qiov,
180 .votes.compare = quorum_sha256_compare,
181 .votes.vote_list = QLIST_HEAD_INITIALIZER(acb.votes.vote_list),
182 };
Benoît Canet13e79562014-02-21 22:21:12 +0100183
Kevin Wolf7c37f942016-11-22 12:49:49 +0100184 acb->qcrs = g_new0(QuorumChildRequest, s->num_children);
Benoît Canet13e79562014-02-21 22:21:12 +0100185 for (i = 0; i < s->num_children; i++) {
186 acb->qcrs[i].buf = NULL;
187 acb->qcrs[i].ret = 0;
188 acb->qcrs[i].parent = acb;
189 }
190
191 return acb;
192}
193
Kevin Wolf6847da32016-11-10 17:22:07 +0100194static void quorum_report_bad(QuorumOpType type, uint64_t offset,
195 uint64_t bytes, char *node_name, int ret)
Benoît Canet95c6bff2014-02-21 22:21:15 +0100196{
Wenchao Xiafe069d92014-06-18 08:43:53 +0200197 const char *msg = NULL;
Kevin Wolf6847da32016-11-10 17:22:07 +0100198 int64_t start_sector = offset / BDRV_SECTOR_SIZE;
199 int64_t end_sector = DIV_ROUND_UP(offset + bytes, BDRV_SECTOR_SIZE);
200
Benoît Canet0c762732014-02-22 18:43:41 +0100201 if (ret < 0) {
Wenchao Xiafe069d92014-06-18 08:43:53 +0200202 msg = strerror(-ret);
Benoît Canet0c762732014-02-22 18:43:41 +0100203 }
Changlong Xie0ae053b2016-02-26 09:39:01 +0800204
Kevin Wolf6847da32016-11-10 17:22:07 +0100205 qapi_event_send_quorum_report_bad(type, !!msg, msg, node_name, start_sector,
Peter Xu3ab72382018-08-15 21:37:37 +0800206 end_sector - start_sector);
Benoît Canet95c6bff2014-02-21 22:21:15 +0100207}
208
209static void quorum_report_failure(QuorumAIOCB *acb)
210{
Kevin Wolfce15dc02016-11-08 11:10:14 +0100211 const char *reference = bdrv_get_device_or_node_name(acb->bs);
Kevin Wolf6847da32016-11-10 17:22:07 +0100212 int64_t start_sector = acb->offset / BDRV_SECTOR_SIZE;
213 int64_t end_sector = DIV_ROUND_UP(acb->offset + acb->bytes,
214 BDRV_SECTOR_SIZE);
215
216 qapi_event_send_quorum_failure(reference, start_sector,
Peter Xu3ab72382018-08-15 21:37:37 +0800217 end_sector - start_sector);
Benoît Canet95c6bff2014-02-21 22:21:15 +0100218}
219
220static int quorum_vote_error(QuorumAIOCB *acb);
221
222static bool quorum_has_too_much_io_failed(QuorumAIOCB *acb)
223{
Kevin Wolfce15dc02016-11-08 11:10:14 +0100224 BDRVQuorumState *s = acb->bs->opaque;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100225
226 if (acb->success_count < s->threshold) {
227 acb->vote_ret = quorum_vote_error(acb);
228 quorum_report_failure(acb);
229 return true;
230 }
231
232 return false;
233}
234
Kevin Wolfce15dc02016-11-08 11:10:14 +0100235static int read_fifo_child(QuorumAIOCB *acb);
Liu Yuana9db86b2014-08-18 17:41:05 +0800236
237static void quorum_copy_qiov(QEMUIOVector *dest, QEMUIOVector *source)
238{
239 int i;
240 assert(dest->niov == source->niov);
241 assert(dest->size == source->size);
242 for (i = 0; i < source->niov; i++) {
243 assert(dest->iov[i].iov_len == source->iov[i].iov_len);
244 memcpy(dest->iov[i].iov_base,
245 source->iov[i].iov_base,
246 source->iov[i].iov_len);
247 }
248}
249
Paolo Bonzini1ba7e152016-10-05 18:35:27 +0200250static void quorum_report_bad_acb(QuorumChildRequest *sacb, int ret)
251{
252 QuorumAIOCB *acb = sacb->parent;
253 QuorumOpType type = acb->is_read ? QUORUM_OP_TYPE_READ : QUORUM_OP_TYPE_WRITE;
Kevin Wolf6847da32016-11-10 17:22:07 +0100254 quorum_report_bad(type, acb->offset, acb->bytes, sacb->bs->node_name, ret);
Paolo Bonzini1ba7e152016-10-05 18:35:27 +0200255}
256
Benoît Canet95c6bff2014-02-21 22:21:15 +0100257static void quorum_report_bad_versions(BDRVQuorumState *s,
258 QuorumAIOCB *acb,
259 QuorumVoteValue *value)
260{
261 QuorumVoteVersion *version;
262 QuorumVoteItem *item;
263
264 QLIST_FOREACH(version, &acb->votes.vote_list, next) {
265 if (acb->votes.compare(&version->value, value)) {
266 continue;
267 }
268 QLIST_FOREACH(item, &version->items, next) {
Kevin Wolf6847da32016-11-10 17:22:07 +0100269 quorum_report_bad(QUORUM_OP_TYPE_READ, acb->offset, acb->bytes,
Changlong Xie0ae053b2016-02-26 09:39:01 +0800270 s->children[item->index]->bs->node_name, 0);
Benoît Canet95c6bff2014-02-21 22:21:15 +0100271 }
272 }
273}
274
Kevin Wolfdee66e22016-11-10 16:50:16 +0100275static void quorum_rewrite_entry(void *opaque)
276{
277 QuorumCo *co = opaque;
278 QuorumAIOCB *acb = co->acb;
279 BDRVQuorumState *s = acb->bs->opaque;
280
281 /* Ignore any errors, it's just a correction attempt for already
Max Reitz1b1a9202018-04-21 15:29:25 +0200282 * corrupted data.
283 * Mask out BDRV_REQ_WRITE_UNCHANGED because this overwrites the
284 * area with different data from the other children. */
Kevin Wolf6847da32016-11-10 17:22:07 +0100285 bdrv_co_pwritev(s->children[co->idx], acb->offset, acb->bytes,
Max Reitz1b1a9202018-04-21 15:29:25 +0200286 acb->qiov, acb->flags & ~BDRV_REQ_WRITE_UNCHANGED);
Kevin Wolfdee66e22016-11-10 16:50:16 +0100287
288 /* Wake up the caller after the last rewrite */
289 acb->rewrite_count--;
290 if (!acb->rewrite_count) {
291 qemu_coroutine_enter_if_inactive(acb->co);
292 }
293}
294
295static bool quorum_rewrite_bad_versions(QuorumAIOCB *acb,
Benoît Canetcf29a572014-06-11 15:24:10 +0200296 QuorumVoteValue *value)
297{
298 QuorumVoteVersion *version;
299 QuorumVoteItem *item;
300 int count = 0;
301
302 /* first count the number of bad versions: done first to avoid concurrency
303 * issues.
304 */
305 QLIST_FOREACH(version, &acb->votes.vote_list, next) {
306 if (acb->votes.compare(&version->value, value)) {
307 continue;
308 }
309 QLIST_FOREACH(item, &version->items, next) {
310 count++;
311 }
312 }
313
Kevin Wolfdee66e22016-11-10 16:50:16 +0100314 /* quorum_rewrite_entry will count down this to zero */
Benoît Canetcf29a572014-06-11 15:24:10 +0200315 acb->rewrite_count = count;
316
317 /* now fire the correcting rewrites */
318 QLIST_FOREACH(version, &acb->votes.vote_list, next) {
319 if (acb->votes.compare(&version->value, value)) {
320 continue;
321 }
322 QLIST_FOREACH(item, &version->items, next) {
Kevin Wolfdee66e22016-11-10 16:50:16 +0100323 Coroutine *co;
324 QuorumCo data = {
325 .acb = acb,
326 .idx = item->index,
327 };
328
329 co = qemu_coroutine_create(quorum_rewrite_entry, &data);
330 qemu_coroutine_enter(co);
Benoît Canetcf29a572014-06-11 15:24:10 +0200331 }
332 }
333
334 /* return true if any rewrite is done else false */
335 return count;
336}
337
Benoît Canet95c6bff2014-02-21 22:21:15 +0100338static void quorum_count_vote(QuorumVotes *votes,
339 QuorumVoteValue *value,
340 int index)
341{
342 QuorumVoteVersion *v = NULL, *version = NULL;
343 QuorumVoteItem *item;
344
345 /* look if we have something with this hash */
346 QLIST_FOREACH(v, &votes->vote_list, next) {
347 if (votes->compare(&v->value, value)) {
348 version = v;
349 break;
350 }
351 }
352
353 /* It's a version not yet in the list add it */
354 if (!version) {
355 version = g_new0(QuorumVoteVersion, 1);
356 QLIST_INIT(&version->items);
357 memcpy(&version->value, value, sizeof(version->value));
358 version->index = index;
359 version->vote_count = 0;
360 QLIST_INSERT_HEAD(&votes->vote_list, version, next);
361 }
362
363 version->vote_count++;
364
365 item = g_new0(QuorumVoteItem, 1);
366 item->index = index;
367 QLIST_INSERT_HEAD(&version->items, item, next);
368}
369
370static void quorum_free_vote_list(QuorumVotes *votes)
371{
372 QuorumVoteVersion *version, *next_version;
373 QuorumVoteItem *item, *next_item;
374
375 QLIST_FOREACH_SAFE(version, &votes->vote_list, next, next_version) {
376 QLIST_REMOVE(version, next);
377 QLIST_FOREACH_SAFE(item, &version->items, next, next_item) {
378 QLIST_REMOVE(item, next);
379 g_free(item);
380 }
381 g_free(version);
382 }
383}
384
385static int quorum_compute_hash(QuorumAIOCB *acb, int i, QuorumVoteValue *hash)
386{
Benoît Canet95c6bff2014-02-21 22:21:15 +0100387 QEMUIOVector *qiov = &acb->qcrs[i].qiov;
Daniel P. Berrange488981a42015-07-01 18:10:35 +0100388 size_t len = sizeof(hash->h);
389 uint8_t *data = hash->h;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100390
Daniel P. Berrange488981a42015-07-01 18:10:35 +0100391 /* XXX - would be nice if we could pass in the Error **
392 * and propagate that back, but this quorum code is
393 * restricted to just errno values currently */
394 if (qcrypto_hash_bytesv(QCRYPTO_HASH_ALG_SHA256,
395 qiov->iov, qiov->niov,
396 &data, &len,
397 NULL) < 0) {
398 return -EINVAL;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100399 }
400
Daniel P. Berrange488981a42015-07-01 18:10:35 +0100401 return 0;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100402}
403
404static QuorumVoteVersion *quorum_get_vote_winner(QuorumVotes *votes)
405{
406 int max = 0;
407 QuorumVoteVersion *candidate, *winner = NULL;
408
409 QLIST_FOREACH(candidate, &votes->vote_list, next) {
410 if (candidate->vote_count > max) {
411 max = candidate->vote_count;
412 winner = candidate;
413 }
414 }
415
416 return winner;
417}
418
419/* qemu_iovec_compare is handy for blkverify mode because it returns the first
420 * differing byte location. Yet it is handcoded to compare vectors one byte
421 * after another so it does not benefit from the libc SIMD optimizations.
422 * quorum_iovec_compare is written for speed and should be used in the non
423 * blkverify mode of quorum.
424 */
425static bool quorum_iovec_compare(QEMUIOVector *a, QEMUIOVector *b)
426{
427 int i;
428 int result;
429
430 assert(a->niov == b->niov);
431 for (i = 0; i < a->niov; i++) {
432 assert(a->iov[i].iov_len == b->iov[i].iov_len);
433 result = memcmp(a->iov[i].iov_base,
434 b->iov[i].iov_base,
435 a->iov[i].iov_len);
436 if (result) {
437 return false;
438 }
439 }
440
441 return true;
442}
443
Alberto Garcia6840e8d2018-10-17 17:33:49 +0300444static bool quorum_compare(QuorumAIOCB *acb, QEMUIOVector *a, QEMUIOVector *b)
Benoît Canet95c6bff2014-02-21 22:21:15 +0100445{
Kevin Wolfce15dc02016-11-08 11:10:14 +0100446 BDRVQuorumState *s = acb->bs->opaque;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100447 ssize_t offset;
448
449 /* This driver will replace blkverify in this particular case */
450 if (s->is_blkverify) {
451 offset = qemu_iovec_compare(a, b);
452 if (offset != -1) {
Alberto Garcia6840e8d2018-10-17 17:33:49 +0300453 fprintf(stderr, "quorum: offset=%" PRIu64 " bytes=%" PRIu64
454 " contents mismatch at offset %" PRIu64 "\n",
455 acb->offset, acb->bytes, acb->offset + offset);
456 exit(1);
Benoît Canet95c6bff2014-02-21 22:21:15 +0100457 }
458 return true;
459 }
460
461 return quorum_iovec_compare(a, b);
462}
463
464/* Do a vote to get the error code */
465static int quorum_vote_error(QuorumAIOCB *acb)
466{
Kevin Wolfce15dc02016-11-08 11:10:14 +0100467 BDRVQuorumState *s = acb->bs->opaque;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100468 QuorumVoteVersion *winner = NULL;
469 QuorumVotes error_votes;
470 QuorumVoteValue result_value;
471 int i, ret = 0;
472 bool error = false;
473
474 QLIST_INIT(&error_votes.vote_list);
475 error_votes.compare = quorum_64bits_compare;
476
477 for (i = 0; i < s->num_children; i++) {
478 ret = acb->qcrs[i].ret;
479 if (ret) {
480 error = true;
481 result_value.l = ret;
482 quorum_count_vote(&error_votes, &result_value, i);
483 }
484 }
485
486 if (error) {
487 winner = quorum_get_vote_winner(&error_votes);
488 ret = winner->value.l;
489 }
490
491 quorum_free_vote_list(&error_votes);
492
493 return ret;
494}
495
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100496static void quorum_vote(QuorumAIOCB *acb)
Benoît Canet95c6bff2014-02-21 22:21:15 +0100497{
498 bool quorum = true;
499 int i, j, ret;
500 QuorumVoteValue hash;
Kevin Wolfce15dc02016-11-08 11:10:14 +0100501 BDRVQuorumState *s = acb->bs->opaque;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100502 QuorumVoteVersion *winner;
503
504 if (quorum_has_too_much_io_failed(acb)) {
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100505 return;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100506 }
507
508 /* get the index of the first successful read */
509 for (i = 0; i < s->num_children; i++) {
510 if (!acb->qcrs[i].ret) {
511 break;
512 }
513 }
514
515 assert(i < s->num_children);
516
517 /* compare this read with all other successful reads stopping at quorum
518 * failure
519 */
520 for (j = i + 1; j < s->num_children; j++) {
521 if (acb->qcrs[j].ret) {
522 continue;
523 }
524 quorum = quorum_compare(acb, &acb->qcrs[i].qiov, &acb->qcrs[j].qiov);
525 if (!quorum) {
526 break;
527 }
528 }
529
530 /* Every successful read agrees */
531 if (quorum) {
532 quorum_copy_qiov(acb->qiov, &acb->qcrs[i].qiov);
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100533 return;
Benoît Canet95c6bff2014-02-21 22:21:15 +0100534 }
535
536 /* compute hashes for each successful read, also store indexes */
537 for (i = 0; i < s->num_children; i++) {
538 if (acb->qcrs[i].ret) {
539 continue;
540 }
541 ret = quorum_compute_hash(acb, i, &hash);
542 /* if ever the hash computation failed */
543 if (ret < 0) {
544 acb->vote_ret = ret;
545 goto free_exit;
546 }
547 quorum_count_vote(&acb->votes, &hash, i);
548 }
549
550 /* vote to select the most represented version */
551 winner = quorum_get_vote_winner(&acb->votes);
552
553 /* if the winner count is smaller than threshold the read fails */
554 if (winner->vote_count < s->threshold) {
555 quorum_report_failure(acb);
556 acb->vote_ret = -EIO;
557 goto free_exit;
558 }
559
560 /* we have a winner: copy it */
561 quorum_copy_qiov(acb->qiov, &acb->qcrs[winner->index].qiov);
562
563 /* some versions are bad print them */
564 quorum_report_bad_versions(s, acb, &winner->value);
565
Benoît Canetcf29a572014-06-11 15:24:10 +0200566 /* corruption correction is enabled */
567 if (s->rewrite_corrupted) {
Kevin Wolfdee66e22016-11-10 16:50:16 +0100568 quorum_rewrite_bad_versions(acb, &winner->value);
Benoît Canetcf29a572014-06-11 15:24:10 +0200569 }
570
Benoît Canet95c6bff2014-02-21 22:21:15 +0100571free_exit:
572 /* free lists */
573 quorum_free_vote_list(&acb->votes);
574}
575
Kevin Wolfce15dc02016-11-08 11:10:14 +0100576static void read_quorum_children_entry(void *opaque)
Liu Yuana9db86b2014-08-18 17:41:05 +0800577{
Kevin Wolfce15dc02016-11-08 11:10:14 +0100578 QuorumCo *co = opaque;
579 QuorumAIOCB *acb = co->acb;
580 BDRVQuorumState *s = acb->bs->opaque;
581 int i = co->idx;
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100582 QuorumChildRequest *sacb = &acb->qcrs[i];
Kevin Wolfce15dc02016-11-08 11:10:14 +0100583
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100584 sacb->bs = s->children[i]->bs;
Kevin Wolf6847da32016-11-10 17:22:07 +0100585 sacb->ret = bdrv_co_preadv(s->children[i], acb->offset, acb->bytes,
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100586 &acb->qcrs[i].qiov, 0);
587
588 if (sacb->ret == 0) {
589 acb->success_count++;
590 } else {
591 quorum_report_bad_acb(sacb, sacb->ret);
592 }
593
594 acb->count++;
595 assert(acb->count <= s->num_children);
596 assert(acb->success_count <= s->num_children);
597
598 /* Wake up the caller after the last read */
599 if (acb->count == s->num_children) {
600 qemu_coroutine_enter_if_inactive(acb->co);
601 }
Kevin Wolfce15dc02016-11-08 11:10:14 +0100602}
603
604static int read_quorum_children(QuorumAIOCB *acb)
605{
606 BDRVQuorumState *s = acb->bs->opaque;
Laurent Vivier4a4ff4c2018-03-23 15:32:02 +0100607 int i;
Liu Yuana9db86b2014-08-18 17:41:05 +0800608
Paolo Bonzini86ec2522016-10-05 18:35:26 +0200609 acb->children_read = s->num_children;
Liu Yuana9db86b2014-08-18 17:41:05 +0800610 for (i = 0; i < s->num_children; i++) {
Kevin Wolf0bd6e912015-06-16 11:29:22 +0200611 acb->qcrs[i].buf = qemu_blockalign(s->children[i]->bs, acb->qiov->size);
Liu Yuana9db86b2014-08-18 17:41:05 +0800612 qemu_iovec_init(&acb->qcrs[i].qiov, acb->qiov->niov);
613 qemu_iovec_clone(&acb->qcrs[i].qiov, acb->qiov, acb->qcrs[i].buf);
614 }
615
616 for (i = 0; i < s->num_children; i++) {
Kevin Wolfce15dc02016-11-08 11:10:14 +0100617 Coroutine *co;
618 QuorumCo data = {
619 .acb = acb,
620 .idx = i,
621 };
622
623 co = qemu_coroutine_create(read_quorum_children_entry, &data);
624 qemu_coroutine_enter(co);
Liu Yuana9db86b2014-08-18 17:41:05 +0800625 }
626
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100627 while (acb->count < s->num_children) {
628 qemu_coroutine_yield();
629 }
630
631 /* Do the vote on read */
632 quorum_vote(acb);
633 for (i = 0; i < s->num_children; i++) {
634 qemu_vfree(acb->qcrs[i].buf);
635 qemu_iovec_destroy(&acb->qcrs[i].qiov);
636 }
637
638 while (acb->rewrite_count) {
Kevin Wolfce15dc02016-11-08 11:10:14 +0100639 qemu_coroutine_yield();
640 }
641
Laurent Vivier4a4ff4c2018-03-23 15:32:02 +0100642 return acb->vote_ret;
Liu Yuana9db86b2014-08-18 17:41:05 +0800643}
644
Kevin Wolfce15dc02016-11-08 11:10:14 +0100645static int read_fifo_child(QuorumAIOCB *acb)
Liu Yuana9db86b2014-08-18 17:41:05 +0800646{
Kevin Wolfce15dc02016-11-08 11:10:14 +0100647 BDRVQuorumState *s = acb->bs->opaque;
Kevin Wolfa7e15902016-11-10 17:40:34 +0100648 int n, ret;
Liu Yuana9db86b2014-08-18 17:41:05 +0800649
Kevin Wolfa7e15902016-11-10 17:40:34 +0100650 /* We try to read the next child in FIFO order if we failed to read */
651 do {
652 n = acb->children_read++;
653 acb->qcrs[n].bs = s->children[n]->bs;
654 ret = bdrv_co_preadv(s->children[n], acb->offset, acb->bytes,
655 acb->qiov, 0);
656 if (ret < 0) {
657 quorum_report_bad_acb(&acb->qcrs[n], ret);
658 }
659 } while (ret < 0 && acb->children_read < s->num_children);
660
661 /* FIXME: rewrite failed children if acb->children_read > 1? */
Liu Yuana9db86b2014-08-18 17:41:05 +0800662
Kevin Wolfce15dc02016-11-08 11:10:14 +0100663 return ret;
Liu Yuana9db86b2014-08-18 17:41:05 +0800664}
665
Kevin Wolf6847da32016-11-10 17:22:07 +0100666static int quorum_co_preadv(BlockDriverState *bs, uint64_t offset,
667 uint64_t bytes, QEMUIOVector *qiov, int flags)
Benoît Canet7db69822014-02-21 22:21:14 +0100668{
669 BDRVQuorumState *s = bs->opaque;
Max Reitz1b1a9202018-04-21 15:29:25 +0200670 QuorumAIOCB *acb = quorum_aio_get(bs, qiov, offset, bytes, flags);
Kevin Wolfce15dc02016-11-08 11:10:14 +0100671 int ret;
672
Benoît Canet7db69822014-02-21 22:21:14 +0100673 acb->is_read = true;
Paolo Bonzini86ec2522016-10-05 18:35:26 +0200674 acb->children_read = 0;
Benoît Canet7db69822014-02-21 22:21:14 +0100675
Liu Yuana9db86b2014-08-18 17:41:05 +0800676 if (s->read_pattern == QUORUM_READ_PATTERN_QUORUM) {
Kevin Wolfce15dc02016-11-08 11:10:14 +0100677 ret = read_quorum_children(acb);
678 } else {
679 ret = read_fifo_child(acb);
Benoît Canet7db69822014-02-21 22:21:14 +0100680 }
Kevin Wolf0f319772016-11-10 14:24:27 +0100681 quorum_aio_finalize(acb);
682
Kevin Wolfce15dc02016-11-08 11:10:14 +0100683 return ret;
Benoît Canet7db69822014-02-21 22:21:14 +0100684}
685
Kevin Wolfce15dc02016-11-08 11:10:14 +0100686static void write_quorum_entry(void *opaque)
687{
688 QuorumCo *co = opaque;
689 QuorumAIOCB *acb = co->acb;
690 BDRVQuorumState *s = acb->bs->opaque;
691 int i = co->idx;
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100692 QuorumChildRequest *sacb = &acb->qcrs[i];
Kevin Wolfce15dc02016-11-08 11:10:14 +0100693
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100694 sacb->bs = s->children[i]->bs;
Alberto Garcia5cddb2e2020-11-13 17:52:32 +0100695 if (acb->flags & BDRV_REQ_ZERO_WRITE) {
696 sacb->ret = bdrv_co_pwrite_zeroes(s->children[i], acb->offset,
697 acb->bytes, acb->flags);
698 } else {
699 sacb->ret = bdrv_co_pwritev(s->children[i], acb->offset, acb->bytes,
700 acb->qiov, acb->flags);
701 }
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100702 if (sacb->ret == 0) {
703 acb->success_count++;
704 } else {
705 quorum_report_bad_acb(sacb, sacb->ret);
706 }
707 acb->count++;
708 assert(acb->count <= s->num_children);
709 assert(acb->success_count <= s->num_children);
710
711 /* Wake up the caller after the last write */
712 if (acb->count == s->num_children) {
713 qemu_coroutine_enter_if_inactive(acb->co);
714 }
Kevin Wolfce15dc02016-11-08 11:10:14 +0100715}
716
Kevin Wolf6847da32016-11-10 17:22:07 +0100717static int quorum_co_pwritev(BlockDriverState *bs, uint64_t offset,
718 uint64_t bytes, QEMUIOVector *qiov, int flags)
Benoît Canet13e79562014-02-21 22:21:12 +0100719{
720 BDRVQuorumState *s = bs->opaque;
Max Reitz1b1a9202018-04-21 15:29:25 +0200721 QuorumAIOCB *acb = quorum_aio_get(bs, qiov, offset, bytes, flags);
Kevin Wolfce15dc02016-11-08 11:10:14 +0100722 int i, ret;
Benoît Canet13e79562014-02-21 22:21:12 +0100723
724 for (i = 0; i < s->num_children; i++) {
Kevin Wolfce15dc02016-11-08 11:10:14 +0100725 Coroutine *co;
726 QuorumCo data = {
727 .acb = acb,
728 .idx = i,
729 };
730
731 co = qemu_coroutine_create(write_quorum_entry, &data);
732 qemu_coroutine_enter(co);
Benoît Canet13e79562014-02-21 22:21:12 +0100733 }
734
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100735 while (acb->count < s->num_children) {
Kevin Wolfce15dc02016-11-08 11:10:14 +0100736 qemu_coroutine_yield();
737 }
738
Kevin Wolf7cd9b392016-11-10 16:13:15 +0100739 quorum_has_too_much_io_failed(acb);
740
Kevin Wolfce15dc02016-11-08 11:10:14 +0100741 ret = acb->vote_ret;
Kevin Wolf0f319772016-11-10 14:24:27 +0100742 quorum_aio_finalize(acb);
Kevin Wolfce15dc02016-11-08 11:10:14 +0100743
744 return ret;
Benoît Canet13e79562014-02-21 22:21:12 +0100745}
746
Alberto Garcia5cddb2e2020-11-13 17:52:32 +0100747static int quorum_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
748 int bytes, BdrvRequestFlags flags)
749
750{
751 return quorum_co_pwritev(bs, offset, bytes, NULL,
752 flags | BDRV_REQ_ZERO_WRITE);
753}
754
Benoît Canetd55dee22014-02-21 22:21:16 +0100755static int64_t quorum_getlength(BlockDriverState *bs)
756{
757 BDRVQuorumState *s = bs->opaque;
758 int64_t result;
759 int i;
760
761 /* check that all file have the same length */
Kevin Wolf0bd6e912015-06-16 11:29:22 +0200762 result = bdrv_getlength(s->children[0]->bs);
Benoît Canetd55dee22014-02-21 22:21:16 +0100763 if (result < 0) {
764 return result;
765 }
766 for (i = 1; i < s->num_children; i++) {
Kevin Wolf0bd6e912015-06-16 11:29:22 +0200767 int64_t value = bdrv_getlength(s->children[i]->bs);
Benoît Canetd55dee22014-02-21 22:21:16 +0100768 if (value < 0) {
769 return value;
770 }
771 if (value != result) {
772 return -EIO;
773 }
774 }
775
776 return result;
777}
778
Benoît Canet1c508d12014-02-21 22:21:18 +0100779static coroutine_fn int quorum_co_flush(BlockDriverState *bs)
780{
781 BDRVQuorumState *s = bs->opaque;
782 QuorumVoteVersion *winner = NULL;
783 QuorumVotes error_votes;
784 QuorumVoteValue result_value;
785 int i;
786 int result = 0;
Changlong Xie924e8a22016-02-26 09:39:02 +0800787 int success_count = 0;
Benoît Canet1c508d12014-02-21 22:21:18 +0100788
789 QLIST_INIT(&error_votes.vote_list);
790 error_votes.compare = quorum_64bits_compare;
791
792 for (i = 0; i < s->num_children; i++) {
Kevin Wolf0bd6e912015-06-16 11:29:22 +0200793 result = bdrv_co_flush(s->children[i]->bs);
Changlong Xie924e8a22016-02-26 09:39:02 +0800794 if (result) {
Alberto Garcia795be062017-08-07 15:36:58 +0300795 quorum_report_bad(QUORUM_OP_TYPE_FLUSH, 0, 0,
Changlong Xie924e8a22016-02-26 09:39:02 +0800796 s->children[i]->bs->node_name, result);
797 result_value.l = result;
798 quorum_count_vote(&error_votes, &result_value, i);
799 } else {
800 success_count++;
801 }
Benoît Canet1c508d12014-02-21 22:21:18 +0100802 }
803
Changlong Xie924e8a22016-02-26 09:39:02 +0800804 if (success_count >= s->threshold) {
805 result = 0;
806 } else {
807 winner = quorum_get_vote_winner(&error_votes);
808 result = winner->value.l;
809 }
Benoît Canet1c508d12014-02-21 22:21:18 +0100810 quorum_free_vote_list(&error_votes);
811
812 return result;
813}
814
Max Reitza3ed7942020-02-18 11:34:43 +0100815static bool quorum_recurse_can_replace(BlockDriverState *bs,
816 BlockDriverState *to_replace)
817{
818 BDRVQuorumState *s = bs->opaque;
819 int i;
820
821 for (i = 0; i < s->num_children; i++) {
822 /*
823 * We have no idea whether our children show the same data as
824 * this node (@bs). It is actually highly likely that
825 * @to_replace does not, because replacing a broken child is
826 * one of the main use cases here.
827 *
828 * We do know that the new BDS will match @bs, so replacing
829 * any of our children by it will be safe. It cannot change
830 * the data this quorum node presents to its parents.
831 *
832 * However, replacing @to_replace by @bs in any of our
833 * children's chains may change visible data somewhere in
834 * there. We therefore cannot recurse down those chains with
835 * bdrv_recurse_can_replace().
836 * (More formally, bdrv_recurse_can_replace() requires that
837 * @to_replace will be replaced by something matching the @bs
838 * passed to it. We cannot guarantee that.)
839 *
840 * Thus, we can only check whether any of our immediate
841 * children matches @to_replace.
842 *
843 * (In the future, we might add a function to recurse down a
844 * chain that checks that nothing there cares about a change
845 * in data from the respective child in question. For
846 * example, most filters do not care when their child's data
847 * suddenly changes, as long as their parents do not care.)
848 */
849 if (s->children[i]->bs == to_replace) {
850 /*
851 * We now have to ensure that there is no other parent
852 * that cares about replacing this child by a node with
853 * potentially different data.
854 * We do so by checking whether there are any other parents
855 * at all, which is stricter than necessary, but also very
856 * simple. (We may decide to implement something more
857 * complex and permissive when there is an actual need for
858 * it.)
859 */
860 return QLIST_FIRST(&to_replace->parents) == s->children[i] &&
861 QLIST_NEXT(s->children[i], next_parent) == NULL;
862 }
863 }
864
865 return false;
866}
867
Benoît Canetc88a1de2014-02-21 22:21:20 +0100868static int quorum_valid_threshold(int threshold, int num_children, Error **errp)
869{
870
871 if (threshold < 1) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100872 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
Markus Armbruster6cc06672020-11-13 09:26:26 +0100873 "vote-threshold", "a value >= 1");
Benoît Canetc88a1de2014-02-21 22:21:20 +0100874 return -ERANGE;
875 }
876
877 if (threshold > num_children) {
878 error_setg(errp, "threshold may not exceed children count");
879 return -ERANGE;
880 }
881
882 return 0;
883}
884
885static QemuOptsList quorum_runtime_opts = {
886 .name = "quorum",
887 .head = QTAILQ_HEAD_INITIALIZER(quorum_runtime_opts.head),
888 .desc = {
889 {
890 .name = QUORUM_OPT_VOTE_THRESHOLD,
891 .type = QEMU_OPT_NUMBER,
892 .help = "The number of vote needed for reaching quorum",
893 },
894 {
895 .name = QUORUM_OPT_BLKVERIFY,
896 .type = QEMU_OPT_BOOL,
897 .help = "Trigger block verify mode if set",
898 },
Benoît Canetcf29a572014-06-11 15:24:10 +0200899 {
900 .name = QUORUM_OPT_REWRITE,
901 .type = QEMU_OPT_BOOL,
902 .help = "Rewrite corrupted block on read quorum",
903 },
Liu Yuana9db86b2014-08-18 17:41:05 +0800904 {
905 .name = QUORUM_OPT_READ_PATTERN,
906 .type = QEMU_OPT_STRING,
907 .help = "Allowed pattern: quorum, fifo. Quorum is default",
908 },
Benoît Canetc88a1de2014-02-21 22:21:20 +0100909 { /* end of list */ }
910 },
911};
912
Alberto Garcia5cddb2e2020-11-13 17:52:32 +0100913static void quorum_refresh_flags(BlockDriverState *bs)
914{
915 BDRVQuorumState *s = bs->opaque;
916 int i;
917
918 bs->supported_zero_flags =
919 BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
920
921 for (i = 0; i < s->num_children; i++) {
922 bs->supported_zero_flags &= s->children[i]->bs->supported_zero_flags;
923 }
924
925 bs->supported_zero_flags |= BDRV_REQ_WRITE_UNCHANGED;
926}
927
Benoît Canetc88a1de2014-02-21 22:21:20 +0100928static int quorum_open(BlockDriverState *bs, QDict *options, int flags,
929 Error **errp)
930{
931 BDRVQuorumState *s = bs->opaque;
Fam Zheng8df3abf2014-08-28 13:56:12 +0800932 QemuOpts *opts = NULL;
Marc-André Lureau8d5fb192017-08-24 10:46:03 +0200933 const char *pattern_str;
Benoît Canetc88a1de2014-02-21 22:21:20 +0100934 bool *opened;
Benoît Canetc88a1de2014-02-21 22:21:20 +0100935 int i;
936 int ret = 0;
937
938 qdict_flatten(options);
Benoît Canetc88a1de2014-02-21 22:21:20 +0100939
Kevin Wolfea6828d2015-01-21 18:49:28 +0100940 /* count how many different children are present */
941 s->num_children = qdict_array_entries(options, "children.");
942 if (s->num_children < 0) {
Markus Armbrusterdcfe4802020-07-07 18:06:01 +0200943 error_setg(errp, "Option children is not a valid array");
Max Reitz8a87f3d2014-02-21 22:30:37 +0100944 ret = -EINVAL;
945 goto exit;
946 }
Wen Congyang98292c62016-05-10 15:36:38 +0800947 if (s->num_children < 1) {
Markus Armbrusterdcfe4802020-07-07 18:06:01 +0200948 error_setg(errp, "Number of provided children must be 1 or more");
Benoît Canetc88a1de2014-02-21 22:21:20 +0100949 ret = -EINVAL;
950 goto exit;
951 }
952
953 opts = qemu_opts_create(&quorum_runtime_opts, NULL, 0, &error_abort);
Markus Armbrustera5f9b9d2020-07-07 18:06:05 +0200954 if (!qemu_opts_absorb_qdict(opts, options, errp)) {
Benoît Canetc88a1de2014-02-21 22:21:20 +0100955 ret = -EINVAL;
956 goto exit;
957 }
958
959 s->threshold = qemu_opt_get_number(opts, QUORUM_OPT_VOTE_THRESHOLD, 0);
Wen Congyang834cb2a2015-07-03 14:45:06 +0800960 /* and validate it against s->num_children */
Markus Armbrusterdcfe4802020-07-07 18:06:01 +0200961 ret = quorum_valid_threshold(s->threshold, s->num_children, errp);
Wen Congyang834cb2a2015-07-03 14:45:06 +0800962 if (ret < 0) {
963 goto exit;
964 }
965
Marc-André Lureau8d5fb192017-08-24 10:46:03 +0200966 pattern_str = qemu_opt_get(opts, QUORUM_OPT_READ_PATTERN);
967 if (!pattern_str) {
968 ret = QUORUM_READ_PATTERN_QUORUM;
969 } else {
Marc-André Lureauf7abe0e2017-08-24 10:46:10 +0200970 ret = qapi_enum_parse(&QuorumReadPattern_lookup, pattern_str,
Marc-André Lureau8d5fb192017-08-24 10:46:03 +0200971 -EINVAL, NULL);
972 }
Benoît Canetc88a1de2014-02-21 22:21:20 +0100973 if (ret < 0) {
Markus Armbrusterdcfe4802020-07-07 18:06:01 +0200974 error_setg(errp, "Please set read-pattern as fifo or quorum");
Benoît Canetc88a1de2014-02-21 22:21:20 +0100975 goto exit;
976 }
Liu Yuana9db86b2014-08-18 17:41:05 +0800977 s->read_pattern = ret;
Benoît Canetc88a1de2014-02-21 22:21:20 +0100978
Liu Yuana9db86b2014-08-18 17:41:05 +0800979 if (s->read_pattern == QUORUM_READ_PATTERN_QUORUM) {
Alberto Garcia83aedca2018-10-17 17:33:50 +0300980 s->is_blkverify = qemu_opt_get_bool(opts, QUORUM_OPT_BLKVERIFY, false);
981 if (s->is_blkverify && (s->num_children != 2 || s->threshold != 2)) {
Markus Armbrusterdcfe4802020-07-07 18:06:01 +0200982 error_setg(errp, "blkverify=on can only be set if there are "
Alberto Garcia83aedca2018-10-17 17:33:50 +0300983 "exactly two files and vote-threshold is 2");
984 ret = -EINVAL;
985 goto exit;
Liu Yuana9db86b2014-08-18 17:41:05 +0800986 }
987
988 s->rewrite_corrupted = qemu_opt_get_bool(opts, QUORUM_OPT_REWRITE,
989 false);
990 if (s->rewrite_corrupted && s->is_blkverify) {
Markus Armbrusterdcfe4802020-07-07 18:06:01 +0200991 error_setg(errp,
Liu Yuana9db86b2014-08-18 17:41:05 +0800992 "rewrite-corrupted=on cannot be used with blkverify=on");
993 ret = -EINVAL;
994 goto exit;
995 }
Benoît Canetcf29a572014-06-11 15:24:10 +0200996 }
997
Kevin Wolf0bd6e912015-06-16 11:29:22 +0200998 /* allocate the children array */
999 s->children = g_new0(BdrvChild *, s->num_children);
Benoît Canetc88a1de2014-02-21 22:21:20 +01001000 opened = g_new0(bool, s->num_children);
1001
Kevin Wolfea6828d2015-01-21 18:49:28 +01001002 for (i = 0; i < s->num_children; i++) {
Lukas Straub5eb9a3c2020-08-04 12:46:42 +02001003 char indexstr[INDEXSTR_LEN];
1004 ret = snprintf(indexstr, INDEXSTR_LEN, "children.%d", i);
1005 assert(ret < INDEXSTR_LEN);
Max Reitz8a87f3d2014-02-21 22:30:37 +01001006
Kevin Wolf0bd6e912015-06-16 11:29:22 +02001007 s->children[i] = bdrv_open_child(NULL, options, indexstr, bs,
Max Reitz36ee58d2020-05-13 13:05:31 +02001008 &child_of_bds, BDRV_CHILD_DATA, false,
Vladimir Sementsov-Ogievskiybc520242021-02-02 15:49:45 +03001009 errp);
1010 if (!s->children[i]) {
Kevin Wolf0bd6e912015-06-16 11:29:22 +02001011 ret = -EINVAL;
Max Reitz8a87f3d2014-02-21 22:30:37 +01001012 goto close_exit;
Benoît Canetc88a1de2014-02-21 22:21:20 +01001013 }
Kevin Wolfea6828d2015-01-21 18:49:28 +01001014
Max Reitz8a87f3d2014-02-21 22:30:37 +01001015 opened[i] = true;
Benoît Canetc88a1de2014-02-21 22:21:20 +01001016 }
Wen Congyang98292c62016-05-10 15:36:38 +08001017 s->next_child_index = s->num_children;
Benoît Canetc88a1de2014-02-21 22:21:20 +01001018
Max Reitz1b1a9202018-04-21 15:29:25 +02001019 bs->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED;
Alberto Garcia5cddb2e2020-11-13 17:52:32 +01001020 quorum_refresh_flags(bs);
Max Reitz1b1a9202018-04-21 15:29:25 +02001021
Benoît Canetc88a1de2014-02-21 22:21:20 +01001022 g_free(opened);
1023 goto exit;
1024
1025close_exit:
1026 /* cleanup on error */
1027 for (i = 0; i < s->num_children; i++) {
1028 if (!opened[i]) {
1029 continue;
1030 }
Kevin Wolf0bd6e912015-06-16 11:29:22 +02001031 bdrv_unref_child(bs, s->children[i]);
Benoît Canetc88a1de2014-02-21 22:21:20 +01001032 }
Kevin Wolf0bd6e912015-06-16 11:29:22 +02001033 g_free(s->children);
Benoît Canetc88a1de2014-02-21 22:21:20 +01001034 g_free(opened);
1035exit:
Fam Zheng8df3abf2014-08-28 13:56:12 +08001036 qemu_opts_del(opts);
Benoît Canetc88a1de2014-02-21 22:21:20 +01001037 return ret;
1038}
1039
1040static void quorum_close(BlockDriverState *bs)
1041{
1042 BDRVQuorumState *s = bs->opaque;
1043 int i;
1044
1045 for (i = 0; i < s->num_children; i++) {
Kevin Wolf0bd6e912015-06-16 11:29:22 +02001046 bdrv_unref_child(bs, s->children[i]);
Benoît Canetc88a1de2014-02-21 22:21:20 +01001047 }
1048
Kevin Wolf0bd6e912015-06-16 11:29:22 +02001049 g_free(s->children);
Benoît Canetc88a1de2014-02-21 22:21:20 +01001050}
1051
Wen Congyang98292c62016-05-10 15:36:38 +08001052static void quorum_add_child(BlockDriverState *bs, BlockDriverState *child_bs,
1053 Error **errp)
1054{
1055 BDRVQuorumState *s = bs->opaque;
1056 BdrvChild *child;
Lukas Straub5eb9a3c2020-08-04 12:46:42 +02001057 char indexstr[INDEXSTR_LEN];
Wen Congyang98292c62016-05-10 15:36:38 +08001058 int ret;
1059
Alberto Garcia808b27d2018-10-18 11:59:03 +03001060 if (s->is_blkverify) {
1061 error_setg(errp, "Cannot add a child to a quorum in blkverify mode");
1062 return;
1063 }
1064
Wen Congyang98292c62016-05-10 15:36:38 +08001065 assert(s->num_children <= INT_MAX / sizeof(BdrvChild *));
1066 if (s->num_children == INT_MAX / sizeof(BdrvChild *) ||
1067 s->next_child_index == UINT_MAX) {
1068 error_setg(errp, "Too many children");
1069 return;
1070 }
1071
Lukas Straub5eb9a3c2020-08-04 12:46:42 +02001072 ret = snprintf(indexstr, INDEXSTR_LEN, "children.%u", s->next_child_index);
1073 if (ret < 0 || ret >= INDEXSTR_LEN) {
Wen Congyang98292c62016-05-10 15:36:38 +08001074 error_setg(errp, "cannot generate child name");
1075 return;
1076 }
1077 s->next_child_index++;
1078
1079 bdrv_drained_begin(bs);
1080
1081 /* We can safely add the child now */
1082 bdrv_ref(child_bs);
Kevin Wolf8b2ff522016-12-20 22:21:17 +01001083
Max Reitz36ee58d2020-05-13 13:05:31 +02001084 child = bdrv_attach_child(bs, child_bs, indexstr, &child_of_bds,
1085 BDRV_CHILD_DATA, errp);
Kevin Wolf8b2ff522016-12-20 22:21:17 +01001086 if (child == NULL) {
1087 s->next_child_index--;
Kevin Wolf8b2ff522016-12-20 22:21:17 +01001088 goto out;
1089 }
Wen Congyang98292c62016-05-10 15:36:38 +08001090 s->children = g_renew(BdrvChild *, s->children, s->num_children + 1);
1091 s->children[s->num_children++] = child;
Alberto Garcia5cddb2e2020-11-13 17:52:32 +01001092 quorum_refresh_flags(bs);
Wen Congyang98292c62016-05-10 15:36:38 +08001093
Kevin Wolf8b2ff522016-12-20 22:21:17 +01001094out:
Wen Congyang98292c62016-05-10 15:36:38 +08001095 bdrv_drained_end(bs);
1096}
1097
1098static void quorum_del_child(BlockDriverState *bs, BdrvChild *child,
1099 Error **errp)
1100{
1101 BDRVQuorumState *s = bs->opaque;
Lukas Straub5eb9a3c2020-08-04 12:46:42 +02001102 char indexstr[INDEXSTR_LEN];
Wen Congyang98292c62016-05-10 15:36:38 +08001103 int i;
1104
1105 for (i = 0; i < s->num_children; i++) {
1106 if (s->children[i] == child) {
1107 break;
1108 }
1109 }
1110
1111 /* we have checked it in bdrv_del_child() */
1112 assert(i < s->num_children);
1113
1114 if (s->num_children <= s->threshold) {
1115 error_setg(errp,
1116 "The number of children cannot be lower than the vote threshold %d",
1117 s->threshold);
1118 return;
1119 }
1120
Alberto Garcia808b27d2018-10-18 11:59:03 +03001121 /* We know now that num_children > threshold, so blkverify must be false */
1122 assert(!s->is_blkverify);
1123
Lukas Straub5eb9a3c2020-08-04 12:46:42 +02001124 snprintf(indexstr, INDEXSTR_LEN, "children.%u", s->next_child_index - 1);
1125 if (!strncmp(child->name, indexstr, INDEXSTR_LEN)) {
1126 s->next_child_index--;
1127 }
1128
Wen Congyang98292c62016-05-10 15:36:38 +08001129 bdrv_drained_begin(bs);
1130
1131 /* We can safely remove this child now */
1132 memmove(&s->children[i], &s->children[i + 1],
1133 (s->num_children - i - 1) * sizeof(BdrvChild *));
1134 s->children = g_renew(BdrvChild *, s->children, --s->num_children);
1135 bdrv_unref_child(bs, child);
1136
Alberto Garcia5cddb2e2020-11-13 17:52:32 +01001137 quorum_refresh_flags(bs);
Wen Congyang98292c62016-05-10 15:36:38 +08001138 bdrv_drained_end(bs);
1139}
1140
Max Reitzabc521a2019-02-01 20:29:26 +01001141static void quorum_gather_child_options(BlockDriverState *bs, QDict *target,
1142 bool backing_overridden)
1143{
1144 BDRVQuorumState *s = bs->opaque;
1145 QList *children_list;
1146 int i;
1147
1148 /*
1149 * The generic implementation for gathering child options in
1150 * bdrv_refresh_filename() would use the names of the children
1151 * as specified for bdrv_open_child() or bdrv_attach_child(),
1152 * which is "children.%u" with %u being a value
1153 * (s->next_child_index) that is incremented each time a new child
1154 * is added (and never decremented). Since children can be
1155 * deleted at runtime, there may be gaps in that enumeration.
1156 * When creating a new quorum BDS and specifying the children for
1157 * it through runtime options, the enumeration used there may not
1158 * have any gaps, though.
1159 *
1160 * Therefore, we have to create a new gap-less enumeration here
1161 * (which we can achieve by simply putting all of the children's
1162 * full_open_options into a QList).
1163 *
1164 * XXX: Note that there are issues with the current child option
1165 * structure quorum uses (such as the fact that children do
1166 * not really have unique permanent names). Therefore, this
1167 * is going to have to change in the future and ideally we
1168 * want quorum to be covered by the generic implementation.
1169 */
1170
1171 children_list = qlist_new();
1172 qdict_put(target, "children", children_list);
1173
1174 for (i = 0; i < s->num_children; i++) {
1175 qlist_append(children_list,
1176 qobject_ref(s->children[i]->bs->full_open_options));
1177 }
1178}
1179
Max Reitzf3037bd2019-02-01 20:29:20 +01001180static char *quorum_dirname(BlockDriverState *bs, Error **errp)
1181{
1182 /* In general, there are multiple BDSs with different dirnames below this
1183 * one; so there is no unique dirname we could return (unless all are equal
1184 * by chance, or there is only one). Therefore, to be consistent, just
1185 * always return NULL. */
1186 error_setg(errp, "Cannot generate a base directory for quorum nodes");
1187 return NULL;
1188}
1189
Max Reitz37a37912020-02-18 11:34:40 +01001190static void quorum_child_perm(BlockDriverState *bs, BdrvChild *c,
Max Reitzbf8e9252020-05-13 13:05:16 +02001191 BdrvChildRole role,
Max Reitz37a37912020-02-18 11:34:40 +01001192 BlockReopenQueue *reopen_queue,
1193 uint64_t perm, uint64_t shared,
1194 uint64_t *nperm, uint64_t *nshared)
1195{
Max Reitz9ca5b0e2020-11-13 22:17:16 +01001196 BDRVQuorumState *s = bs->opaque;
1197
Max Reitz37a37912020-02-18 11:34:40 +01001198 *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
Max Reitz9ca5b0e2020-11-13 22:17:16 +01001199 if (s->rewrite_corrupted) {
1200 *nperm |= BLK_PERM_WRITE;
1201 }
Max Reitz37a37912020-02-18 11:34:40 +01001202
1203 /*
1204 * We cannot share RESIZE or WRITE, as this would make the
1205 * children differ from each other.
1206 */
1207 *nshared = (shared & (BLK_PERM_CONSISTENT_READ |
1208 BLK_PERM_WRITE_UNCHANGED))
1209 | DEFAULT_PERM_UNCHANGED;
1210}
1211
Alberto Garciaef9bba12020-11-13 17:52:31 +01001212/*
1213 * Each one of the children can report different status flags even
1214 * when they contain the same data, so what this function does is
1215 * return BDRV_BLOCK_ZERO if *all* children agree that a certain
1216 * region contains zeroes, and BDRV_BLOCK_DATA otherwise.
1217 */
1218static int coroutine_fn quorum_co_block_status(BlockDriverState *bs,
1219 bool want_zero,
1220 int64_t offset, int64_t count,
1221 int64_t *pnum, int64_t *map,
1222 BlockDriverState **file)
1223{
1224 BDRVQuorumState *s = bs->opaque;
1225 int i, ret;
1226 int64_t pnum_zero = count;
1227 int64_t pnum_data = 0;
1228
1229 for (i = 0; i < s->num_children; i++) {
1230 int64_t bytes;
1231 ret = bdrv_co_common_block_status_above(s->children[i]->bs, NULL, false,
1232 want_zero, offset, count,
1233 &bytes, NULL, NULL, NULL);
1234 if (ret < 0) {
1235 quorum_report_bad(QUORUM_OP_TYPE_READ, offset, count,
1236 s->children[i]->bs->node_name, ret);
1237 pnum_data = count;
1238 break;
1239 }
1240 /*
1241 * Even if all children agree about whether there are zeroes
1242 * or not at @offset they might disagree on the size, so use
1243 * the smallest when reporting BDRV_BLOCK_ZERO and the largest
1244 * when reporting BDRV_BLOCK_DATA.
1245 */
1246 if (ret & BDRV_BLOCK_ZERO) {
1247 pnum_zero = MIN(pnum_zero, bytes);
1248 } else {
1249 pnum_data = MAX(pnum_data, bytes);
1250 }
1251 }
1252
1253 if (pnum_data) {
1254 *pnum = pnum_data;
1255 return BDRV_BLOCK_DATA;
1256 } else {
1257 *pnum = pnum_zero;
1258 return BDRV_BLOCK_ZERO;
1259 }
1260}
1261
Max Reitz26542672019-02-01 20:29:25 +01001262static const char *const quorum_strong_runtime_opts[] = {
1263 QUORUM_OPT_VOTE_THRESHOLD,
1264 QUORUM_OPT_BLKVERIFY,
1265 QUORUM_OPT_REWRITE,
1266 QUORUM_OPT_READ_PATTERN,
1267
1268 NULL
1269};
1270
Benoît Canetcadebd72014-02-21 22:21:11 +01001271static BlockDriver bdrv_quorum = {
Stefan Hajnoczie3625d32014-05-08 16:34:46 +02001272 .format_name = "quorum",
Benoît Canetcadebd72014-02-21 22:21:11 +01001273
Stefan Hajnoczie3625d32014-05-08 16:34:46 +02001274 .instance_size = sizeof(BDRVQuorumState),
Benoît Canet13e79562014-02-21 22:21:12 +01001275
Fabiano Rosas65d2c3e2018-03-12 19:07:50 -03001276 .bdrv_open = quorum_open,
Stefan Hajnoczie3625d32014-05-08 16:34:46 +02001277 .bdrv_close = quorum_close,
Max Reitzabc521a2019-02-01 20:29:26 +01001278 .bdrv_gather_child_options = quorum_gather_child_options,
Max Reitzf3037bd2019-02-01 20:29:20 +01001279 .bdrv_dirname = quorum_dirname,
Alberto Garciaef9bba12020-11-13 17:52:31 +01001280 .bdrv_co_block_status = quorum_co_block_status,
Benoît Canetc88a1de2014-02-21 22:21:20 +01001281
Lukas Straub5529b022021-05-18 13:42:14 +02001282 .bdrv_co_flush = quorum_co_flush,
Benoît Canet1c508d12014-02-21 22:21:18 +01001283
Stefan Hajnoczie3625d32014-05-08 16:34:46 +02001284 .bdrv_getlength = quorum_getlength,
Benoît Canetd55dee22014-02-21 22:21:16 +01001285
Kevin Wolf6847da32016-11-10 17:22:07 +01001286 .bdrv_co_preadv = quorum_co_preadv,
1287 .bdrv_co_pwritev = quorum_co_pwritev,
Alberto Garcia5cddb2e2020-11-13 17:52:32 +01001288 .bdrv_co_pwrite_zeroes = quorum_co_pwrite_zeroes,
Benoît Canet98a7a382014-02-21 22:21:19 +01001289
Wen Congyang98292c62016-05-10 15:36:38 +08001290 .bdrv_add_child = quorum_add_child,
1291 .bdrv_del_child = quorum_del_child,
1292
Max Reitz37a37912020-02-18 11:34:40 +01001293 .bdrv_child_perm = quorum_child_perm,
Kevin Wolfd7010df2016-12-15 12:28:58 +01001294
Max Reitza3ed7942020-02-18 11:34:43 +01001295 .bdrv_recurse_can_replace = quorum_recurse_can_replace,
Max Reitz26542672019-02-01 20:29:25 +01001296
1297 .strong_runtime_opts = quorum_strong_runtime_opts,
Benoît Canetcadebd72014-02-21 22:21:11 +01001298};
1299
1300static void bdrv_quorum_init(void)
1301{
Sascha Silbee94867e2015-08-04 16:48:25 +02001302 if (!qcrypto_hash_supports(QCRYPTO_HASH_ALG_SHA256)) {
1303 /* SHA256 hash support is required for quorum device */
1304 return;
1305 }
Benoît Canetcadebd72014-02-21 22:21:11 +01001306 bdrv_register(&bdrv_quorum);
1307}
1308
1309block_init(bdrv_quorum_init);