ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

-----BEGIN PGP SIGNATURE----- 

iQIcBAABAgAGBQJY2m0AAAoJEL2+eyfA3jBXiykP/1JuVkm8b+SJhcanFRNNdr4n
 bOKmJQot9dCVzC3PQTOgKL99j8ZFGCo3XVztoNy8ZM3lbIdiPE9YLS+llh2cflOY
 J95+leX6n5QSdFVGBUmmi3yGESD/4BdT4p04/mm2RcMfqN0ehuLKBQQ/9ucgXNL+
 8dRUFc5Sse3xxJcr+r4buTuffQI6fr6JZw5Z6MkishZOQKz3zMIzQgtk9YpurcuY
 Mz7HFh7lY6v1zQEUyM4kwk57+5EQ977tbAQ3/dFaNWrHxDSMSAK7cyEBfHlhIFLl
 6pa5hFvg6q4zSZ8mrkSt5uSSj2dg6mx08p8b1qhMQcmnMeYpsnJ6rubnvWlh26qZ
 NGH7dQRFFpJOM8HVDzEOS9ePNhIyYc03FTSQyVArSygrJRF4BRGqlMc1JdiDUBKl
 9ksG+73MPK2lGW609jNHhpvcZUfUGagFJHCF1g5RqH5zTvJXa/VJbAOFMKLzSHH3
 OYnm7yLkbmTEfUDY0s9RxQbZXJYPnWn8Pc+yHyJFxT1gb0qqK6wtzKeJIHPYKH2q
 IjijGvkyTdZ6+ODdywlUF7S4rcFPnojWCedX9EwGAIFVK3RVLxnQdsWoJu6vXDZU
 bFY+nnV5dlMjE2QiPBekfuT7qrREI291AxoMOUibCfDMMMTkNIc+3UTKxcyPkpzZ
 91KFPRKL0X3pgIocbTZb
 =Shqy
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/cody/tags/block-pull-request' into staging

# gpg: Signature made Tue 28 Mar 2017 15:02:40 BST
# gpg:                using RSA key 0xBDBE7B27C0DE3057
# gpg: Good signature from "Jeffrey Cody <jcody@redhat.com>"
# gpg:                 aka "Jeffrey Cody <jeff@codyprime.org>"
# gpg:                 aka "Jeffrey Cody <codyprime@gmail.com>"
# Primary key fingerprint: 9957 4B4D 3474 90E7 9D98  D624 BDBE 7B27 C0DE 3057

* remotes/cody/tags/block-pull-request:
  rbd: Fix bugs around -drive parameter "server"
  rbd: Revert -blockdev parameter password-secret
  rbd: Revert -blockdev and -drive parameter auth-supported
  rbd: Clean up qemu_rbd_create()'s detour through QemuOpts
  rbd: Clean up runtime_opts, fix -drive to reject filename
  rbd: Don't accept -drive driver=rbd, keyvalue-pairs=...
  rbd: Clean up after the previous commit
  rbd: Don't limit length of parameter values
  rbd: Fix to cleanly reject -drive without pool or image
  rbd: Reject -blockdev server.*.{numeric, to, ipv4, ipv6}

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2017-03-28 15:56:05 +01:00
parent 4d2bee82f4 2836284db6
commit aba0fb1e2e
3 changed files with 100 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

299
block/rbd.c
View File

