Browse Source
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"}' [Jeff: Modified trace-events with the correct string formatting] 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.compull/9/merge
Ashish Mittal
9 years ago
committed by
Jeff Cody
Jeff Cody
5 changed files with 654 additions and 2 deletions
@ -0,0 +1,575 @@ |
|||
/*
|
|||
* 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); |
|||
Loading…
Reference in new issue