block/vxhs.c: Add support for a new block device type called "vxhs" (da92c3ff) · Commits · SUMMER2020 / students / proj-2021291

block/Makefile.objs

+2 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@ 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
		@@ -38,6 +39,7 @@ 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

block/trace-events

+17 −0

Original line number	Diff line number	Diff line
		@@ -110,3 +110,20 @@ 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 = %"PRIu64" offset = %"PRIu64" 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 %"PRIu64
		vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %"PRIu64
		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"

block/vxhs.c

0 → 100644

+575 −0

Original line number	Diff line number	Diff line
		/*
		* 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,
		Error **errp)
		{
		if (qdict_haskey(options, "vdisk-id") \|\| qdict_haskey(options, "server")) {
		error_setg(errp, "vdisk-id/server and a file name may not be specified "
		"at the same time");
		return;
		}

		if (strstr(filename, "://")) {
		int ret = vxhs_parse_uri(filename, options);
		if (ret < 0) {
		error_setg(errp, "Invalid URI. URI should be of the form "
		" vxhs://<host_ip>:<port>/<vdisk-id>");
		}
		}
		}

		static int vxhs_init_and_ref(void)
		{
		if (vxhs_ref++ == 0) {
		if (iio_init(QNIO_VERSION, vxhs_iio_callback)) {
		return -ENODEV;
		}
		}
		return 0;
		}

		static void vxhs_unref(void)
		{
		if (--vxhs_ref == 0) {
		iio_fini();
		}
		}

		static void vxhs_get_tls_creds(const char id, char *cacert,
		char key, char cert, Error **errp)
		{
		Object *obj;
		QCryptoTLSCreds *creds;
		QCryptoTLSCredsX509 *creds_x509;

		obj = object_resolve_path_component(
		object_get_objects_root(), id);

		if (!obj) {
		error_setg(errp, "No TLS credentials with id '%s'",
		id);
		return;
		}

		creds_x509 = (QCryptoTLSCredsX509 *)
		object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS_X509);

		if (!creds_x509) {
		error_setg(errp, "Object with id '%s' is not TLS credentials",
		id);
		return;
		}

		creds = &creds_x509->parent_obj;

		if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) {
		error_setg(errp,
		"Expecting TLS credentials with a client endpoint");
		return;
		}

		/*
		* Get the cacert, client_cert and client_key file names.
		*/
		if (!creds->dir) {
		error_setg(errp, "TLS object missing 'dir' property value");
		return;
		}

		*cacert = g_strdup_printf("%s/%s", creds->dir,
		QCRYPTO_TLS_CREDS_X509_CA_CERT);
		*cert = g_strdup_printf("%s/%s", creds->dir,
		QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
		*key = g_strdup_printf("%s/%s", creds->dir,
		QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);
		}

		static int vxhs_open(BlockDriverState bs, QDict options,
		int bdrv_flags, Error **errp)
		{
		BDRVVXHSState *s = bs->opaque;
		void *dev_handlep;
		QDict *backing_options = NULL;
		QemuOpts *opts = NULL;
		QemuOpts *tcp_opts = NULL;
		char *of_vsa_addr = NULL;
		Error *local_err = NULL;
		const char *vdisk_id_opt;
		const char *server_host_opt;
		int ret = 0;
		char *cacert = NULL;
		char *client_key = NULL;
		char *client_cert = NULL;

		ret = vxhs_init_and_ref();
		if (ret < 0) {
		ret = -EINVAL;
		goto out;
		}

		/* Create opts info from runtime_opts and runtime_tcp_opts list */
		opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
		tcp_opts = qemu_opts_create(&runtime_tcp_opts, NULL, 0, &error_abort);

		qemu_opts_absorb_qdict(opts, options, &local_err);
		if (local_err) {
		ret = -EINVAL;
		goto out;
		}

		/* vdisk-id is the disk UUID */
		vdisk_id_opt = qemu_opt_get(opts, VXHS_OPT_VDISK_ID);
		if (!vdisk_id_opt) {
		error_setg(&local_err, QERR_MISSING_PARAMETER, VXHS_OPT_VDISK_ID);
		ret = -EINVAL;
		goto out;
		}

		/* vdisk-id may contain a leading '/' */
		if (strlen(vdisk_id_opt) > UUID_FMT_LEN + 1) {
		error_setg(&local_err, "vdisk-id cannot be more than %d characters",
		UUID_FMT_LEN);
		ret = -EINVAL;
		goto out;
		}

		s->vdisk_guid = g_strdup(vdisk_id_opt);
		trace_vxhs_open_vdiskid(vdisk_id_opt);

		/* get the 'server.' arguments */
		qdict_extract_subqdict(options, &backing_options, VXHS_OPT_SERVER".");

		qemu_opts_absorb_qdict(tcp_opts, backing_options, &local_err);
		if (local_err != NULL) {
		ret = -EINVAL;
		goto out;
		}

		server_host_opt = qemu_opt_get(tcp_opts, VXHS_OPT_HOST);
		if (!server_host_opt) {
		error_setg(&local_err, QERR_MISSING_PARAMETER,
		VXHS_OPT_SERVER"."VXHS_OPT_HOST);
		ret = -EINVAL;
		goto out;
		}

		if (strlen(server_host_opt) > MAXHOSTNAMELEN) {
		error_setg(&local_err, "server.host cannot be more than %d characters",
		MAXHOSTNAMELEN);
		ret = -EINVAL;
		goto out;
		}

		/* check if we got tls-creds via the --object argument */
		s->tlscredsid = g_strdup(qemu_opt_get(opts, "tls-creds"));
		if (s->tlscredsid) {
		vxhs_get_tls_creds(s->tlscredsid, &cacert, &client_key,
		&client_cert, &local_err);
		if (local_err != NULL) {
		ret = -EINVAL;
		goto out;
		}
		trace_vxhs_get_creds(cacert, client_key, client_cert);
		}

		s->vdisk_hostinfo.host = g_strdup(server_host_opt);
		s->vdisk_hostinfo.port = g_ascii_strtoll(qemu_opt_get(tcp_opts,
		VXHS_OPT_PORT),
		NULL, 0);

		trace_vxhs_open_hostinfo(s->vdisk_hostinfo.host,
		s->vdisk_hostinfo.port);

		of_vsa_addr = g_strdup_printf("of://%s:%d",
		s->vdisk_hostinfo.host,
		s->vdisk_hostinfo.port);

		/*
		* Open qnio channel to storage agent if not opened before
		*/
		dev_handlep = iio_open(of_vsa_addr, s->vdisk_guid, 0,
		cacert, client_key, client_cert);
		if (dev_handlep == NULL) {
		trace_vxhs_open_iio_open(of_vsa_addr);
		ret = -ENODEV;
		goto out;
		}
		s->vdisk_hostinfo.dev_handle = dev_handlep;

		out:
		g_free(of_vsa_addr);
		QDECREF(backing_options);
		qemu_opts_del(tcp_opts);
		qemu_opts_del(opts);
		g_free(cacert);
		g_free(client_key);
		g_free(client_cert);

		if (ret < 0) {
		vxhs_unref();
		error_propagate(errp, local_err);
		g_free(s->vdisk_hostinfo.host);
		g_free(s->vdisk_guid);
		g_free(s->tlscredsid);
		s->vdisk_guid = NULL;
		}

		return ret;
		}

		static const AIOCBInfo vxhs_aiocb_info = {
		.aiocb_size = sizeof(VXHSAIOCB)
		};

		/*
		* This allocates QEMU-VXHS callback for each IO
		* and is passed to QNIO. When QNIO completes the work,
		* it will be passed back through the callback.
		*/
		static BlockAIOCB vxhs_aio_rw(BlockDriverState bs, int64_t sector_num,
		QEMUIOVector *qiov, int nb_sectors,
		BlockCompletionFunc cb, void opaque,
		VDISKAIOCmd iodir)
		{
		VXHSAIOCB *acb = NULL;
		BDRVVXHSState *s = bs->opaque;
		size_t size;
		uint64_t offset;
		int iio_flags = 0;
		int ret = 0;
		void *dev_handle = s->vdisk_hostinfo.dev_handle;

		offset = sector_num * BDRV_SECTOR_SIZE;
		size = nb_sectors * BDRV_SECTOR_SIZE;
		acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);

		/*
		* Initialize VXHSAIOCB.
		*/
		acb->err = 0;

		iio_flags = IIO_FLAG_ASYNC;

		switch (iodir) {
		case VDISK_AIO_WRITE:
		ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,
		offset, (uint64_t)size, iio_flags);
		break;
		case VDISK_AIO_READ:
		ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,
		offset, (uint64_t)size, iio_flags);
		break;
		default:
		trace_vxhs_aio_rw_invalid(iodir);
		goto errout;
		}

		if (ret != 0) {
		trace_vxhs_aio_rw_ioerr(s->vdisk_guid, iodir, size, offset,
		acb, ret, errno);
		goto errout;
		}
		return &acb->common;

		errout:
		qemu_aio_unref(acb);
		return NULL;
		}

		static BlockAIOCB vxhs_aio_readv(BlockDriverState bs,
		int64_t sector_num, QEMUIOVector *qiov,
		int nb_sectors,
		BlockCompletionFunc cb, void opaque)
		{
		return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
		opaque, VDISK_AIO_READ);
		}

		static BlockAIOCB vxhs_aio_writev(BlockDriverState bs,
		int64_t sector_num, QEMUIOVector *qiov,
		int nb_sectors,
		BlockCompletionFunc cb, void opaque)
		{
		return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors,
		cb, opaque, VDISK_AIO_WRITE);
		}

		static void vxhs_close(BlockDriverState *bs)
		{
		BDRVVXHSState *s = bs->opaque;

		trace_vxhs_close(s->vdisk_guid);

		g_free(s->vdisk_guid);
		s->vdisk_guid = NULL;

		/*
		* Close vDisk device
		*/
		if (s->vdisk_hostinfo.dev_handle) {
		iio_close(s->vdisk_hostinfo.dev_handle);
		s->vdisk_hostinfo.dev_handle = NULL;
		}

		vxhs_unref();

		/*
		* Free the dynamically allocated host string etc
		*/
		g_free(s->vdisk_hostinfo.host);
		g_free(s->tlscredsid);
		s->tlscredsid = NULL;
		s->vdisk_hostinfo.host = NULL;
		s->vdisk_hostinfo.port = 0;
		}

		static int64_t vxhs_get_vdisk_stat(BDRVVXHSState *s)
		{
		int64_t vdisk_size = -1;
		int ret = 0;
		void *dev_handle = s->vdisk_hostinfo.dev_handle;

		ret = iio_ioctl(dev_handle, IOR_VDISK_STAT, &vdisk_size, 0);
		if (ret < 0) {
		trace_vxhs_get_vdisk_stat_err(s->vdisk_guid, ret, errno);
		return -EIO;
		}

		trace_vxhs_get_vdisk_stat(s->vdisk_guid, vdisk_size);
		return vdisk_size;
		}

		/*
		* Returns the size of vDisk in bytes. This is required
		* by QEMU block upper block layer so that it is visible
		* to guest.
		*/
		static int64_t vxhs_getlength(BlockDriverState *bs)
		{
		BDRVVXHSState *s = bs->opaque;
		int64_t vdisk_size;

		vdisk_size = vxhs_get_vdisk_stat(s);
		if (vdisk_size < 0) {
		return -EIO;
		}

		return vdisk_size;
		}

		static BlockDriver bdrv_vxhs = {
		.format_name = "vxhs",
		.protocol_name = "vxhs",
		.instance_size = sizeof(BDRVVXHSState),
		.bdrv_file_open = vxhs_open,
		.bdrv_parse_filename = vxhs_parse_filename,
		.bdrv_close = vxhs_close,
		.bdrv_getlength = vxhs_getlength,
		.bdrv_aio_readv = vxhs_aio_readv,
		.bdrv_aio_writev = vxhs_aio_writev,
		};

		static void bdrv_vxhs_init(void)
		{
		bdrv_register(&bdrv_vxhs);
		}

		block_init(bdrv_vxhs_init);

configure

+39 −0

Original line number	Diff line number	Diff line
		@@ -320,6 +320,7 @@ numa=""
		tcmalloc="no"
		jemalloc="no"
		replication="yes"
		vxhs=""

		supported_cpu="no"
		supported_os="no"
		@@ -1183,6 +1184,10 @@ for opt do
		;;
		--enable-replication) replication="yes"
		;;
		--disable-vxhs) vxhs="no"
		;;
		--enable-vxhs) vxhs="yes"
		;;
		*)
		echo "ERROR: unknown option $opt"
		echo "Try '$0 --help' for more information"
		@@ -1415,6 +1420,7 @@ disabled with --disable-FEATURE, default is enabled if available:
		xfsctl xfsctl support
		qom-cast-debug cast debugging support
		tools build qemu-io, qemu-nbd and qemu-image tools
		vxhs Veritas HyperScale vDisk backend support

		NOTE: The object files are built at the place where configure is launched
		EOF
		@@ -4783,6 +4789,33 @@ if compile_prog "" "" ; then
		have_sysmacros=yes
		fi

		##########################################
		# Veritas HyperScale block driver VxHS
		# Check if libvxhs is installed

		if test "$vxhs" != "no" ; then
		cat > $TMPC <<EOF
		#include <stdint.h>
		#include <qnio/qnio_api.h>

		void *vxhs_callback;

		int main(void) {
		iio_init(QNIO_VERSION, vxhs_callback);
		return 0;
		}
		EOF
		vxhs_libs="-lvxhs -lssl"
		if compile_prog "" "$vxhs_libs" ; then
		vxhs=yes
		else
		if test "$vxhs" = "yes" ; then
		feature_not_found "vxhs block device" "Install libvxhs See github"
		fi
		vxhs=no
		fi
		fi

		##########################################
		# End of CC checks
		# After here, no more $cc or $ld runs
		@@ -5149,6 +5182,7 @@ echo "tcmalloc support $tcmalloc"
		echo "jemalloc support $jemalloc"
		echo "avx2 optimization $avx2_opt"
		echo "replication support $replication"
		echo "VxHS block device $vxhs"

		if test "$sdl_too_old" = "yes"; then
		echo "-> Your SDL version is too old - please upgrade to have SDL support"
		@@ -5788,6 +5822,11 @@ if test "$pthread_setname_np" = "yes" ; then
		echo "CONFIG_PTHREAD_SETNAME_NP=y" >> $config_host_mak
		fi

		if test "$vxhs" = "yes" ; then
		echo "CONFIG_VXHS=y" >> $config_host_mak
		echo "VXHS_LIBS=$vxhs_libs" >> $config_host_mak
		fi

		if test "$tcg_interpreter" = "yes"; then
		QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/tci $QEMU_INCLUDES"
		elif test "$ARCH" = "sparc64" ; then

qapi/block-core.json

+21 −2

Original line number	Diff line number	Diff line
		@@ -2108,6 +2108,8 @@
		#
		# Drivers that are supported in block device operations.
		#
		# @vxhs: Since 2.10
		#
		# Since: 2.9
		##
		{ 'enum': 'BlockdevDriver',
		@@ -2116,7 +2118,7 @@
		'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
		'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed',
		'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh',
		'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
		'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }

		##
		# @BlockdevOptionsFile:
		@@ -2865,6 +2867,22 @@
		'base': 'BlockdevOptionsGenericFormat',
		'data': { 'offset': 'int', 'size': 'int' } }

		##
		# @BlockdevOptionsVxHS:
		#
		# Driver specific block device options for VxHS
		#
		# @vdisk-id: UUID of VxHS volume
		# @server: vxhs server IP, port
		# @tls-creds: TLS credentials ID
		#
		# Since: 2.10
		##
		{ 'struct': 'BlockdevOptionsVxHS',
		'data': { 'vdisk-id': 'str',
		'server': 'InetSocketAddressBase',
		'*tls-creds': 'str' } }

		##
		# @BlockdevOptions:
		#
		@@ -2927,7 +2945,8 @@
		'vhdx': 'BlockdevOptionsGenericFormat',
		'vmdk': 'BlockdevOptionsGenericCOWFormat',
		'vpc': 'BlockdevOptionsGenericFormat',
		'vvfat': 'BlockdevOptionsVVFAT'
		'vvfat': 'BlockdevOptionsVVFAT',
		'vxhs': 'BlockdevOptionsVxHS'
		} }

		##