From patchwork Tue Jan 28 16:52:53 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Beno=C3=AEt_Canet?= X-Patchwork-Id: 314783 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id ECF2D2C0307 for ; Wed, 29 Jan 2014 03:58:31 +1100 (EST) Received: from localhost ([::1]:38287 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1W8BzZ-0003bZ-Tl for incoming@patchwork.ozlabs.org; Tue, 28 Jan 2014 11:58:29 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:35137) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1W8BuR-0004pV-GV for qemu-devel@nongnu.org; Tue, 28 Jan 2014 11:53:16 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1W8BuI-000142-TY for qemu-devel@nongnu.org; Tue, 28 Jan 2014 11:53:11 -0500 Received: from paradis.irqsave.net ([62.212.105.220]:48547) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1W8BuH-00012z-BG for qemu-devel@nongnu.org; Tue, 28 Jan 2014 11:53:02 -0500 Received: from localhost.localdomain (laure.irqsave.net [192.168.77.2]) by paradis.irqsave.net (Postfix) with ESMTP id 9EBC25CEE3; Tue, 28 Jan 2014 18:23:33 +0100 (CET) From: =?UTF-8?q?Beno=C3=AEt=20Canet?= To: qemu-devel@nongnu.org Date: Tue, 28 Jan 2014 17:52:53 +0100 Message-Id: <1390927974-31325-13-git-send-email-benoit.canet@irqsave.net> X-Mailer: git-send-email 1.8.3.2 In-Reply-To: <1390927974-31325-1-git-send-email-benoit.canet@irqsave.net> References: <1390927974-31325-1-git-send-email-benoit.canet@irqsave.net> MIME-Version: 1.0 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 62.212.105.220 Cc: kwolf@redhat.com, =?UTF-8?q?Beno=C3=AEt=20Canet?= , stefanha@redhat.com, mreitz@redhat.com Subject: [Qemu-devel] [PATCH V10 12/13] quorum: Add quorum_open() and quorum_close(). X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org From: Benoît Canet Example of command line: -drive if=virtio,file.driver=quorum,\ file.children.0.file.filename=1.raw,\ file.children.0.node-name=1.raw,\ file.children.0.driver=raw,\ file.children.1.file.filename=2.raw,\ file.children.1.node-name=2.raw,\ file.children.1.driver=raw,\ file.children.2.file.filename=3.raw,\ file.children.2.node-name=3.raw,\ file.children.2.driver=raw,\ file.vote_threshold=2 file.blkverify=on with file.vote_threshold=2 and two files can be passed to emulated blkverify. Signed-off-by: Benoit Canet --- block/quorum.c | 308 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ qapi-schema.json | 21 +++- 2 files changed, 328 insertions(+), 1 deletion(-) diff --git a/block/quorum.c b/block/quorum.c index e7b2090..0c0d630 100644 --- a/block/quorum.c +++ b/block/quorum.c @@ -17,8 +17,12 @@ #include #include "block/block_int.h" #include "qapi/qmp/qjson.h" +#include "qapi/qmp/types.h" +#include "qemu-common.h" #define HASH_LENGTH 32 +#define KEY_PREFIX "children." +#define KEY_FILENAME_SUFFIX ".file.filename" /* This union holds a vote hash value */ typedef union QuorumVoteValue { @@ -702,12 +706,316 @@ static bool quorum_recurse_is_first_non_filter(BlockDriverState *bs, return false; } +static int quorum_match_key(const char *key, + char **key_prefix) +{ + const char *start; + char *next; + unsigned long long idx; + int ret; + + *key_prefix = NULL; + + /* the following code is a translation of the following pseudo code: + * match = key.match('(^children\.(\d+)\.)$suffix) + * if not match: + * return -1; + * key_prefix = match.outer_match() + * idx = match.inner_match() + * + * note: we also match the .file suffix to avoid futher checkings + */ + + /* this key is not a child */ + if (strncmp(key, KEY_PREFIX, strlen(KEY_PREFIX))) { + return -1; + } + + /* take first char after prefix */ + start = key + strlen(KEY_PREFIX); + + /* if the string end here -> scan fail */ + if (start[0] == '\0') { + return -1; + } + + /* try to retrieve the index */ + ret = parse_uint(start, &idx, &next, 10); + + /* no int found -> scan fail */ + if (ret < 0) { + return -1; + } + + /* we are taking a reference via QMP */ + if (next - key == strlen(key)) { + *key_prefix = g_strdup(key); + return idx; + } + + /* match the suffix to avoid matching the same idx + * multiple times and be required to do more checks later + */ + if (strncmp(next, KEY_FILENAME_SUFFIX, strlen(KEY_FILENAME_SUFFIX))) { + return -1; + } + + /* do not include '.' */ + int len = next - key; + *key_prefix = g_strndup(key, len); + + return idx; +} + +static QDict *quorum_get_children_idx(const QDict *options) +{ + const QDictEntry *ent; + QDict *result; + char *key_prefix; + int idx; + + result = qdict_new(); + + for (ent = qdict_first(options); ent; ent = qdict_next(options, ent)) { + const char *key = qdict_entry_key(ent); + idx = quorum_match_key(key, + &key_prefix); + + /* if the result zero or positive we got a key */ + if (idx < 0) { + continue; + } + + qdict_put(result, key_prefix, qint_from_int(idx)); + } + + return result; +} + +static int quorum_fill_validation_array(bool *array, + const QDict *dict, + int total, + Error **errp) +{ + const QDictEntry *ent; + + /* fill the checking array with children indexes */ + for (ent = qdict_first(dict); ent; ent = qdict_next(dict, ent)) { + const char *key = qdict_entry_key(ent); + int idx = qdict_get_int(dict, key); + + if (idx < 0 || idx >= total) { + error_setg(errp, + "Children index must be between 0 and children count -1"); + return -ERANGE; + } + + array[idx] = true; + } + + return 0; +} + +static int quorum_valid_indexes(const bool *array, int total, Error **errp) +{ + int i; + + for (i = 0; i < total; i++) { + if (array[i] == true) { + continue; + } + + error_setg(errp, + "All child indexes between 0 and children count -1 must be " + " used"); + return -ERANGE; + } + + return 0; +} + +static int quorum_valid_children_indexes(const QDict *dict, + int total, + Error **errp) +{ + bool *array; + int ret = 0;; + + /* allocate indexes checking array and put false in it */ + array = g_new0(bool, total); + + ret = quorum_fill_validation_array(array, dict, total, errp); + if (ret < 0) { + goto free_exit; + } + + ret = quorum_valid_indexes(array, total, errp); +free_exit: + g_free(array); + return ret; +} + +static int quorum_valid_threshold(int threshold, + int total, + Error **errp) +{ + + if (threshold < 1) { + error_set(errp, QERR_INVALID_PARAMETER_VALUE, + "vote-threshold", "value >= 1"); + return -ERANGE; + } + + if (threshold > total) { + error_setg(errp, "threshold <= children count must be true"); + return -ERANGE; + } + + return 0; +} + +static int quorum_open(BlockDriverState *bs, + QDict *options, + int flags, + Error **errp) +{ + BDRVQuorumState *s = bs->opaque; + Error *local_err = NULL; + const QDictEntry *ent; + QDict *idx_dict; + bool *opened; + const char *value; + char *next; + int i; + int ret = 0; + + /* get a dict of children indexes for validation */ + idx_dict = quorum_get_children_idx(options); + + /* count how many different children indexes are present and validate */ + s->total = qdict_size(idx_dict); + if (s->total < 2) { + error_setg(&local_err, + "Number of provided children must be greater than 1"); + ret = -EINVAL; + goto exit; + } + + /* validate that the set of index is coherent */ + ret = quorum_valid_children_indexes(idx_dict, s->total, &local_err); + if (ret < 0) { + goto exit; + } + + ret = qdict_get_try_int(options, "vote-threshold", -1); + /* from QMP */ + if (ret != -1) { + qdict_del(options, "vote-threshold"); + s->threshold = ret; + /* from command line */ + } else { + /* retrieve the threshold option from the command line */ + value = qdict_get_try_str(options, "vote_threshold"); + if (!value) { + error_setg(&local_err, + "vote_threshold must be provided"); + ret = -EINVAL; + goto exit; + } + qdict_del(options, "vote_threshold"); + + ret = parse_uint(value, (unsigned long long *) &s->threshold, &next, 10); + + /* no int found -> scan fail */ + if (ret < 0) { + error_setg(&local_err, + "invalid voter_threshold specified"); + ret = -EINVAL; + goto exit; + } + } + + /* and validate it againts s->total */ + ret = quorum_valid_threshold(s->threshold, s->total, &local_err); + if (ret < 0) { + goto exit; + } + + /* is the driver in blkverify mode */ + value = qdict_get_try_str(options, "blkverify"); + if (value && !strcmp(value, "on") && + s->total == 2 && s->threshold == 2) { + s->is_blkverify = true; + } + qdict_del(options, "blkverify"); + + /* allocate the children BlockDriverState array */ + s->bs = g_new0(BlockDriverState *, s->total); + opened = g_new0(bool, s->total); + + /* open children bs */ + for (ent = qdict_first(idx_dict); + ent; ent = qdict_next(idx_dict, ent)) { + const char *key = qdict_entry_key(ent); + int idx = qdict_get_int(idx_dict, key); + ret = bdrv_open_image(&s->bs[idx], + NULL, + options, + key, + flags, + false, + &local_err); + if (ret < 0) { + goto close_exit; + } + opened[idx] = true; + } + + g_free(opened); + goto exit; + +close_exit: + /* cleanup on error */ + for (i = 0; i < s->total; i++) { + if (!opened[i]) { + continue; + } + bdrv_close(s->bs[i]); + } + g_free(s->bs); + g_free(opened); +exit: + /* propagate error */ + if (error_is_set(&local_err)) { + error_propagate(errp, local_err); + } + return ret; +} + +static void quorum_close(BlockDriverState *bs) +{ + BDRVQuorumState *s = bs->opaque; + int i; + + for (i = 0; i < s->total; i++) { + /* Ensure writes reach stable storage */ + bdrv_flush(s->bs[i]); + /* close manually because we'll free s->bs */ + bdrv_close(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, + .bdrv_co_flush_to_disk = quorum_co_flush, .bdrv_getlength = quorum_getlength, diff --git a/qapi-schema.json b/qapi-schema.json index 05ced9d..903a3a0 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -4352,6 +4352,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. @@ -4389,7 +4407,8 @@ 'vdi': 'BlockdevOptionsGenericFormat', 'vhdx': 'BlockdevOptionsGenericFormat', 'vmdk': 'BlockdevOptionsGenericCOWFormat', - 'vpc': 'BlockdevOptionsGenericFormat' + 'vpc': 'BlockdevOptionsGenericFormat', + 'quorum': 'BlockdevOptionsQuorum' } } ##