@ -13,6 +13,7 @@
#include "qemu/osdep.h" #include "qemu/osdep.h"
#include <rbd/librbd.h>
#include "qapi/error.h" #include "qapi/error.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "block/block_int.h" #include "block/block_int.h"
@ -20,8 +21,6 @@
#include "qemu/cutils.h" #include "qemu/cutils.h"
#include "qapi/qmp/qstring.h" #include "qapi/qmp/qstring.h"
#include <rbd/librbd.h>
/* /*
* When specifying the image filename use: * When specifying the image filename use:
* *
@ -56,11 +55,6 @@
#define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER) #define OBJ_MAX_SIZE (1UL << OBJ_DEFAULT_OBJ_ORDER)
#define RBD_MAX_CONF_NAME_SIZE 128
#define RBD_MAX_CONF_VAL_SIZE 512
#define RBD_MAX_CONF_SIZE 1024
#define RBD_MAX_POOL_NAME_SIZE 128
#define RBD_MAX_SNAP_NAME_SIZE 128
#define RBD_MAX_SNAPS 100 #define RBD_MAX_SNAPS 100
/* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */ /* The LIBRBD_SUPPORTS_IOVEC is defined in librbd.h */
@ -99,21 +93,16 @@ typedef struct BDRVRBDState {
rados_t cluster; rados_t cluster;
rados_ioctx_t io_ctx; rados_ioctx_t io_ctx;
rbd_image_t image; rbd_image_t image;
char name[RBD_MAX_IMAGE_NAME_SIZE]; char *name;
char *snap; char *snap;
} BDRVRBDState; } BDRVRBDState;
static char *qemu_rbd_next_tok(int max_len, static char *qemu_rbd_next_tok(char *src, char delim, char **p)
char *src, char delim,
const char *name,
char **p, Error **errp)
{ {
int l;
char *end; char *end;
*p = NULL; *p = NULL;
if (delim != '\0') {
for (end = src; *end; ++end) { for (end = src; *end; ++end) {
if (*end == delim) { if (*end == delim) {
break; break;
@ -126,16 +115,6 @@ static char *qemu_rbd_next_tok(int max_len,
*p = end + 1; *p = end + 1;
*end = '\0'; *end = '\0';
} }
}
l = strlen(src);
if (l >= max_len) {
error_setg(errp, "%s too long", name);
return NULL;
} else if (l == 0) {
error_setg(errp, "%s too short", name);
return NULL;
}
return src; return src;
} }
@ -159,7 +138,6 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
char *p, *buf, *keypairs; char *p, *buf, *keypairs;
char *found_str; char *found_str;
size_t max_keypair_size; size_t max_keypair_size;
Error *local_err = NULL;
if (!strstart(filename, "rbd:", &start)) { if (!strstart(filename, "rbd:", &start)) {
error_setg(errp, "File name must start with 'rbd:'"); error_setg(errp, "File name must start with 'rbd:'");
@ -171,11 +149,7 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
keypairs = g_malloc0(max_keypair_size); keypairs = g_malloc0(max_keypair_size);
p = buf; p = buf;
found_str = qemu_rbd_next_tok(RBD_MAX_POOL_NAME_SIZE, p, found_str = qemu_rbd_next_tok(p, '/', &p);
'/', "pool name", &p, &local_err);
if (local_err) {
goto done;
}
if (!p) { if (!p) {
error_setg(errp, "Pool name is required"); error_setg(errp, "Pool name is required");
goto done; goto done;
@ -184,27 +158,15 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
qdict_put(options, "pool", qstring_from_str(found_str)); qdict_put(options, "pool", qstring_from_str(found_str));
if (strchr(p, '@')) { if (strchr(p, '@')) {
found_str = qemu_rbd_next_tok(RBD_MAX_IMAGE_NAME_SIZE, p, found_str = qemu_rbd_next_tok(p, '@', &p);
'@', "object name", &p, &local_err);
if (local_err) {
goto done;
}
qemu_rbd_unescape(found_str); qemu_rbd_unescape(found_str);
qdict_put(options, "image", qstring_from_str(found_str)); qdict_put(options, "image", qstring_from_str(found_str));
found_str = qemu_rbd_next_tok(RBD_MAX_SNAP_NAME_SIZE, p, found_str = qemu_rbd_next_tok(p, ':', &p);
':', "snap name", &p, &local_err);
if (local_err) {
goto done;
}
qemu_rbd_unescape(found_str); qemu_rbd_unescape(found_str);
qdict_put(options, "snapshot", qstring_from_str(found_str)); qdict_put(options, "snapshot", qstring_from_str(found_str));
} else { } else {
found_str = qemu_rbd_next_tok(RBD_MAX_IMAGE_NAME_SIZE, p, found_str = qemu_rbd_next_tok(p, ':', &p);
':', "object name", &p, &local_err);
if (local_err) {
goto done;
}
qemu_rbd_unescape(found_str); qemu_rbd_unescape(found_str);
qdict_put(options, "image", qstring_from_str(found_str)); qdict_put(options, "image", qstring_from_str(found_str));
} }
@ -212,24 +174,11 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
goto done; goto done;
} }
found_str = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, p,
'\0', "configuration", &p, &local_err);
if (local_err) {
goto done;
}
p = found_str;
/* The following are essentially all key/value pairs, and we treat /* The following are essentially all key/value pairs, and we treat
* 'id' and 'conf' a bit special. Key/value pairs may be in any order. */ * 'id' and 'conf' a bit special. Key/value pairs may be in any order. */
while (p) { while (p) {
char *name, *value; char *name, *value;
name = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, p, name = qemu_rbd_next_tok(p, '=', &p);
'=', "conf option name", &p, &local_err);
if (local_err) {
break;
}
if (!p) { if (!p) {
error_setg(errp, "conf option %s has no value", name); error_setg(errp, "conf option %s has no value", name);
break; break;
@ -237,11 +186,7 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
qemu_rbd_unescape(name); qemu_rbd_unescape(name);
value = qemu_rbd_next_tok(RBD_MAX_CONF_VAL_SIZE, p, value = qemu_rbd_next_tok(p, ':', &p);
':', "conf option value", &p, &local_err);
if (local_err) {
break;
}
qemu_rbd_unescape(value); qemu_rbd_unescape(value);
if (!strcmp(name, "conf")) { if (!strcmp(name, "conf")) {
@ -269,14 +214,11 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
} }
if (keypairs[0]) { if (keypairs[0]) {
qdict_put(options, "keyvalue-pairs", qstring_from_str(keypairs)); qdict_put(options, "=keyvalue-pairs", qstring_from_str(keypairs));
} }
done: done:
if (local_err) {
error_propagate(errp, local_err);
}
g_free(buf); g_free(buf);
g_free(keypairs); g_free(keypairs);
return; return;
@ -308,30 +250,20 @@ static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs,
char *p, *buf; char *p, *buf;
char *name; char *name;
char *value; char *value;
Error *local_err = NULL;
int ret = 0; int ret = 0;
buf = g_strdup(keypairs); buf = g_strdup(keypairs);
p = buf; p = buf;
while (p) { while (p) {
name = qemu_rbd_next_tok(RBD_MAX_CONF_NAME_SIZE, p, name = qemu_rbd_next_tok(p, '=', &p);
'=', "conf option name", &p, &local_err);
if (local_err) {
break;
}
if (!p) { if (!p) {
error_setg(errp, "conf option %s has no value", name); error_setg(errp, "conf option %s has no value", name);
ret = -EINVAL; ret = -EINVAL;
break; break;
} }
value = qemu_rbd_next_tok(RBD_MAX_CONF_VAL_SIZE, p, value = qemu_rbd_next_tok(p, ':', &p);
':', "conf option value", &p, &local_err);
if (local_err) {
break;
}
ret = rados_conf_set(cluster, name, value); ret = rados_conf_set(cluster, name, value);
if (ret < 0) { if (ret < 0) {
@ -341,10 +273,6 @@ static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs,
} }
} }
if (local_err) {
error_propagate(errp, local_err);
ret = -EINVAL;
}
g_free(buf); g_free(buf);
return ret; return ret;
} }
@ -364,21 +292,6 @@ static QemuOptsList runtime_opts = {
.name = "rbd", .name = "rbd",
.head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head), .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
.desc = { .desc = {
{
.name = "filename",
.type = QEMU_OPT_STRING,
.help = "Specification of the rbd image",
},
{
.name = "password-secret",
.type = QEMU_OPT_STRING,
.help = "ID of secret providing the password",
},
{
.name = "conf",
.type = QEMU_OPT_STRING,
.help = "Rados config file location",
},
{ {
.name = "pool", .name = "pool",
.type = QEMU_OPT_STRING, .type = QEMU_OPT_STRING,
@ -389,6 +302,11 @@ static QemuOptsList runtime_opts = {
.type = QEMU_OPT_STRING, .type = QEMU_OPT_STRING,
.help = "Image name in the pool", .help = "Image name in the pool",
}, },
{
.name = "conf",
.type = QEMU_OPT_STRING,
.help = "Rados config file location",
},
{ {
.name = "snapshot", .name = "snapshot",
.type = QEMU_OPT_STRING, .type = QEMU_OPT_STRING,
@ -400,24 +318,27 @@ static QemuOptsList runtime_opts = {
.type = QEMU_OPT_STRING, .type = QEMU_OPT_STRING,
.help = "Rados id name", .help = "Rados id name",
}, },
/*
* server.* extracted manually, see qemu_rbd_mon_host()
*/
{ {
.name = "keyvalue-pairs", .name = "password-secret",
.type = QEMU_OPT_STRING,
.help = "ID of secret providing the password",
},
/*
* Keys for qemu_rbd_parse_filename(), not in the QAPI schema
*/
{
/*
* HACK: name starts with '=' so that qemu_opts_parse()
* can't set it
*/
.name = "=keyvalue-pairs",
.type = QEMU_OPT_STRING, .type = QEMU_OPT_STRING,
.help = "Legacy rados key/value option parameters", .help = "Legacy rados key/value option parameters",
}, },
{
.name = "host",
.type = QEMU_OPT_STRING,
},
{
.name = "port",
.type = QEMU_OPT_STRING,
},
{
.name = "auth",
.type = QEMU_OPT_STRING,
.help = "Supported authentication method, either cephx or none",
},
{ /* end of list */ } { /* end of list */ }
}, },
}; };
@ -433,7 +354,6 @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
rados_t cluster; rados_t cluster;
rados_ioctx_t io_ctx; rados_ioctx_t io_ctx;
QDict *options = NULL; QDict *options = NULL;
QemuOpts *rbd_opts = NULL;
int ret = 0; int ret = 0;
secretid = qemu_opt_get(opts, "password-secret"); secretid = qemu_opt_get(opts, "password-secret");
@ -464,19 +384,11 @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
goto exit; goto exit;
} }
rbd_opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); pool = qdict_get_try_str(options, "pool");
qemu_opts_absorb_qdict(rbd_opts, options, &local_err); conf = qdict_get_try_str(options, "conf");
if (local_err) { clientname = qdict_get_try_str(options, "user");
error_propagate(errp, local_err); name = qdict_get_try_str(options, "image");
ret = -EINVAL; keypairs = qdict_get_try_str(options, "=keyvalue-pairs");
goto exit;
}
pool = qemu_opt_get(rbd_opts, "pool");
conf = qemu_opt_get(rbd_opts, "conf");
clientname = qemu_opt_get(rbd_opts, "user");
name = qemu_opt_get(rbd_opts, "image");
keypairs = qemu_opt_get(rbd_opts, "keyvalue-pairs");
ret = rados_create(&cluster, clientname); ret = rados_create(&cluster, clientname);
if (ret < 0) { if (ret < 0) {
@ -527,7 +439,6 @@ shutdown:
exit: exit:
QDECREF(options); QDECREF(options);
qemu_opts_del(rbd_opts);
return ret; return ret;
} }
@ -578,91 +489,43 @@ static void qemu_rbd_complete_aio(RADOSCB *rcb)
qemu_aio_unref(acb); qemu_aio_unref(acb);
} }
#define RBD_MON_HOST 0 static char *qemu_rbd_mon_host(QDict *options, Error **errp)
#define RBD_AUTH_SUPPORTED 1
static char *qemu_rbd_array_opts(QDict *options, const char *prefix, int type,
Error **errp)
{ {
int num_entries; const char **vals = g_new(const char *, qdict_size(options) + 1);
QemuOpts *opts = NULL; char keybuf[32];
QDict *sub_options; const char *host, *port;
const char *host; char *rados_str;
const char *port;
char *str;
char *rados_str = NULL;
Error *local_err = NULL;
int i; int i;
assert(type == RBD_MON_HOST || type == RBD_AUTH_SUPPORTED); for (i = 0;; i++) {
sprintf(keybuf, "server.%d.host", i);
num_entries = qdict_array_entries(options, prefix); host = qdict_get_try_str(options, keybuf);
qdict_del(options, keybuf);
if (num_entries < 0) { sprintf(keybuf, "server.%d.port", i);
error_setg(errp, "Parse error on RBD QDict array"); port = qdict_get_try_str(options, keybuf);
return NULL; qdict_del(options, keybuf);
if (!host && !port) {
break;
} }
if (!host) {
for (i = 0; i < num_entries; i++) { error_setg(errp, "Parameter server.%d.host is missing", i);
char *strbuf = NULL;
const char *value;
char *rados_str_tmp;
str = g_strdup_printf("%s%d.", prefix, i);
qdict_extract_subqdict(options, &sub_options, str);
g_free(str);
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, sub_options, &local_err);
QDECREF(sub_options);
if (local_err) {
error_propagate(errp, local_err);
g_free(rados_str);
rados_str = NULL; rados_str = NULL;
goto exit; goto out;
} }
if (type == RBD_MON_HOST) {
host = qemu_opt_get(opts, "host");
port = qemu_opt_get(opts, "port");
value = host;
if (port) {
/* check for ipv6 */
if (strchr(host, ':')) { if (strchr(host, ':')) {
strbuf = g_strdup_printf("[%s]:%s", host, port); vals[i] = port ? g_strdup_printf("[%s]:%s", host, port)
: g_strdup_printf("[%s]", host);
} else { } else {
strbuf = g_strdup_printf("%s:%s", host, port); vals[i] = port ? g_strdup_printf("%s:%s", host, port)
: g_strdup(host);
} }
value = strbuf;
} else if (strchr(host, ':')) {
strbuf = g_strdup_printf("[%s]", host);
value = strbuf;
}
} else {
value = qemu_opt_get(opts, "auth");
} }
vals[i] = NULL;
rados_str = i ? g_strjoinv(";", (char **)vals) : NULL;
/* each iteration in the for loop will build upon the string, and if out:
* rados_str is NULL then it is our first pass */ g_strfreev((char **)vals);
if (rados_str) {
/* separate options with ';', as that is what rados_conf_set()
* requires */
rados_str_tmp = rados_str;
rados_str = g_strdup_printf("%s;%s", rados_str_tmp, value);
g_free(rados_str_tmp);
} else {
rados_str = g_strdup(value);
}
g_free(strbuf);
qemu_opts_del(opts);
opts = NULL;
}
exit:
qemu_opts_del(opts);
return rados_str; return rados_str;
} }
@ -675,27 +538,17 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
QemuOpts *opts; QemuOpts *opts;
Error *local_err = NULL; Error *local_err = NULL;
char *mon_host = NULL; char *mon_host = NULL;
char *auth_supported = NULL;
int r; int r;
opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort); opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
qemu_opts_absorb_qdict(opts, options, &local_err); qemu_opts_absorb_qdict(opts, options, &local_err);
if (local_err) {
error_propagate(errp, local_err);
qemu_opts_del(opts);
return -EINVAL;
}
auth_supported = qemu_rbd_array_opts(options, "auth-supported.",
RBD_AUTH_SUPPORTED, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
r = -EINVAL; r = -EINVAL;
goto failed_opts; goto failed_opts;
} }
mon_host = qemu_rbd_array_opts(options, "server.", mon_host = qemu_rbd_mon_host(options, &local_err);
RBD_MON_HOST, &local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
r = -EINVAL; r = -EINVAL;
@ -709,7 +562,13 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
snap = qemu_opt_get(opts, "snapshot"); snap = qemu_opt_get(opts, "snapshot");
clientname = qemu_opt_get(opts, "user"); clientname = qemu_opt_get(opts, "user");
name = qemu_opt_get(opts, "image"); name = qemu_opt_get(opts, "image");
keypairs = qemu_opt_get(opts, "keyvalue-pairs"); keypairs = qemu_opt_get(opts, "=keyvalue-pairs");
if (!pool || !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, clientname);
if (r < 0) { if (r < 0) {
@ -718,9 +577,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
} }
s->snap = g_strdup(snap); s->snap = g_strdup(snap);
if (name) { s->name = g_strdup(name);
pstrcpy(s->name, RBD_MAX_IMAGE_NAME_SIZE, name);
}
/* try default location when conf=NULL, but ignore failure */ /* try default location when conf=NULL, but ignore failure */
r = rados_conf_read_file(s->cluster, conf); r = rados_conf_read_file(s->cluster, conf);
@ -741,13 +598,6 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
} }
} }
if (auth_supported) {
r = rados_conf_set(s->cluster, "auth_supported", auth_supported);
if (r < 0) {
goto failed_shutdown;
}
}
if (qemu_rbd_set_auth(s->cluster, secretid, errp) < 0) { if (qemu_rbd_set_auth(s->cluster, secretid, errp) < 0) {
r = -EIO; r = -EIO;
goto failed_shutdown; goto failed_shutdown;
@ -794,10 +644,10 @@ failed_open:
failed_shutdown: failed_shutdown:
rados_shutdown(s->cluster); rados_shutdown(s->cluster);
g_free(s->snap); g_free(s->snap);
g_free(s->name);
failed_opts: failed_opts:
qemu_opts_del(opts); qemu_opts_del(opts);
g_free(mon_host); g_free(mon_host);
g_free(auth_supported);
return r; return r;
} }
@ -808,6 +658,7 @@ static void qemu_rbd_close(BlockDriverState *bs)
rbd_close(s->image); rbd_close(s->image);
rados_ioctx_destroy(s->io_ctx); rados_ioctx_destroy(s->io_ctx);
g_free(s->snap); g_free(s->snap);
g_free(s->name);
rados_shutdown(s->cluster); rados_shutdown(s->cluster);
} }

