The following changes since commit bfec359afba088aaacc7d316f43302f28c6e642a:

Merge remote-tracking branch 'remotes/armbru/tags/pull-qdev-2017-04-21' into staging (2017-04-21 11:42:03 +0100)

are available in the git repository at:

git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request

for you to fetch changes up to 1507631e438930bc07f776f303af127a9cdb4d41:

qemu-iotests: _cleanup_qemu must be called on exit (2017-04-21 08:32:44 -0400)

Block patches for 2.10

----------------------------------------------------------------

Ashish Mittal (2):

block/vxhs.c: Add support for a new block device type called "vxhs"

block/vxhs.c: Add qemu-iotests for new block device type "vxhs"

Jeff Cody (10):

qemu-iotests: exclude vxhs from image creation via protocol

block: add bdrv_set_read_only() helper function

block: do not set BDS read_only if copy_on_read enabled

block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only

block: code movement

block: introduce bdrv_can_set_read_only()

block: use bdrv_can_set_read_only() during reopen

block/rbd - update variable names to more apt names

block/rbd: Add support for reopen()

qemu-iotests: _cleanup_qemu must be called on exit

block.c | 56 +++-

block/Makefile.objs | 2 +

block/bochs.c | 5 +-

block/cloop.c | 5 +-

block/dmg.c | 6 +-

block/rbd.c | 65 +++--

block/trace-events | 17 ++

block/vvfat.c | 19 +-

block/vxhs.c | 575 +++++++++++++++++++++++++++++++++++++++

configure | 39 +++

include/block/block.h | 2 +

qapi/block-core.json | 23 +-

tests/qemu-iotests/017 | 1 +

tests/qemu-iotests/020 | 1 +

tests/qemu-iotests/028 | 1 +

tests/qemu-iotests/029 | 1 +

tests/qemu-iotests/073 | 1 +

tests/qemu-iotests/094 | 11 +-

tests/qemu-iotests/102 | 5 +-

tests/qemu-iotests/109 | 1 +

tests/qemu-iotests/114 | 1 +

tests/qemu-iotests/117 | 1 +

tests/qemu-iotests/130 | 2 +

tests/qemu-iotests/134 | 1 +

tests/qemu-iotests/140 | 1 +

tests/qemu-iotests/141 | 1 +

tests/qemu-iotests/143 | 1 +

tests/qemu-iotests/156 | 2 +

tests/qemu-iotests/158 | 1 +

tests/qemu-iotests/common | 6 +

tests/qemu-iotests/common.config | 13 +

tests/qemu-iotests/common.filter | 1 +

tests/qemu-iotests/common.rc | 19 ++

33 files changed, 844 insertions(+), 42 deletions(-)

create mode 100644 block/vxhs.c

2.9.3

Move bdrv_is_read_only() up with its friends.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Jeff Cody <jcody@redhat.com>

Message-id: 73b2399459760c32506f9407efb9dddb3a2789de.1491597120.git.jcody@redhat.com

block.c | 10 +++++-----

1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/block.c b/block.c

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,

+bool bdrv_is_read_only(BlockDriverState *bs)

+{

+ return bs->read_only;

+}

+

int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

{

/* Do not set read_only if copy_on_read is enabled */

@@ -XXX,XX +XXX,XX @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)

*nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;

}

-bool bdrv_is_read_only(BlockDriverState *bs)

- return bs->read_only;

bool bdrv_is_sg(BlockDriverState *bs)

{

return bs->sg;

2.9.3

Update 'clientname' to be 'user', which tracks better with both

the QAPI and rados variable naming.

Update 'name' to be 'image_name', as it indicates the rbd image.

Naming it 'image' would have been ideal, but we are using that for

the rados_image_t value returned by rbd_open().

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Jeff Cody <jcody@redhat.com>

Reviewed-by: John Snow <jsnow@redhat.com>

Message-id: b7ec1fb2e1cf36f9b6911631447a5b0422590b7d.1491597120.git.jcody@redhat.com

block/rbd.c | 33 +++++++++++++++++----------------

1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/block/rbd.c b/block/rbd.c

index XXXXXXX..XXXXXXX 100644

--- a/block/rbd.c

+++ b/block/rbd.c

@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRBDState {

rados_t cluster;

rados_ioctx_t io_ctx;

rbd_image_t image;

- char *name;

+ char *image_name;

char *snap;

} BDRVRBDState;

@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)

int64_t bytes = 0;

int64_t objsize;

int obj_order = 0;

- const char *pool, *name, *conf, *clientname, *keypairs;

+ const char *pool, *image_name, *conf, *user, *keypairs;

const char *secretid;

rados_t cluster;

rados_ioctx_t io_ctx;

@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)

*/

pool = qdict_get_try_str(options, "pool");

conf = qdict_get_try_str(options, "conf");

- clientname = qdict_get_try_str(options, "user");

- name = qdict_get_try_str(options, "image");

+ user = qdict_get_try_str(options, "user");

+ image_name = qdict_get_try_str(options, "image");

keypairs = qdict_get_try_str(options, "=keyvalue-pairs");

- ret = rados_create(&cluster, clientname);

+ ret = rados_create(&cluster, user);

if (ret < 0) {

error_setg_errno(errp, -ret, "error initializing");

goto exit;

@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)

goto shutdown;

}

- ret = rbd_create(io_ctx, name, bytes, &obj_order);

+ ret = rbd_create(io_ctx, image_name, bytes, &obj_order);

if (ret < 0) {

error_setg_errno(errp, -ret, "error rbd create");

}

@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,

Error **errp)

{

BDRVRBDState *s = bs->opaque;

- const char *pool, *snap, *conf, *clientname, *name, *keypairs;

+ const char *pool, *snap, *conf, *user, *image_name, *keypairs;

const char *secretid;

QemuOpts *opts;

Error *local_err = NULL;

@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,

pool = qemu_opt_get(opts, "pool");

conf = qemu_opt_get(opts, "conf");

snap = qemu_opt_get(opts, "snapshot");

- clientname = qemu_opt_get(opts, "user");

- name = qemu_opt_get(opts, "image");

+ user = qemu_opt_get(opts, "user");

+ image_name = qemu_opt_get(opts, "image");

keypairs = qemu_opt_get(opts, "=keyvalue-pairs");

- if (!pool || !name) {

+ if (!pool || !image_name) {

error_setg(errp, "Parameters 'pool' and 'image' are required");

r = -EINVAL;

goto failed_opts;

}

- r = rados_create(&s->cluster, clientname);

+ r = rados_create(&s->cluster, user);

if (r < 0) {

error_setg_errno(errp, -r, "error initializing");

goto failed_opts;

}

s->snap = g_strdup(snap);

- s->name = g_strdup(name);

+ s->image_name = g_strdup(image_name);

/* try default location when conf=NULL, but ignore failure */

r = rados_conf_read_file(s->cluster, conf);

@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,

}

/* rbd_open is always r/w */

- r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);

+ r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap);

if (r < 0) {

- error_setg_errno(errp, -r, "error reading header from %s", s->name);

+ error_setg_errno(errp, -r, "error reading header from %s",

+ s->image_name);

goto failed_open;

}

@@ -XXX,XX +XXX,XX @@ failed_open:

failed_shutdown:

rados_shutdown(s->cluster);

g_free(s->snap);

- g_free(s->name);

+ g_free(s->image_name);

failed_opts:

qemu_opts_del(opts);

g_free(mon_host);

@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_close(BlockDriverState *bs)

rbd_close(s->image);

rados_ioctx_destroy(s->io_ctx);

g_free(s->snap);

- g_free(s->name);

+ g_free(s->image_name);

rados_shutdown(s->cluster);

}

2.9.3

For the tests that use the common.qemu functions for running a QEMU

process, _cleanup_qemu must be called in the exit function.

If it is not, if the qemu process aborts, then not all of the droppings

are cleaned up (e.g. pidfile, fifos).

This updates those tests that did not have a cleanup in qemu-iotests.

(I swapped spaces for tabs in test 102 as well)

Reported-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Signed-off-by: Jeff Cody <jcody@redhat.com>

Message-id: d59c2f6ad6c1da8b9b3c7f357c94a7122ccfc55a.1492544096.git.jcody@redhat.com

---

tests/qemu-iotests/028 | 1 +

tests/qemu-iotests/094 | 11 ++++++++---

tests/qemu-iotests/102 | 5 +++--

tests/qemu-iotests/109 | 1 +

tests/qemu-iotests/117 | 1 +

tests/qemu-iotests/130 | 1 +

tests/qemu-iotests/140 | 1 +

tests/qemu-iotests/141 | 1 +

tests/qemu-iotests/143 | 1 +

tests/qemu-iotests/156 | 1 +

10 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028

--- a/tests/qemu-iotests/028

+++ b/tests/qemu-iotests/028

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

rm -f "${TEST_IMG}.copy"

_cleanup_test_img

}

diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/094

+++ b/tests/qemu-iotests/094

@@ -XXX,XX +XXX,XX @@ echo "QA output created by $seq"

here="$PWD"

status=1    # failure is the default!

-trap "exit \$status" 0 1 2 3 15

+_cleanup()

+{

+ _cleanup_qemu

+ _cleanup_test_img

+ rm -f "$TEST_DIR/source.$IMGFMT"

+}

+trap "_cleanup; exit \$status" 0 1 2 3 15

# get standard environment, filters and checks

. ./common.rc

@@ -XXX,XX +XXX,XX @@ _send_qemu_cmd $QEMU_HANDLE \

wait=1 _cleanup_qemu

-_cleanup_test_img

-rm -f "$TEST_DIR/source.$IMGFMT"

# success, all done

echo '*** done'

diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/102

+++ b/tests/qemu-iotests/102

@@ -XXX,XX +XXX,XX @@ seq=$(basename $0)

echo "QA output created by $seq"

here=$PWD

-status=1    # failure is the default!

+status=1 # failure is the default!

_cleanup()

{

-    _cleanup_test_img

+ _cleanup_qemu

+ _cleanup_test_img

}

trap "_cleanup; exit \$status" 0 1 2 3 15

diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/109

+++ b/tests/qemu-iotests/109

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

rm -f $TEST_IMG.src

    _cleanup_test_img

}

diff --git a/tests/qemu-iotests/117 b/tests/qemu-iotests/117

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/117

+++ b/tests/qemu-iotests/117

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

    _cleanup_test_img

}

trap "_cleanup; exit \$status" 0 1 2 3 15

diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/130

+++ b/tests/qemu-iotests/130

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

_cleanup_test_img

}

trap "_cleanup; exit \$status" 0 1 2 3 15

diff --git a/tests/qemu-iotests/140 b/tests/qemu-iotests/140

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/140

+++ b/tests/qemu-iotests/140

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

_cleanup_test_img

rm -f "$TEST_DIR/nbd"

}

diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/141

+++ b/tests/qemu-iotests/141

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

_cleanup_test_img

rm -f "$TEST_DIR/{b,m,o}.$IMGFMT"

}

diff --git a/tests/qemu-iotests/143 b/tests/qemu-iotests/143

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/143

+++ b/tests/qemu-iotests/143

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

rm -f "$TEST_DIR/nbd"

}

trap "_cleanup; exit \$status" 0 1 2 3 15

diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/156

+++ b/tests/qemu-iotests/156

@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!

_cleanup()

{

+ _cleanup_qemu

rm -f "$TEST_IMG{,.target}{,.backing,.overlay}"

}

trap "_cleanup; exit \$status" 0 1 2 3 15

2.9.3

This adds support for reopen in rbd, for changing between r/w and r/o.

Note, that this is only a flag change, but we will block a change from

r/o to r/w if we are using an RBD internal snapshot.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Jeff Cody <jcody@redhat.com>

Reviewed-by: John Snow <jsnow@redhat.com>

Message-id: d4e87539167ec6527d44c97b164eabcccf96e4f3.1491597120.git.jcody@redhat.com

block/rbd.c | 21 +++++++++++++++++++++

1 file changed, 21 insertions(+)

diff --git a/block/rbd.c b/block/rbd.c

index XXXXXXX..XXXXXXX 100644

--- a/block/rbd.c

+++ b/block/rbd.c

@@ -XXX,XX +XXX,XX @@ failed_opts:

return r;

}

+

+/* Since RBD is currently always opened R/W via the API,

+ * we just need to check if we are using a snapshot or not, in

+ * order to determine if we will allow it to be R/W */

+static int qemu_rbd_reopen_prepare(BDRVReopenState *state,

+ BlockReopenQueue *queue, Error **errp)

+{

+ BDRVRBDState *s = state->bs->opaque;

+ int ret = 0;

+

+ if (s->snap && state->flags & BDRV_O_RDWR) {

+ error_setg(errp,

+ "Cannot change node '%s' to r/w when using RBD snapshot",

+ bdrv_get_device_or_node_name(state->bs));

+ ret = -EINVAL;

+ }

+

+ return ret;

+}

+

static void qemu_rbd_close(BlockDriverState *bs)

{

BDRVRBDState *s = bs->opaque;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {

.bdrv_parse_filename = qemu_rbd_parse_filename,

.bdrv_file_open = qemu_rbd_open,

.bdrv_close = qemu_rbd_close,

+ .bdrv_reopen_prepare = qemu_rbd_reopen_prepare,

.bdrv_create = qemu_rbd_create,

.bdrv_has_zero_init = bdrv_has_zero_init_1,

.bdrv_get_info = qemu_rbd_getinfo,

2.9.3

Signed-off-by: Jeff Cody <jcody@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Reviewed-by: John Snow <jsnow@redhat.com>

Message-id: 00aed7ffdd7be4b9ed9ce1007d50028a72b34ebe.1491597120.git.jcody@redhat.com

block.c | 14 ++++++++------

1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/block.c b/block.c

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,

BlockDriver *drv;

QemuOpts *opts;

const char *value;

+ bool read_only;

assert(reopen_state != NULL);

assert(reopen_state->bs->drv != NULL);

@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,

qdict_put(reopen_state->options, "driver", qstring_from_str(value));

}

- /* if we are to stay read-only, do not allow permission change

- * to r/w */

- if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&

- reopen_state->flags & BDRV_O_RDWR) {

- error_setg(errp, "Node '%s' is read only",

- bdrv_get_device_or_node_name(reopen_state->bs));

+ /* If we are to stay read-only, do not allow permission change

+ * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is

+ * not set, or if the BDS still has copy_on_read enabled */

+ read_only = !(reopen_state->flags & BDRV_O_RDWR);

+ ret = bdrv_can_set_read_only(reopen_state->bs, read_only, &local_err);

+ if (local_err) {

+ error_propagate(errp, local_err);

goto error;

}

2.9.3

Introduce check function for setting read_only flags. Will return < 0 on

error, with appropriate Error value set. Does not alter any flags.

Signed-off-by: Jeff Cody <jcody@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Reviewed-by: John Snow <jsnow@redhat.com>

Message-id: e2bba34ac3bc76a0c42adc390413f358ae0566e8.1491597120.git.jcody@redhat.com

block.c | 14 +++++++++++++-

include/block/block.h | 1 +

2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c

index XXXXXXX..XXXXXXX 100644

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ bool bdrv_is_read_only(BlockDriverState *bs)

return bs->read_only;

}

-int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

{

/* Do not set read_only if copy_on_read is enabled */

if (bs->copy_on_read && read_only) {

@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

return -EPERM;

}

+ return 0;

+}

+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

+{

+ int ret = 0;

+

+ ret = bdrv_can_set_read_only(bs, read_only, errp);

+ if (ret < 0) {

+ return ret;

+ }

+

bs->read_only = read_only;

return 0;

}

diff --git a/include/block/block.h b/include/block/block.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/block.h

+++ b/include/block/block.h

@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,

int64_t sector_num, int nb_sectors, int *pnum);

bool bdrv_is_read_only(BlockDriverState *bs);

+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);

int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);

bool bdrv_is_sg(BlockDriverState *bs);

bool bdrv_is_inserted(BlockDriverState *bs);

2.9.3

A few block drivers will set the BDS read_only flag from their

.bdrv_open() function. This means the bs->read_only flag could

be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ

flag check occurs prior to the call to bdrv->bdrv_open().

This adds an error return to bdrv_set_read_only(), and an error will be

return if we try to set the BDS to read_only while copy_on_read is

enabled.

This patch also changes the behavior of vvfat. Before, vvfat could

override the drive 'readonly' flag with its own, internal 'rw' flag.

For instance, this -drive parameter would result in a writable image:

"-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"

This is not correct. Now, attempting to use the above -drive parameter

will result in an error (i.e., 'rw' is incompatible with 'readonly=on').

Signed-off-by: Jeff Cody <jcody@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Reviewed-by: John Snow <jsnow@redhat.com>

Message-id: 0c5b4c1cc2c651471b131f21376dfd5ea24d2196.1491597120.git.jcody@redhat.com

---

block.c | 10 +++++++++-

block/bochs.c | 5 ++++-

block/cloop.c | 5 ++++-

block/dmg.c | 6 +++++-

block/rbd.c | 11 ++++++++++-

block/vvfat.c | 19 +++++++++++++++----

include/block/block.h | 2 +-

7 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/block.c b/block.c

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,

}

-void bdrv_set_read_only(BlockDriverState *bs, bool read_only)

+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)

{

+ /* Do not set read_only if copy_on_read is enabled */

+ if (bs->copy_on_read && read_only) {

+ error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",

+ bdrv_get_device_or_node_name(bs));

+ return -EINVAL;

bs->read_only = read_only;

+ return 0;

}

void bdrv_get_full_backing_filename_from_filename(const char *backed,

diff --git a/block/bochs.c b/block/bochs.c

index XXXXXXX..XXXXXXX 100644

--- a/block/bochs.c

+++ b/block/bochs.c

@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,

return -EINVAL;

}

- bdrv_set_read_only(bs, true); /* no write support yet */

+ ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */

+ if (ret < 0) {

+ return ret;

+ }

ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));

if (ret < 0) {

diff --git a/block/cloop.c b/block/cloop.c

index XXXXXXX..XXXXXXX 100644

--- a/block/cloop.c

+++ b/block/cloop.c

@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,

return -EINVAL;

}

- bdrv_set_read_only(bs, true);

+ ret = bdrv_set_read_only(bs, true, errp);

+ if (ret < 0) {

+ return ret;

+ }

/* read header */

ret = bdrv_pread(bs->file, 128, &s->block_size, 4);

diff --git a/block/dmg.c b/block/dmg.c

index XXXXXXX..XXXXXXX 100644

--- a/block/dmg.c

+++ b/block/dmg.c

@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,

return -EINVAL;

}

+ ret = bdrv_set_read_only(bs, true, errp);

+ if (ret < 0) {

+ return ret;

block_module_load_one("dmg-bz2");

- bdrv_set_read_only(bs, true);

s->n_chunks = 0;

s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;

diff --git a/block/rbd.c b/block/rbd.c

index XXXXXXX..XXXXXXX 100644

--- a/block/rbd.c

+++ b/block/rbd.c

@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,

goto failed_shutdown;

}

+ /* rbd_open is always r/w */

r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);

if (r < 0) {

error_setg_errno(errp, -r, "error reading header from %s", s->name);

goto failed_open;

}

- bdrv_set_read_only(bs, (s->snap != NULL));

+ /* If we are using an rbd snapshot, we must be r/o, otherwise

+ * leave as-is */

+ if (s->snap != NULL) {

+ r = bdrv_set_read_only(bs, true, &local_err);

+ if (r < 0) {

+ error_propagate(errp, local_err);

+ goto failed_open;

+ }

qemu_opts_del(opts);

return 0;

diff --git a/block/vvfat.c b/block/vvfat.c

index XXXXXXX..XXXXXXX 100644

--- a/block/vvfat.c

+++ b/block/vvfat.c

@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,

s->current_cluster=0xffffffff;

- /* read only is the default for safety */

- bdrv_set_read_only(bs, true);

s->qcow = NULL;

s->qcow_filename = NULL;

s->fat2 = NULL;

@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,

s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);

if (qemu_opt_get_bool(opts, "rw", false)) {

- ret = enable_write_target(bs, errp);

+ if (!bdrv_is_read_only(bs)) {

+ ret = enable_write_target(bs, errp);

+ if (ret < 0) {

+ goto fail;

+ }

+ } else {

+ ret = -EPERM;

+ error_setg(errp,

+ "Unable to set VVFAT to 'rw' when drive is read-only");

+ goto fail;

+ }

+ } else {

+ /* read only is the default for safety */

+ ret = bdrv_set_read_only(bs, true, &local_err);

if (ret < 0) {

+ error_propagate(errp, local_err);

goto fail;

}

- bdrv_set_read_only(bs, false);

}

bs->total_sectors = cyls * heads * secs;

diff --git a/include/block/block.h b/include/block/block.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/block.h

+++ b/include/block/block.h

@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,

int64_t sector_num, int nb_sectors, int *pnum);

bool bdrv_is_read_only(BlockDriverState *bs);

-void bdrv_set_read_only(BlockDriverState *bs, bool read_only);

+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);

bool bdrv_is_sg(BlockDriverState *bs);

bool bdrv_is_inserted(BlockDriverState *bs);

int bdrv_media_changed(BlockDriverState *bs);

2.9.3

From: Ashish Mittal <ashmit602@gmail.com>

Source code for the qnio library that this code loads can be downloaded from:

https://github.com/VeritasHyperScale/libqnio.git

Sample command line using JSON syntax:

./x86_64-softmmu/qemu-system-x86_64 -name instance-00000008 -S -vnc 0.0.0.0:0

-k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5

-msg timestamp=on

'json:{"driver":"vxhs","vdisk-id":"c3e9095a-a5ee-4dce-afeb-2a59fb387410",

"server":{"host":"172.172.17.4","port":"9999"}}'

Sample command line using URI syntax:

qemu-img convert -f raw -O raw -n

/var/lib/nova/instances/_base/0c5eacd5ebea5ed914b6a3e7b18f1ce734c386ad

vxhs://192.168.0.1:9999/c6718f6b-0401-441d-a8c3-1f0064d75ee0

Sample command line using TLS credentials (run in secure mode):

./qemu-io --object

tls-creds-x509,id=tls0,dir=/etc/pki/qemu/vxhs,endpoint=client -c 'read

-v 66000 2.5k' 'json:{"server.host": "127.0.0.1", "server.port": "9999",

"vdisk-id": "/test.raw", "driver": "vxhs", "tls-creds":"tls0"}'

Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Reviewed-by: Jeff Cody <jcody@redhat.com>

Signed-off-by: Jeff Cody <jcody@redhat.com>

Message-id: 1491277689-24949-2-git-send-email-Ashish.Mittal@veritas.com

block/Makefile.objs | 2 +

block/trace-events | 17 ++

block/vxhs.c | 575 +++++++++++++++++++++++++++++++++++++++++++++++++++

configure | 39 ++++

qapi/block-core.json | 23 ++-

5 files changed, 654 insertions(+), 2 deletions(-)

create mode 100644 block/vxhs.c

diff --git a/block/Makefile.objs b/block/Makefile.objs

index XXXXXXX..XXXXXXX 100644

--- a/block/Makefile.objs

+++ b/block/Makefile.objs

@@ -XXX,XX +XXX,XX @@ block-obj-$(CONFIG_LIBNFS) += nfs.o

block-obj-$(CONFIG_CURL) += curl.o

block-obj-$(CONFIG_RBD) += rbd.o

block-obj-$(CONFIG_GLUSTERFS) += gluster.o

+block-obj-$(CONFIG_VXHS) += vxhs.o

block-obj-$(CONFIG_LIBSSH2) += ssh.o

block-obj-y += accounting.o dirty-bitmap.o

block-obj-y += write-threshold.o

@@ -XXX,XX +XXX,XX @@ rbd.o-cflags := $(RBD_CFLAGS)

rbd.o-libs := $(RBD_LIBS)

gluster.o-cflags := $(GLUSTERFS_CFLAGS)

gluster.o-libs := $(GLUSTERFS_LIBS)

+vxhs.o-libs := $(VXHS_LIBS)

ssh.o-cflags := $(LIBSSH2_CFLAGS)

ssh.o-libs := $(LIBSSH2_LIBS)

block-obj-$(if $(CONFIG_BZIP2),m,n) += dmg-bz2.o

diff --git a/block/trace-events b/block/trace-events

index XXXXXXX..XXXXXXX 100644

--- a/block/trace-events

+++ b/block/trace-events

@@ -XXX,XX +XXX,XX @@ qed_aio_write_data(void *s, void *acb, int ret, uint64_t offset, size_t len) "s

qed_aio_write_prefill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64

qed_aio_write_postfill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64

qed_aio_write_main(void *s, void *acb, int ret, uint64_t offset, size_t len) "s %p acb %p ret %d offset %"PRIu64" len %zu"

+

+# block/vxhs.c

+vxhs_iio_callback(int error) "ctx is NULL: error %d"

+vxhs_iio_callback_chnfail(int err, int error) "QNIO channel failed, no i/o %d, %d"

+vxhs_iio_callback_unknwn(int opcode, int err) "unexpected opcode %d, errno %d"

+vxhs_aio_rw_invalid(int req) "Invalid I/O request iodir %d"

+vxhs_aio_rw_ioerr(char *guid, int iodir, uint64_t size, uint64_t off, void *acb, int ret, int err) "IO ERROR (vDisk %s) FOR : Read/Write = %d size = %lu offset = %lu ACB = %p. Error = %d, errno = %d"

+vxhs_get_vdisk_stat_err(char *guid, int ret, int err) "vDisk (%s) stat ioctl failed, ret = %d, errno = %d"

+vxhs_get_vdisk_stat(char *vdisk_guid, uint64_t vdisk_size) "vDisk %s stat ioctl returned size %lu"

+vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %ld"

+vxhs_parse_uri_filename(const char *filename) "URI passed via bdrv_parse_filename %s"

+vxhs_open_vdiskid(const char *vdisk_id) "Opening vdisk-id %s"

+vxhs_open_hostinfo(char *of_vsa_addr, int port) "Adding host %s:%d to BDRVVXHSState"

+vxhs_open_iio_open(const char *host) "Failed to connect to storage agent on host %s"

+vxhs_parse_uri_hostinfo(char *host, int port) "Host: IP %s, Port %d"

+vxhs_close(char *vdisk_guid) "Closing vdisk %s"

+vxhs_get_creds(const char *cacert, const char *client_key, const char *client_cert) "cacert %s, client_key %s, client_cert %s"

diff --git a/block/vxhs.c b/block/vxhs.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/block/vxhs.c

@@ -XXX,XX +XXX,XX @@

+/*

+ * QEMU Block driver for Veritas HyperScale (VxHS)

+ *

+ * Copyright (c) 2017 Veritas Technologies LLC.

+ *

+ * 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 "qemu/osdep.h"

+#include <qnio/qnio_api.h>

+#include <sys/param.h>

+#include "block/block_int.h"

+#include "qapi/qmp/qerror.h"

+#include "qapi/qmp/qdict.h"

+#include "qapi/qmp/qstring.h"

+#include "trace.h"

+#include "qemu/uri.h"

+#include "qapi/error.h"

+#include "qemu/uuid.h"

+#include "crypto/tlscredsx509.h"

+

+#define VXHS_OPT_FILENAME "filename"

+#define VXHS_OPT_VDISK_ID "vdisk-id"

+#define VXHS_OPT_SERVER "server"

+#define VXHS_OPT_HOST "host"

+#define VXHS_OPT_PORT "port"

+

+/* Only accessed under QEMU global mutex */

+static uint32_t vxhs_ref;

+

+typedef enum {

+ VDISK_AIO_READ,

+ VDISK_AIO_WRITE,

+} VDISKAIOCmd;

+

+/*

+ * HyperScale AIO callbacks structure

+ */

+typedef struct VXHSAIOCB {

+ BlockAIOCB common;

+ int err;

+} VXHSAIOCB;

+

+typedef struct VXHSvDiskHostsInfo {

+ void *dev_handle; /* Device handle */

+ char *host; /* Host name or IP */

+ int port; /* Host's port number */

+} VXHSvDiskHostsInfo;

+

+/*

+ * Structure per vDisk maintained for state

+ */

+typedef struct BDRVVXHSState {

+ VXHSvDiskHostsInfo vdisk_hostinfo; /* Per host info */

+ char *vdisk_guid;

+ char *tlscredsid; /* tlscredsid */

+} BDRVVXHSState;

+

+static void vxhs_complete_aio_bh(void *opaque)

+{

+ VXHSAIOCB *acb = opaque;

+ BlockCompletionFunc *cb = acb->common.cb;

+ void *cb_opaque = acb->common.opaque;

+ int ret = 0;

+

+ if (acb->err != 0) {

+ trace_vxhs_complete_aio(acb, acb->err);

+ ret = (-EIO);

+ }

+

+ qemu_aio_unref(acb);

+ cb(cb_opaque, ret);

+}

+

+/*

+ * Called from a libqnio thread

+ */

+static void vxhs_iio_callback(void *ctx, uint32_t opcode, uint32_t error)

+{

+ VXHSAIOCB *acb = NULL;

+

+ switch (opcode) {

+ case IRP_READ_REQUEST:

+ case IRP_WRITE_REQUEST:

+

+ /*

+ * ctx is VXHSAIOCB*

+ * ctx is NULL if error is QNIOERROR_CHANNEL_HUP

+ */

+ if (ctx) {

+ acb = ctx;

+ } else {

+ trace_vxhs_iio_callback(error);

+ goto out;

+ }

+

+ if (error) {

+ if (!acb->err) {

+ acb->err = error;

+ }

+ trace_vxhs_iio_callback(error);

+ }

+

+ aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),

+ vxhs_complete_aio_bh, acb);

+ break;

+

+ default:

+ if (error == QNIOERROR_HUP) {

+ /*

+ * Channel failed, spontaneous notification,

+ * not in response to I/O

+ */

+ trace_vxhs_iio_callback_chnfail(error, errno);

+ } else {

+ trace_vxhs_iio_callback_unknwn(opcode, error);

+ }

+ break;

+ }

+out:

+ return;

+}

+

+static QemuOptsList runtime_opts = {

+ .name = "vxhs",

+ .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),

+ .desc = {

+ {

+ .name = VXHS_OPT_FILENAME,

+ .type = QEMU_OPT_STRING,

+ .help = "URI to the Veritas HyperScale image",

+ },

+ {

+ .name = VXHS_OPT_VDISK_ID,

+ .type = QEMU_OPT_STRING,

+ .help = "UUID of the VxHS vdisk",

+ },

+ {

+ .name = "tls-creds",

+ .type = QEMU_OPT_STRING,

+ .help = "ID of the TLS/SSL credentials to use",

+ },

+ { /* end of list */ }

+ },

+};

+

+static QemuOptsList runtime_tcp_opts = {

+ .name = "vxhs_tcp",

+ .head = QTAILQ_HEAD_INITIALIZER(runtime_tcp_opts.head),

+ .desc = {

+ {

+ .name = VXHS_OPT_HOST,

+ .type = QEMU_OPT_STRING,

+ .help = "host address (ipv4 addresses)",

+ },

+ {

+ .name = VXHS_OPT_PORT,

+ .type = QEMU_OPT_NUMBER,

+ .help = "port number on which VxHSD is listening (default 9999)",

+ .def_value_str = "9999"

+ },

+ { /* end of list */ }

+ },

+};

+

+/*

+ * Parse incoming URI and populate *options with the host

+ * and device information

+ */

+static int vxhs_parse_uri(const char *filename, QDict *options)

+{

+ URI *uri = NULL;

+ char *port;

+ int ret = 0;

+

+ trace_vxhs_parse_uri_filename(filename);

+ uri = uri_parse(filename);

+ if (!uri || !uri->server || !uri->path) {

+ uri_free(uri);

+ return -EINVAL;

+ }

+

+ qdict_put(options, VXHS_OPT_SERVER".host", qstring_from_str(uri->server));

+

+ if (uri->port) {

+ port = g_strdup_printf("%d", uri->port);

+ qdict_put(options, VXHS_OPT_SERVER".port", qstring_from_str(port));

+ g_free(port);

+ }

+

+ qdict_put(options, "vdisk-id", qstring_from_str(uri->path));

+

+ trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);

+ uri_free(uri);

+

+ return ret;

+}

+

+static void vxhs_parse_filename(const char *filename, QDict *options,