21
qapi-schema.json
View File

@ -4050,20 +4050,28 @@
{ 'enum': 'NetFilterDirection', { 'enum': 'NetFilterDirection',
'data': [ 'all', 'rx', 'tx' ] } 'data': [ 'all', 'rx', 'tx' ] }
##
# @InetSocketAddressBase:
#
# @host: host part of the address
# @port: port part of the address
##
{ 'struct': 'InetSocketAddressBase',
'data': {
'host': 'str',
'port': 'str' } }
## ##
# @InetSocketAddress: # @InetSocketAddress:
# #
# Captures a socket address or address range in the Internet namespace. # Captures a socket address or address range in the Internet namespace.
# #
# @host: host part of the address
#
# @port: port part of the address, or lowest port if @to is present
#
# @numeric: true if the host/port are guaranteed to be numeric, # @numeric: true if the host/port are guaranteed to be numeric,
# false if name resolution should be attempted. Defaults to false. # false if name resolution should be attempted. Defaults to false.
# (Since 2.9) # (Since 2.9)
# #
# @to: highest port to try # @to: If present, this is range of possible addresses, with port
# between @port and @to.
# #
# @ipv4: whether to accept IPv4 addresses, default try both IPv4 and IPv6 # @ipv4: whether to accept IPv4 addresses, default try both IPv4 and IPv6
# #
@ -4072,9 +4080,8 @@
# Since: 1.3 # Since: 1.3
## ##
{ 'struct': 'InetSocketAddress', { 'struct': 'InetSocketAddress',
'base': 'InetSocketAddressBase',
'data': { 'data': {
'host': 'str',
'port': 'str',
'*numeric': 'bool', '*numeric': 'bool',
'*to': 'uint16', '*to': 'uint16',
'*ipv4': 'bool', '*ipv4': 'bool',

30
qapi/block-core.json
View File

@ -2589,27 +2589,6 @@
'*timeout': 'int' } } '*timeout': 'int' } }
##
# @RbdAuthSupport:
#
# An enumeration of RBD auth support
#
# Since: 2.9
##
{ 'enum': 'RbdAuthSupport',
'data': [ 'cephx', 'none' ] }
##
# @RbdAuthMethod:
#
# An enumeration of rados auth_supported types
#
# Since: 2.9
##
{ 'struct': 'RbdAuthMethod',
'data': { 'auth': 'RbdAuthSupport' } }
## ##
# @BlockdevOptionsRbd: # @BlockdevOptionsRbd:
# #
@ -2628,11 +2607,6 @@
# @server: Monitor host address and port. This maps # @server: Monitor host address and port. This maps
# to the "mon_host" Ceph option. # to the "mon_host" Ceph option.
# #
# @auth-supported: Authentication supported.
#
# @password-secret: The ID of a QCryptoSecret object providing
# the password for the login.
#
# Since: 2.9 # Since: 2.9
## ##
{ 'struct': 'BlockdevOptionsRbd', { 'struct': 'BlockdevOptionsRbd',
@ -2641,9 +2615,7 @@
'*conf': 'str', '*conf': 'str',
'*snapshot': 'str', '*snapshot': 'str',
'*user': 'str', '*user': 'str',
'*server': ['InetSocketAddress'], '*server': ['InetSocketAddressBase'] } }
'*auth-supported': ['RbdAuthMethod'],
'*password-secret': 'str' } }
## ##
# @BlockdevOptionsSheepdog: # @BlockdevOptionsSheepdog: