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

QAPI patches patches for 2022-12-14 

-----BEGIN PGP SIGNATURE-----
 
 iQJGBAABCAAwFiEENUvIs9frKmtoZ05fOHC0AOuRhlMFAmOaIJoSHGFybWJydUBy
 ZWRoYXQuY29tAAoJEDhwtADrkYZTViMP/228DvzS8KBbEFUoCRbgxpnx2zk+05lk
 4TpbVohS3k25bgT86PR8d4PgVxItrKjXmx7v4ubm4hEtPk5YC/PADWwyZfJKzrst
 ogvGVIl++ccR1S0REonlSCmAxxUH6V2gYBE1XRs0vYRWGZefOqyINJ7i9W9FUhv8
 27V26dNtFel/z6aqPrRn2PXT+Y50DfLTAg+A+KpG6GdNR6zeAxGX6DCegWeZwZW4
 Kod3TfC6ZvYKxGhl46qpQwBvYUBCtO5ffxrbRLbmcKMYDMyIO7sfMQTQWBJ8pgwj
 AkiIjV/J2cPuHGyPDOFjC/Q6kaEz0L+wITPodflLyX+qYJGpr4q6L82fpZD7piV7
 9KoEppocdcJZxI/qrDwk03UH0UavPoqnCgpCzZ6+zOPhoUM8fP6qhPdSNxP2TkJz
 YstjWdWd39Nd5YnKMz6rRwBXuXSx4RiNFiBjnLahNZ0LkdFlWV5D54/7q1/YXoGK
 jnmcbmhyaVPmgCBBOEdHgzafP71qRQJqCnQeX11WJyA5bCb09sQTDXHJnhx0FDfz
 Zxgw+8Mc98fDQm5vx0t4zQQJZqiqEoIKxNKdgMn+JI61Wu0i8XsgrDnjIPy13EfI
 AuCmiCi9HcU5Jde823tF0kRl4XL1hp2AylTJyv3qwqlbUyEyKh0G6Aepfp4axguI
 HAsQ2UiVnjj8
 =fMjR
 -----END PGP SIGNATURE-----

Merge tag 'pull-qapi-2022-12-14-v2' of https://repo.or.cz/qemu/armbru into staging

QAPI patches patches for 2022-12-14

# gpg: Signature made Wed 14 Dec 2022 19:14:34 GMT
# gpg:                using RSA key 354BC8B3D7EB2A6B68674E5F3870B400EB918653
# gpg:                issuer "armbru@redhat.com"
# gpg: Good signature from "Markus Armbruster <armbru@redhat.com>" [full]
# gpg:                 aka "Markus Armbruster <armbru@pond.sub.org>" [full]
# Primary key fingerprint: 354B C8B3 D7EB 2A6B 6867  4E5F 3870 B400 EB91 8653

* tag 'pull-qapi-2022-12-14-v2' of https://repo.or.cz/qemu/armbru: (30 commits)
  qapi: Drop temporary logic to support conversion step by step
  qapi qga: Elide redundant has_FOO in generated C
  qapi virtio: Elide redundant has_FOO in generated C
  qapi ui: Elide redundant has_FOO in generated C
  qapi transaction: Elide redundant has_FOO in generated C
  qapi tpm: Elide redundant has_FOO in generated C
  qapi stats: Elide redundant has_FOO in generated C
  qapi run-state: Elide redundant has_FOO in generated C
  qapi rocker: Elide redundant has_FOO in generated C
  qapi replay: Elide redundant has_FOO in generated C
  qapi qdev qom: Elide redundant has_FOO in generated C
  qapi pci: Elide redundant has_FOO in generated C
  qapi net: Elide redundant has_FOO in generated C
  qapi misc: Elide redundant has_FOO in generated C
  qapi migration: Elide redundant has_FOO in generated C
  qapi machine: Elide redundant has_FOO in generated C
  qapi job: Elide redundant has_FOO in generated C
  qapi dump: Elide redundant has_FOO in generated C
  qapi crypto: Elide redundant has_FOO in generated C
  qapi chardev: Elide redundant has_FOO in generated C
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2022-12-14 22:42:13 +00:00
parent 5204b499a6 5efb40d657
commit ae2b87341b
107 changed files with 511 additions and 760 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
audio/alsaaudio.c
View File

@ -449,7 +449,7 @@ static int alsa_open(bool in, struct alsa_params_req *req,
snd_pcm_hw_params_t *hw_params; snd_pcm_hw_params_t *hw_params;
int err; int err;
unsigned int freq, nchannels; unsigned int freq, nchannels;
const char *pcm_name = apdo->has_dev ? apdo->dev : "default"; const char *pcm_name = apdo->dev ?: "default";
snd_pcm_uframes_t obt_buffer_size; snd_pcm_uframes_t obt_buffer_size;
const char *typ = in ? "ADC" : "DAC"; const char *typ = in ? "ADC" : "DAC";
snd_pcm_format_t obtfmt; snd_pcm_format_t obtfmt;

6
audio/audio.c
View File

@ -2035,15 +2035,13 @@ void audio_create_pdos(Audiodev *dev)
switch (dev->driver) { switch (dev->driver) {
#define CASE(DRIVER, driver, pdo_name) \ #define CASE(DRIVER, driver, pdo_name) \
case AUDIODEV_DRIVER_##DRIVER: \ case AUDIODEV_DRIVER_##DRIVER: \
if (!dev->u.driver.has_in) { \ if (!dev->u.driver.in) { \
dev->u.driver.in = g_malloc0( \ dev->u.driver.in = g_malloc0( \
sizeof(Audiodev##pdo_name##PerDirectionOptions)); \ sizeof(Audiodev##pdo_name##PerDirectionOptions)); \
dev->u.driver.has_in = true; \
} \ } \
if (!dev->u.driver.has_out) { \ if (!dev->u.driver.out) { \
dev->u.driver.out = g_malloc0( \ dev->u.driver.out = g_malloc0( \
sizeof(Audiodev##pdo_name##PerDirectionOptions)); \ sizeof(Audiodev##pdo_name##PerDirectionOptions)); \
dev->u.driver.has_out = true; \
} \ } \
break break

17
audio/audio_legacy.c
View File

@ -62,15 +62,12 @@ static void get_int(const char *env, uint32_t *dst, bool *has_dst)
} }
} }
static void get_str(const char *env, char **dst, bool *has_dst) static void get_str(const char *env, char **dst)
{ {
const char *val = getenv(env); const char *val = getenv(env);
if (val) { if (val) {
if (*has_dst) { g_free(*dst);
g_free(*dst);
}
*dst = g_strdup(val); *dst = g_strdup(val);
*has_dst = true;
} }
} }
@ -169,7 +166,7 @@ static void handle_alsa_per_direction(
get_bool(buf, &apdo->try_poll, &apdo->has_try_poll); get_bool(buf, &apdo->try_poll, &apdo->has_try_poll);
strcpy(buf + len, "DEV"); strcpy(buf + len, "DEV");
get_str(buf, &apdo->dev, &apdo->has_dev); get_str(buf, &apdo->dev);
strcpy(buf + len, "SIZE_IN_USEC"); strcpy(buf + len, "SIZE_IN_USEC");
get_bool(buf, &size_in_usecs, &dummy); get_bool(buf, &size_in_usecs, &dummy);
@ -235,7 +232,7 @@ static void handle_oss_per_direction(
const char *dev_env) const char *dev_env)
{ {
get_bool(try_poll_env, &opdo->try_poll, &opdo->has_try_poll); get_bool(try_poll_env, &opdo->try_poll, &opdo->has_try_poll);
get_str(dev_env, &opdo->dev, &opdo->has_dev); get_str(dev_env, &opdo->dev);
get_bytes_to_usecs("QEMU_OSS_FRAGSIZE", get_bytes_to_usecs("QEMU_OSS_FRAGSIZE",
&opdo->buffer_length, &opdo->has_buffer_length, &opdo->buffer_length, &opdo->has_buffer_length,
@ -261,7 +258,7 @@ static void handle_oss(Audiodev *dev)
static void handle_pa_per_direction( static void handle_pa_per_direction(
AudiodevPaPerDirectionOptions *ppdo, const char *env) AudiodevPaPerDirectionOptions *ppdo, const char *env)
{ {
get_str(env, &ppdo->name, &ppdo->has_name); get_str(env, &ppdo->name);
} }
static void handle_pa(Audiodev *dev) static void handle_pa(Audiodev *dev)
@ -278,7 +275,7 @@ static void handle_pa(Audiodev *dev)
&dev->u.pa.out->has_buffer_length, &dev->u.pa.out->has_buffer_length,
qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.out)); qapi_AudiodevPaPerDirectionOptions_base(dev->u.pa.out));
get_str("QEMU_PA_SERVER", &dev->u.pa.server, &dev->u.pa.has_server); get_str("QEMU_PA_SERVER", &dev->u.pa.server);
} }
/* SDL */ /* SDL */
@ -299,7 +296,7 @@ static void handle_wav(Audiodev *dev)
&dev->u.wav.out->has_format); &dev->u.wav.out->has_format);
get_int("QEMU_WAV_DAC_FIXED_CHANNELS", get_int("QEMU_WAV_DAC_FIXED_CHANNELS",
&dev->u.wav.out->channels, &dev->u.wav.out->has_channels); &dev->u.wav.out->channels, &dev->u.wav.out->has_channels);
get_str("QEMU_WAV_PATH", &dev->u.wav.path, &dev->u.wav.has_path); get_str("QEMU_WAV_PATH", &dev->u.wav.path);
} }
/* general */ /* general */

8
audio/ossaudio.c
View File

@ -252,7 +252,7 @@ static int oss_open(int in, struct oss_params *req, audsettings *as,
audio_buf_info abinfo; audio_buf_info abinfo;
int fmt, freq, nchannels; int fmt, freq, nchannels;
int setfragment = 1; int setfragment = 1;
const char *dspname = opdo->has_dev ? opdo->dev : "/dev/dsp"; const char *dspname = opdo->dev ?: "/dev/dsp";
const char *typ = in ? "ADC" : "DAC"; const char *typ = in ? "ADC" : "DAC";
#ifdef USE_DSP_POLICY #ifdef USE_DSP_POLICY
int policy = oopts->has_dsp_policy ? oopts->dsp_policy : 5; int policy = oopts->has_dsp_policy ? oopts->dsp_policy : 5;
@ -745,10 +745,8 @@ static void *oss_audio_init(Audiodev *dev)
oss_init_per_direction(oopts->in); oss_init_per_direction(oopts->in);
oss_init_per_direction(oopts->out); oss_init_per_direction(oopts->out);
if (access(oopts->in->has_dev ? oopts->in->dev : "/dev/dsp", if (access(oopts->in->dev ?: "/dev/dsp", R_OK | W_OK) < 0 ||
R_OK | W_OK) < 0 || access(oopts->out->dev ?: "/dev/dsp", R_OK | W_OK) < 0) {
access(oopts->out->has_dev ? oopts->out->dev : "/dev/dsp",
R_OK | W_OK) < 0) {
return NULL; return NULL;
} }
return dev; return dev;

12
audio/paaudio.c
View File

@ -536,9 +536,9 @@ static int qpa_init_out(HWVoiceOut *hw, struct audsettings *as,
pa->stream = qpa_simple_new ( pa->stream = qpa_simple_new (
c, c,
ppdo->has_stream_name ? ppdo->stream_name : g->dev->id, ppdo->stream_name ?: g->dev->id,
PA_STREAM_PLAYBACK, PA_STREAM_PLAYBACK,
ppdo->has_name ? ppdo->name : NULL, ppdo->name,
&ss, &ss,
&ba, /* buffering attributes */ &ba, /* buffering attributes */
&error &error
@ -585,9 +585,9 @@ static int qpa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
pa->stream = qpa_simple_new ( pa->stream = qpa_simple_new (
c, c,
ppdo->has_stream_name ? ppdo->stream_name : g->dev->id, ppdo->stream_name ?: g->dev->id,
PA_STREAM_RECORD, PA_STREAM_RECORD,
ppdo->has_name ? ppdo->name : NULL, ppdo->name,
&ss, &ss,
&ba, /* buffering attributes */ &ba, /* buffering attributes */
&error &error
@ -827,7 +827,7 @@ static void *qpa_audio_init(Audiodev *dev)
assert(dev->driver == AUDIODEV_DRIVER_PA); assert(dev->driver == AUDIODEV_DRIVER_PA);
if (!popts->has_server) { if (!popts->server) {
char pidfile[64]; char pidfile[64];
char *runtime; char *runtime;
struct stat st; struct stat st;
@ -850,7 +850,7 @@ static void *qpa_audio_init(Audiodev *dev)
} }
g = g_new0(paaudio, 1); g = g_new0(paaudio, 1);
server = popts->has_server ? popts->server : NULL; server = popts->server;
g->dev = dev; g->dev = dev;

2
audio/sndioaudio.c
View File

@ -333,7 +333,7 @@ static int sndio_init(SndioVoice *self,
unsigned int nch; unsigned int nch;
int i, nfds; int i, nfds;
dev_name = opts->has_dev ? opts->dev : SIO_DEVANY; dev_name = opts->dev ?: SIO_DEVANY;
latency = opts->has_latency ? opts->latency : SNDIO_LATENCY_US; latency = opts->has_latency ? opts->latency : SNDIO_LATENCY_US;
/* open the device in non-blocking mode */ /* open the device in non-blocking mode */

2
audio/wavaudio.c
View File

@ -78,7 +78,7 @@ static int wav_init_out(HWVoiceOut *hw, struct audsettings *as,
Audiodev *dev = drv_opaque; Audiodev *dev = drv_opaque;
AudiodevWavOptions *wopts = &dev->u.wav; AudiodevWavOptions *wopts = &dev->u.wav;
struct audsettings wav_as = audiodev_to_audsettings(dev->u.wav.out); struct audsettings wav_as = audiodev_to_audsettings(dev->u.wav.out);
const char *wav_path = wopts->has_path ? wopts->path : "qemu.wav"; const char *wav_path = wopts->path ?: "qemu.wav";
stereo = wav_as.nchannels == 2; stereo = wav_as.nchannels == 2;
switch (wav_as.fmt) { switch (wav_as.fmt) {

2
backends/tpm/tpm_passthrough.c
View File

@ -259,12 +259,10 @@ tpm_passthrough_handle_device_opts(TPMPassthruState *tpm_pt, QemuOpts *opts)
value = qemu_opt_get(opts, "cancel-path"); value = qemu_opt_get(opts, "cancel-path");
if (value) { if (value) {
tpm_pt->options->cancel_path = g_strdup(value); tpm_pt->options->cancel_path = g_strdup(value);
tpm_pt->options->has_cancel_path = true;
} }
value = qemu_opt_get(opts, "path"); value = qemu_opt_get(opts, "path");
if (value) { if (value) {
tpm_pt->options->has_path = true;
tpm_pt->options->path = g_strdup(value); tpm_pt->options->path = g_strdup(value);
} }

2
block/block-backend.c
View File

@ -1860,7 +1860,7 @@ static void send_qmp_error_event(BlockBackend *blk,
BlockDriverState *bs = blk_bs(blk); BlockDriverState *bs = blk_bs(blk);
optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE; optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
qapi_event_send_block_io_error(blk_name(blk), !!bs, qapi_event_send_block_io_error(blk_name(blk),
bs ? bdrv_get_node_name(bs) : NULL, optype, bs ? bdrv_get_node_name(bs) : NULL, optype,
action, blk_iostatus_is_enabled(blk), action, blk_iostatus_is_enabled(blk),
error == ENOSPC, strerror(error)); error == ENOSPC, strerror(error));

2
block/copy-before-write.c
View File

@ -432,7 +432,7 @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
return -EINVAL; return -EINVAL;
} }
if (opts->has_bitmap) { if (opts->bitmap) {
bitmap = block_dirty_bitmap_lookup(opts->bitmap->node, bitmap = block_dirty_bitmap_lookup(opts->bitmap->node,
opts->bitmap->name, NULL, errp); opts->bitmap->name, NULL, errp);
if (!bitmap) { if (!bitmap) {

1
block/dirty-bitmap.c
View File

@ -541,7 +541,6 @@ BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
info->count = bdrv_get_dirty_count(bm); info->count = bdrv_get_dirty_count(bm);
info->granularity = bdrv_dirty_bitmap_granularity(bm); info->granularity = bdrv_dirty_bitmap_granularity(bm);
info->has_name = !!bm->name;
info->name = g_strdup(bm->name); info->name = g_strdup(bm->name);
info->recording = bdrv_dirty_bitmap_recording(bm); info->recording = bdrv_dirty_bitmap_recording(bm);
info->busy = bdrv_dirty_bitmap_busy(bm); info->busy = bdrv_dirty_bitmap_busy(bm);

2
block/export/export.c
View File

@ -114,7 +114,7 @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
ctx = bdrv_get_aio_context(bs); ctx = bdrv_get_aio_context(bs);
aio_context_acquire(ctx); aio_context_acquire(ctx);
if (export->has_iothread) { if (export->iothread) {
IOThread *iothread; IOThread *iothread;
AioContext *new_ctx; AioContext *new_ctx;
Error **set_context_errp; Error **set_context_errp;

3
block/export/vduse-blk.c
View File

@ -265,8 +265,7 @@ static int vduse_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
} }
vblk_exp->num_queues = num_queues; vblk_exp->num_queues = num_queues;
vblk_exp->handler.blk = exp->blk; vblk_exp->handler.blk = exp->blk;
vblk_exp->handler.serial = g_strdup(vblk_opts->has_serial ? vblk_exp->handler.serial = g_strdup(vblk_opts->serial ?: "");
vblk_opts->serial : "");
vblk_exp->handler.logical_block_size = logical_block_size; vblk_exp->handler.logical_block_size = logical_block_size;
vblk_exp->handler.writable = opts->writable; vblk_exp->handler.writable = opts->writable;

3
block/gluster.c
View File

@ -830,7 +830,6 @@ static int qemu_gluster_open(BlockDriverState *bs, QDict *options,
s->logfile = g_strdup(logfile ? logfile : GLUSTER_LOGFILE_DEFAULT); s->logfile = g_strdup(logfile ? logfile : GLUSTER_LOGFILE_DEFAULT);
gconf->logfile = g_strdup(s->logfile); gconf->logfile = g_strdup(s->logfile);
gconf->has_logfile = true;
s->glfs = qemu_gluster_init(gconf, filename, options, errp); s->glfs = qemu_gluster_init(gconf, filename, options, errp);
if (!s->glfs) { if (!s->glfs) {
@ -917,7 +916,6 @@ static int qemu_gluster_reopen_prepare(BDRVReopenState *state,
gconf->debug = s->debug; gconf->debug = s->debug;
gconf->has_debug = true; gconf->has_debug = true;
gconf->logfile = g_strdup(s->logfile); gconf->logfile = g_strdup(s->logfile);
gconf->has_logfile = true;
/* /*
* If 'state->bs->exact_filename' is empty, 'state->options' should contain * If 'state->bs->exact_filename' is empty, 'state->options' should contain
@ -1162,7 +1160,6 @@ static int coroutine_fn qemu_gluster_co_create_opts(BlockDriver *drv,
if (!gconf->logfile) { if (!gconf->logfile) {
gconf->logfile = g_strdup(GLUSTER_LOGFILE_DEFAULT); gconf->logfile = g_strdup(GLUSTER_LOGFILE_DEFAULT);
} }
gconf->has_logfile = true;
ret = qemu_gluster_parse(gconf, filename, NULL, errp); ret = qemu_gluster_parse(gconf, filename, NULL, errp);
if (ret < 0) { if (ret < 0) {

48
block/monitor/block-hmp-cmds.c
View File

@ -241,7 +241,6 @@ void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
DriveMirror mirror = { DriveMirror mirror = {
.device = (char *)qdict_get_str(qdict, "device"), .device = (char *)qdict_get_str(qdict, "device"),
.target = (char *)filename, .target = (char *)filename,
.has_format = !!format,
.format = (char *)format, .format = (char *)format,
.sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
.has_mode = true, .has_mode = true,
@ -270,7 +269,6 @@ void hmp_drive_backup(Monitor *mon, const QDict *qdict)
DriveBackup backup = { DriveBackup backup = {
.device = (char *)device, .device = (char *)device,
.target = (char *)filename, .target = (char *)filename,
.has_format = !!format,
.format = (char *)format, .format = (char *)format,
.sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP, .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
.has_mode = true, .has_mode = true,
@ -360,9 +358,7 @@ void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
} }
mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS; mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS;
qmp_blockdev_snapshot_sync(true, device, false, NULL, qmp_blockdev_snapshot_sync(device, NULL, filename, NULL, format,
filename, false, NULL,
!!format, format,
true, mode, &err); true, mode, &err);
end: end:
hmp_handle_error(mon, err); hmp_handle_error(mon, err);
@ -385,8 +381,7 @@ void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
const char *id = qdict_get_try_str(qdict, "id"); const char *id = qdict_get_try_str(qdict, "id");
Error *err = NULL; Error *err = NULL;
qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id, qmp_blockdev_snapshot_delete_internal_sync(device, id, name, &err);
true, name, &err);
hmp_handle_error(mon, err); hmp_handle_error(mon, err);
} }
@ -427,7 +422,7 @@ void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
block_list = qmp_query_block(NULL); block_list = qmp_query_block(NULL);
for (info = block_list; info; info = info->next) { for (info = block_list; info; info = info->next) {
if (!info->value->has_inserted) { if (!info->value->inserted) {
continue; continue;
} }
@ -460,7 +455,6 @@ void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
NbdServerAddOptions export = { NbdServerAddOptions export = {
.device = (char *) device, .device = (char *) device,
.has_name = !!name,
.name = (char *) name, .name = (char *) name,
.has_writable = true, .has_writable = true,
.writable = writable, .writable = writable,
@ -495,7 +489,7 @@ void coroutine_fn hmp_block_resize(Monitor *mon, const QDict *qdict)
int64_t size = qdict_get_int(qdict, "size"); int64_t size = qdict_get_int(qdict, "size");
Error *err = NULL; Error *err = NULL;
qmp_block_resize(true, device, false, NULL, size, &err); qmp_block_resize(device, NULL, size, &err);
hmp_handle_error(mon, err); hmp_handle_error(mon, err);
} }
@ -506,11 +500,10 @@ void hmp_block_stream(Monitor *mon, const QDict *qdict)
const char *base = qdict_get_try_str(qdict, "base"); const char *base = qdict_get_try_str(qdict, "base");
int64_t speed = qdict_get_try_int(qdict, "speed", 0); int64_t speed = qdict_get_try_int(qdict, "speed", 0);
qmp_block_stream(true, device, device, base != NULL, base, false, NULL, qmp_block_stream(device, device, base, NULL, NULL, NULL,
false, NULL, false, NULL, qdict_haskey(qdict, "speed"), speed,
qdict_haskey(qdict, "speed"), speed, true, true, BLOCKDEV_ON_ERROR_REPORT, NULL,
BLOCKDEV_ON_ERROR_REPORT, false, NULL, false, false, false, false, false, false, false, &error);
false, &error);
hmp_handle_error(mon, error); hmp_handle_error(mon, error);
} }
@ -534,10 +527,8 @@ void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
* version has only one, so we must decide which one to pass. * version has only one, so we must decide which one to pass.
*/ */
if (blk_by_name(device)) { if (blk_by_name(device)) {
throttle.has_device = true;
throttle.device = device; throttle.device = device;
} else { } else {
throttle.has_id = true;
throttle.id = device; throttle.id = device;
} }
@ -551,7 +542,7 @@ void hmp_eject(Monitor *mon, const QDict *qdict)
const char *device = qdict_get_str(qdict, "device"); const char *device = qdict_get_str(qdict, "device");
Error *err = NULL; Error *err = NULL;
qmp_eject(true, device, false, NULL, true, force, &err); qmp_eject(device, NULL, true, force, &err);
hmp_handle_error(mon, err); hmp_handle_error(mon, err);
} }
@ -635,18 +626,18 @@ static void print_block_info(Monitor *mon, BlockInfo *info,
{ {
ImageInfo *image_info; ImageInfo *image_info;
assert(!info || !info->has_inserted || info->inserted == inserted); assert(!info || !info->inserted || info->inserted == inserted);
if (info && *info->device) { if (info && *info->device) {
monitor_puts(mon, info->device); monitor_puts(mon, info->device);
if (inserted && inserted->has_node_name) { if (inserted && inserted->node_name) {
monitor_printf(mon, " (%s)", inserted->node_name); monitor_printf(mon, " (%s)", inserted->node_name);
} }
} else { } else {
assert(info || inserted); assert(info || inserted);
monitor_puts(mon, monitor_puts(mon,
inserted && inserted->has_node_name ? inserted->node_name inserted && inserted->node_name ? inserted->node_name
: info && info->has_qdev ? info->qdev : info && info->qdev ? info->qdev
: "<anonymous>"); : "<anonymous>");
} }
@ -661,7 +652,7 @@ static void print_block_info(Monitor *mon, BlockInfo *info,
} }
if (info) { if (info) {
if (info->has_qdev) { if (info->qdev) {
monitor_printf(mon, " Attached to: %s\n", info->qdev); monitor_printf(mon, " Attached to: %s\n", info->qdev);
} }
if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) { if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) {
@ -686,7 +677,7 @@ static void print_block_info(Monitor *mon, BlockInfo *info,
inserted->cache->direct ? ", direct" : "", inserted->cache->direct ? ", direct" : "",
inserted->cache->no_flush ? ", ignore flushes" : ""); inserted->cache->no_flush ? ", ignore flushes" : "");
if (inserted->has_backing_file) { if (inserted->backing_file) {
monitor_printf(mon, monitor_printf(mon,
" Backing file: %s " " Backing file: %s "
"(chain depth: %" PRId64 ")\n", "(chain depth: %" PRId64 ")\n",
@ -735,7 +726,7 @@ static void print_block_info(Monitor *mon, BlockInfo *info,
image_info = inserted->image; image_info = inserted->image;
while (1) { while (1) {
bdrv_image_info_dump(image_info); bdrv_image_info_dump(image_info);
if (image_info->has_backing_image) { if (image_info->backing_image) {
image_info = image_info->backing_image; image_info = image_info->backing_image;
} else { } else {
break; break;
@ -769,8 +760,7 @@ void hmp_info_block(Monitor *mon, const QDict *qdict)
monitor_printf(mon, "\n"); monitor_printf(mon, "\n");
} }
print_block_info(mon, info->value, info->value->has_inserted print_block_info(mon, info->value, info->value->inserted,
? info->value->inserted : NULL,
verbose); verbose);
printed = true; printed = true;
} }
@ -784,7 +774,7 @@ void hmp_info_block(Monitor *mon, const QDict *qdict)
/* Print node information */ /* Print node information */
blockdev_list = qmp_query_named_block_nodes(false, false, NULL); blockdev_list = qmp_query_named_block_nodes(false, false, NULL);
for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) { for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {
assert(blockdev->value->has_node_name); assert(blockdev->value->node_name);
if (device && strcmp(device, blockdev->value->node_name)) { if (device && strcmp(device, blockdev->value->node_name)) {
continue; continue;
} }
@ -805,7 +795,7 @@ void hmp_info_blockstats(Monitor *mon, const QDict *qdict)
stats_list = qmp_query_blockstats(false, false, NULL); stats_list = qmp_query_blockstats(false, false, NULL);
for (stats = stats_list; stats; stats = stats->next) { for (stats = stats_list; stats; stats = stats->next) {
if (!stats->value->has_device) { if (!stats->value->device) {
continue; continue;
} }

73
block/qapi-sysemu.c
View File

@ -116,8 +116,8 @@ static int do_open_tray(const char *blk_name, const char *qdev_id,
return 0; return 0;
} }
void qmp_blockdev_open_tray(bool has_device, const char *device, void qmp_blockdev_open_tray(const char *device,
bool has_id, const char *id, const char *id,
bool has_force, bool force, bool has_force, bool force,
Error **errp) Error **errp)
{ {
@ -127,9 +127,7 @@ void qmp_blockdev_open_tray(bool has_device, const char *device,
if (!has_force) { if (!has_force) {
force = false; force = false;
} }
rc = do_open_tray(has_device ? device : NULL, rc = do_open_tray(device, id, force, &local_err);
has_id ? id : NULL,
force, &local_err);
if (rc && rc != -ENOSYS && rc != -EINPROGRESS) { if (rc && rc != -ENOSYS && rc != -EINPROGRESS) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
@ -137,16 +135,13 @@ void qmp_blockdev_open_tray(bool has_device, const char *device,
error_free(local_err); error_free(local_err);
} }
void qmp_blockdev_close_tray(bool has_device, const char *device, void qmp_blockdev_close_tray(const char *device,
bool has_id, const char *id, const char *id,
Error **errp) Error **errp)
{ {
BlockBackend *blk; BlockBackend *blk;
Error *local_err = NULL; Error *local_err = NULL;
device = has_device ? device : NULL;
id = has_id ? id : NULL;
blk = qmp_get_blk(device, id, errp); blk = qmp_get_blk(device, id, errp);
if (!blk) { if (!blk) {
return; return;
@ -173,17 +168,14 @@ void qmp_blockdev_close_tray(bool has_device, const char *device,
} }
} }
static void blockdev_remove_medium(bool has_device, const char *device, static void blockdev_remove_medium(const char *device, const char *id,
bool has_id, const char *id, Error **errp) Error **errp)
{ {
BlockBackend *blk; BlockBackend *blk;
BlockDriverState *bs; BlockDriverState *bs;
AioContext *aio_context; AioContext *aio_context;
bool has_attached_device; bool has_attached_device;
device = has_device ? device : NULL;
id = has_id ? id : NULL;
blk = qmp_get_blk(device, id, errp); blk = qmp_get_blk(device, id, errp);
if (!blk) { if (!blk) {
return; return;
@ -232,7 +224,7 @@ out:
void qmp_blockdev_remove_medium(const char *id, Error **errp) void qmp_blockdev_remove_medium(const char *id, Error **errp)
{ {
blockdev_remove_medium(false, NULL, true, id, errp); blockdev_remove_medium(NULL, id, errp);
} }
static void qmp_blockdev_insert_anon_medium(BlockBackend *blk, static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
@ -280,16 +272,13 @@ static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
} }
} }
static void blockdev_insert_medium(bool has_device, const char *device, static void blockdev_insert_medium(const char *device, const char *id,
bool has_id, const char *id,
const char *node_name, Error **errp) const char *node_name, Error **errp)
{ {
BlockBackend *blk; BlockBackend *blk;
BlockDriverState *bs; BlockDriverState *bs;
blk = qmp_get_blk(has_device ? device : NULL, blk = qmp_get_blk(device, id, errp);
has_id ? id : NULL,
errp);
if (!blk) { if (!blk) {
return; return;
} }
@ -311,13 +300,13 @@ static void blockdev_insert_medium(bool has_device, const char *device,
void qmp_blockdev_insert_medium(const char *id, const char *node_name, void qmp_blockdev_insert_medium(const char *id, const char *node_name,
Error **errp) Error **errp)
{ {
blockdev_insert_medium(false, NULL, true, id, node_name, errp); blockdev_insert_medium(NULL, id, node_name, errp);
} }
void qmp_blockdev_change_medium(bool has_device, const char *device, void qmp_blockdev_change_medium(const char *device,
bool has_id, const char *id, const char *id,
const char *filename, const char *filename,
bool has_format, const char *format, const char *format,
bool has_force, bool force, bool has_force, bool force,
bool has_read_only, bool has_read_only,
BlockdevChangeReadOnlyMode read_only, BlockdevChangeReadOnlyMode read_only,
@ -331,9 +320,7 @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
QDict *options = NULL; QDict *options = NULL;
Error *err = NULL; Error *err = NULL;
blk = qmp_get_blk(has_device ? device : NULL, blk = qmp_get_blk(device, id, errp);
has_id ? id : NULL,
errp);
if (!blk) { if (!blk) {
goto fail; goto fail;
} }
@ -370,7 +357,7 @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
detect_zeroes = blk_get_detect_zeroes_from_root_state(blk); detect_zeroes = blk_get_detect_zeroes_from_root_state(blk);
qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off"); qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off");
if (has_format) { if (format) {
qdict_put_str(options, "driver", format); qdict_put_str(options, "driver", format);
} }
@ -379,9 +366,7 @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
goto fail; goto fail;
} }
rc = do_open_tray(has_device ? device : NULL, rc = do_open_tray(device, id, force, &err);
has_id ? id : NULL,
force, &err);
if (rc && rc != -ENOSYS) { if (rc && rc != -ENOSYS) {
error_propagate(errp, err); error_propagate(errp, err);
goto fail; goto fail;
@ -389,7 +374,7 @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
error_free(err); error_free(err);
err = NULL; err = NULL;
blockdev_remove_medium(has_device, device, has_id, id, &err); blockdev_remove_medium(device, id, &err);
if (err) { if (err) {
error_propagate(errp, err); error_propagate(errp, err);
goto fail; goto fail;
@ -401,7 +386,7 @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
goto fail; goto fail;
} }
qmp_blockdev_close_tray(has_device, device, has_id, id, errp); qmp_blockdev_close_tray(device, id, errp);
fail: fail:
/* If the medium has been inserted, the device has its own reference, so /* If the medium has been inserted, the device has its own reference, so
@ -410,8 +395,7 @@ fail:
bdrv_unref(medium_bs); bdrv_unref(medium_bs);
} }
void qmp_eject(bool has_device, const char *device, void qmp_eject(const char *device, const char *id,
bool has_id, const char *id,
bool has_force, bool force, Error **errp) bool has_force, bool force, Error **errp)
{ {
Error *local_err = NULL; Error *local_err = NULL;
@ -421,16 +405,14 @@ void qmp_eject(bool has_device, const char *device,
force = false; force = false;
} }
rc = do_open_tray(has_device ? device : NULL, rc = do_open_tray(device, id, force, &local_err);
has_id ? id : NULL,
force, &local_err);
if (rc && rc != -ENOSYS) { if (rc && rc != -ENOSYS) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
} }
error_free(local_err); error_free(local_err);
blockdev_remove_medium(has_device, device, has_id, id, errp); blockdev_remove_medium(device, id, errp);
} }
/* throttling disk I/O limits */ /* throttling disk I/O limits */
@ -441,9 +423,7 @@ void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp)
BlockBackend *blk; BlockBackend *blk;
AioContext *aio_context; AioContext *aio_context;
blk = qmp_get_blk(arg->has_device ? arg->device : NULL, blk = qmp_get_blk(arg->device, arg->id, errp);
arg->has_id ? arg->id : NULL,
errp);
if (!blk) { if (!blk) {
return; return;
} }
@ -516,11 +496,8 @@ void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp)
/* Enable I/O limits if they're not enabled yet, otherwise /* Enable I/O limits if they're not enabled yet, otherwise
* just update the throttling group. */ * just update the throttling group. */
if (!blk_get_public(blk)->throttle_group_member.throttle_state) { if (!blk_get_public(blk)->throttle_group_member.throttle_state) {
blk_io_limits_enable(blk, blk_io_limits_enable(blk, arg->group ?: arg->device ?: arg->id);
arg->has_group ? arg->group : } else if (arg->group) {
arg->has_device ? arg->device :
arg->id);
} else if (arg->has_group) {
blk_io_limits_update_group(blk, arg->group); blk_io_limits_update_group(blk, arg->group);
} }
/* Set the new throttling configuration */ /* Set the new throttling configuration */

62
block/qapi.c
View File

@ -71,13 +71,11 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
}; };
if (bs->node_name[0]) { if (bs->node_name[0]) {
info->has_node_name = true;
info->node_name = g_strdup(bs->node_name); info->node_name = g_strdup(bs->node_name);
} }
backing = bdrv_cow_bs(bs); backing = bdrv_cow_bs(bs);
if (backing) { if (backing) {
info->has_backing_file = true;
info->backing_file = g_strdup(backing->filename); info->backing_file = g_strdup(backing->filename);
} }
@ -139,7 +137,6 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
info->has_iops_size = cfg.op_size; info->has_iops_size = cfg.op_size;
info->iops_size = cfg.op_size; info->iops_size = cfg.op_size;
info->has_group = true;
info->group = info->group =
g_strdup(throttle_group_get_name(&blkp->throttle_group_member)); g_strdup(throttle_group_get_name(&blkp->throttle_group_member));
} }
@ -170,7 +167,6 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
*/ */
info->backing_file_depth++; info->backing_file_depth++;
bs0 = bdrv_filter_or_cow_bs(bs0); bs0 = bdrv_filter_or_cow_bs(bs0);
(*p_image_info)->has_backing_image = true;
p_image_info = &((*p_image_info)->backing_image); p_image_info = &((*p_image_info)->backing_image);
} else { } else {
break; break;
@ -301,26 +297,21 @@ void bdrv_query_image_info(BlockDriverState *bs,
qapi_free_ImageInfo(info); qapi_free_ImageInfo(info);
goto out; goto out;
} }
info->has_format_specific = info->format_specific != NULL;
backing_filename = bs->backing_file; backing_filename = bs->backing_file;
if (backing_filename[0] != '\0') { if (backing_filename[0] != '\0') {
char *backing_filename2; char *backing_filename2;
info->backing_filename = g_strdup(backing_filename); info->backing_filename = g_strdup(backing_filename);
info->has_backing_filename = true;
backing_filename2 = bdrv_get_full_backing_filename(bs, NULL); backing_filename2 = bdrv_get_full_backing_filename(bs, NULL);
/* Always report the full_backing_filename if present, even if it's the /* Always report the full_backing_filename if present, even if it's the
* same as backing_filename. That they are same is useful info. */ * same as backing_filename. That they are same is useful info. */
if (backing_filename2) { if (backing_filename2) {
info->full_backing_filename = g_strdup(backing_filename2); info->full_backing_filename = g_strdup(backing_filename2);
info->has_full_backing_filename = true;
} }
if (bs->backing_format[0]) { if (bs->backing_format[0]) {
info->backing_filename_format = g_strdup(bs->backing_format); info->backing_filename_format = g_strdup(bs->backing_format);
info->has_backing_filename_format = true;
} }
g_free(backing_filename2); g_free(backing_filename2);
} }
@ -367,7 +358,6 @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,
qdev = blk_get_attached_dev_id(blk); qdev = blk_get_attached_dev_id(blk);
if (qdev && *qdev) { if (qdev && *qdev) {
info->has_qdev = true;
info->qdev = qdev; info->qdev = qdev;
} else { } else {
g_free(qdev); g_free(qdev);
@ -384,7 +374,6 @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,
} }
if (bs && bs->drv) { if (bs && bs->drv) {
info->has_inserted = true;
info->inserted = bdrv_block_device_info(blk, bs, false, errp); info->inserted = bdrv_block_device_info(blk, bs, false, errp);
if (info->inserted == NULL) { if (info->inserted == NULL) {
goto err; goto err;
@ -411,23 +400,26 @@ static uint64List *uint64_list(uint64_t *list, int size)
return out_list; return out_list;
} }
static void bdrv_latency_histogram_stats(BlockLatencyHistogram *hist, static BlockLatencyHistogramInfo *
bool *not_null, bdrv_latency_histogram_stats(BlockLatencyHistogram *hist)
BlockLatencyHistogramInfo **info)
{ {
*not_null = hist->bins != NULL; BlockLatencyHistogramInfo *info;
if (*not_null) {
*info = g_new0(BlockLatencyHistogramInfo, 1);
(*info)->boundaries = uint64_list(hist->boundaries, hist->nbins - 1); if (!hist->bins) {
(*info)->bins = uint64_list(hist->bins, hist->nbins); return NULL;
} }
info = g_new0(BlockLatencyHistogramInfo, 1);
info->boundaries = uint64_list(hist->boundaries, hist->nbins - 1);
info->bins = uint64_list(hist->bins, hist->nbins);
return info;
} }
static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk) static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
{ {
BlockAcctStats *stats = blk_get_stats(blk); BlockAcctStats *stats = blk_get_stats(blk);
BlockAcctTimedStats *ts = NULL; BlockAcctTimedStats *ts = NULL;
BlockLatencyHistogram *hgram;
ds->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ]; ds->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ];
ds->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE]; ds->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE];
@ -493,15 +485,13 @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
QAPI_LIST_PREPEND(ds->timed_stats, dev_stats); QAPI_LIST_PREPEND(ds->timed_stats, dev_stats);
} }
bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_READ], hgram = stats->latency_histogram;
&ds->has_rd_latency_histogram, ds->rd_latency_histogram
&ds->rd_latency_histogram); = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_READ]);
bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_WRITE], ds->wr_latency_histogram
&ds->has_wr_latency_histogram, = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_WRITE]);
&ds->wr_latency_histogram); ds->flush_latency_histogram
bdrv_latency_histogram_stats(&stats->latency_histogram[BLOCK_ACCT_FLUSH], = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_FLUSH]);
&ds->has_flush_latency_histogram,
&ds->flush_latency_histogram);
} }
static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs, static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs,
@ -526,16 +516,12 @@ static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs,
} }
if (bdrv_get_node_name(bs)[0]) { if (bdrv_get_node_name(bs)[0]) {
s->has_node_name = true;
s->node_name = g_strdup(bdrv_get_node_name(bs)); s->node_name = g_strdup(bdrv_get_node_name(bs));
} }
s->stats->wr_highest_offset = stat64_get(&bs->wr_highest_offset); s->stats->wr_highest_offset = stat64_get(&bs->wr_highest_offset);
s->driver_specific = bdrv_get_specific_stats(bs); s->driver_specific = bdrv_get_specific_stats(bs);
if (s->driver_specific) {
s->has_driver_specific = true;
}
parent_child = bdrv_primary_child(bs); parent_child = bdrv_primary_child(bs);
if (!parent_child || if (!parent_child ||
@ -564,7 +550,6 @@ static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs,
} }
} }
if (parent_child) { if (parent_child) {
s->has_parent = true;
s->parent = bdrv_query_bds_stats(parent_child->bs, blk_level); s->parent = bdrv_query_bds_stats(parent_child->bs, blk_level);
} }
@ -575,7 +560,6 @@ static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs,
* compatibility to when we put bs0->backing here, which might * compatibility to when we put bs0->backing here, which might
* be either) * be either)
*/ */
s->has_backing = true;
s->backing = bdrv_query_bds_stats(filter_or_cow_bs, blk_level); s->backing = bdrv_query_bds_stats(filter_or_cow_bs, blk_level);
} }
@ -640,12 +624,10 @@ BlockStatsList *qmp_query_blockstats(bool has_query_nodes,
aio_context_acquire(ctx); aio_context_acquire(ctx);
s = bdrv_query_bds_stats(blk_bs(blk), true); s = bdrv_query_bds_stats(blk_bs(blk), true);
s->has_device = true;
s->device = g_strdup(blk_name(blk)); s->device = g_strdup(blk_name(blk));
qdev = blk_get_attached_dev_id(blk); qdev = blk_get_attached_dev_id(blk);
if (qdev && *qdev) { if (qdev && *qdev) {
s->has_qdev = true;
s->qdev = qdev; s->qdev = qdev;
} else { } else {
g_free(qdev); g_free(qdev);
@ -822,16 +804,16 @@ void bdrv_image_info_dump(ImageInfo *info)
qemu_printf("cleanly shut down: no\n"); qemu_printf("cleanly shut down: no\n");
} }
if (info->has_backing_filename) { if (info->backing_filename) {
qemu_printf("backing file: %s", info->backing_filename); qemu_printf("backing file: %s", info->backing_filename);
if (!info->has_full_backing_filename) { if (!info->full_backing_filename) {
qemu_printf(" (cannot determine actual path)"); qemu_printf(" (cannot determine actual path)");
} else if (strcmp(info->backing_filename, } else if (strcmp(info->backing_filename,
info->full_backing_filename) != 0) { info->full_backing_filename) != 0) {
qemu_printf(" (actual path: %s)", info->full_backing_filename); qemu_printf(" (actual path: %s)", info->full_backing_filename);
} }
qemu_printf("\n"); qemu_printf("\n");
if (info->has_backing_filename_format) { if (info->backing_filename_format) {
qemu_printf("backing file format: %s\n", qemu_printf("backing file format: %s\n",
info->backing_filename_format); info->backing_filename_format);
} }
@ -865,7 +847,7 @@ void bdrv_image_info_dump(ImageInfo *info)
} }
} }
if (info->has_format_specific) { if (info->format_specific) {
qemu_printf("Format specific information:\n"); qemu_printf("Format specific information:\n");
bdrv_image_info_specific_dump(info->format_specific); bdrv_image_info_specific_dump(info->format_specific);
} }

10
block/qcow.c
View File

@ -825,7 +825,7 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
return -EINVAL; return -EINVAL;
} }
if (qcow_opts->has_encrypt && if (qcow_opts->encrypt &&
qcow_opts->encrypt->format != Q_CRYPTO_BLOCK_FORMAT_QCOW) qcow_opts->encrypt->format != Q_CRYPTO_BLOCK_FORMAT_QCOW)
{ {
error_setg(errp, "Unsupported encryption format"); error_setg(errp, "Unsupported encryption format");
@ -853,7 +853,7 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
header.size = cpu_to_be64(total_size); header.size = cpu_to_be64(total_size);
header_size = sizeof(header); header_size = sizeof(header);
backing_filename_len = 0; backing_filename_len = 0;
if (qcow_opts->has_backing_file) { if (qcow_opts->backing_file) {
if (strcmp(qcow_opts->backing_file, "fat:")) { if (strcmp(qcow_opts->backing_file, "fat:")) {
header.backing_file_offset = cpu_to_be64(header_size); header.backing_file_offset = cpu_to_be64(header_size);
backing_filename_len = strlen(qcow_opts->backing_file); backing_filename_len = strlen(qcow_opts->backing_file);
@ -861,7 +861,7 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
header_size += backing_filename_len; header_size += backing_filename_len;
} else { } else {
/* special backing file for vvfat */ /* special backing file for vvfat */
qcow_opts->has_backing_file = false; qcow_opts->backing_file = NULL;
} }
header.cluster_bits = 9; /* 512 byte cluster to avoid copying header.cluster_bits = 9; /* 512 byte cluster to avoid copying
unmodified sectors */ unmodified sectors */
@ -876,7 +876,7 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
header.l1_table_offset = cpu_to_be64(header_size); header.l1_table_offset = cpu_to_be64(header_size);
if (qcow_opts->has_encrypt) { if (qcow_opts->encrypt) {
header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES); header.crypt_method = cpu_to_be32(QCOW_CRYPT_AES);
crypto = qcrypto_block_create(qcow_opts->encrypt, "encrypt.", crypto = qcrypto_block_create(qcow_opts->encrypt, "encrypt.",
@ -895,7 +895,7 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
goto exit; goto exit;
} }
if (qcow_opts->has_backing_file) { if (qcow_opts->backing_file) {
ret = blk_co_pwrite(qcow_blk, sizeof(header), backing_filename_len, ret = blk_co_pwrite(qcow_blk, sizeof(header), backing_filename_len,
qcow_opts->backing_file, 0); qcow_opts->backing_file, 0);
if (ret < 0) { if (ret < 0) {

18
block/qcow2.c
View File

@ -3508,7 +3508,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
if (!qcow2_opts->has_preallocation) { if (!qcow2_opts->has_preallocation) {
qcow2_opts->preallocation = PREALLOC_MODE_OFF; qcow2_opts->preallocation = PREALLOC_MODE_OFF;
} }
if (qcow2_opts->has_backing_file && if (qcow2_opts->backing_file &&
qcow2_opts->preallocation != PREALLOC_MODE_OFF && qcow2_opts->preallocation != PREALLOC_MODE_OFF &&
!qcow2_opts->extended_l2) !qcow2_opts->extended_l2)
{ {
@ -3517,7 +3517,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
if (qcow2_opts->has_backing_fmt && !qcow2_opts->has_backing_file) { if (qcow2_opts->has_backing_fmt && !qcow2_opts->backing_file) {
error_setg(errp, "Backing format cannot be used without backing file"); error_setg(errp, "Backing format cannot be used without backing file");
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
@ -3558,7 +3558,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
if (qcow2_opts->data_file_raw && qcow2_opts->has_backing_file) { if (qcow2_opts->data_file_raw && qcow2_opts->backing_file) {
error_setg(errp, "Backing file and data-file-raw cannot be used at " error_setg(errp, "Backing file and data-file-raw cannot be used at "
"the same time"); "the same time");
ret = -EINVAL; ret = -EINVAL;
@ -3584,7 +3584,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
* backing file when specifying data_file_raw is an error * backing file when specifying data_file_raw is an error
* anyway. * anyway.
*/ */
assert(!qcow2_opts->has_backing_file); assert(!qcow2_opts->backing_file);
} }
if (qcow2_opts->data_file) { if (qcow2_opts->data_file) {
@ -3752,7 +3752,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
} }
/* Want a backing file? There you go. */ /* Want a backing file? There you go. */
if (qcow2_opts->has_backing_file) { if (qcow2_opts->backing_file) {
const char *backing_format = NULL; const char *backing_format = NULL;
if (qcow2_opts->has_backing_fmt) { if (qcow2_opts->has_backing_fmt) {
@ -3770,7 +3770,7 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
} }
/* Want encryption? There you go. */ /* Want encryption? There you go. */
if (qcow2_opts->has_encrypt) { if (qcow2_opts->encrypt) {
ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp); ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
@ -5195,7 +5195,6 @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
.refcount_bits = s->refcount_bits, .refcount_bits = s->refcount_bits,
.has_bitmaps = !!bitmaps, .has_bitmaps = !!bitmaps,
.bitmaps = bitmaps, .bitmaps = bitmaps,
.has_data_file = !!s->image_data_file,
.data_file = g_strdup(s->image_data_file), .data_file = g_strdup(s->image_data_file),
.has_data_file_raw = has_data_file(bs), .has_data_file_raw = has_data_file(bs),
.data_file_raw = data_file_is_raw(bs), .data_file_raw = data_file_is_raw(bs),
@ -5226,7 +5225,6 @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs,
memset(&encrypt_info->u, 0, sizeof(encrypt_info->u)); memset(&encrypt_info->u, 0, sizeof(encrypt_info->u));
qapi_free_QCryptoBlockInfo(encrypt_info); qapi_free_QCryptoBlockInfo(encrypt_info);
spec_info->u.qcow2.data->has_encrypt = true;
spec_info->u.qcow2.data->encrypt = qencrypt; spec_info->u.qcow2.data->encrypt = qencrypt;
} }
@ -5846,7 +5844,7 @@ static int coroutine_fn qcow2_co_amend(BlockDriverState *bs,
BDRVQcow2State *s = bs->opaque; BDRVQcow2State *s = bs->opaque;
int ret = 0; int ret = 0;
if (qopts->has_encrypt) { if (qopts->encrypt) {
if (!s->crypto) { if (!s->crypto) {
error_setg(errp, "image is not encrypted, can't amend"); error_setg(errp, "image is not encrypted, can't amend");
return -EOPNOTSUPP; return -EOPNOTSUPP;
@ -5911,7 +5909,7 @@ void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
node_name = bdrv_get_node_name(bs); node_name = bdrv_get_node_name(bs);
qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs), qapi_event_send_block_image_corrupted(bdrv_get_device_name(bs),
*node_name != '\0', node_name, *node_name ? node_name : NULL,
message, offset >= 0, offset, message, offset >= 0, offset,
size >= 0, size, size >= 0, size,
fatal); fatal);

2
block/qed.c
View File

@ -698,7 +698,7 @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
goto out; goto out;
} }
if (qed_opts->has_backing_file) { if (qed_opts->backing_file) {
header.features |= QED_F_BACKING_FILE; header.features |= QED_F_BACKING_FILE;
header.backing_filename_offset = sizeof(le_header); header.backing_filename_offset = sizeof(le_header);
header.backing_filename_size = strlen(qed_opts->backing_file); header.backing_filename_size = strlen(qed_opts->backing_file);

2
block/quorum.c
View File

@ -202,7 +202,7 @@ static void quorum_report_bad(QuorumOpType type, uint64_t offset,
msg = strerror(-ret); msg = strerror(-ret);
} }
qapi_event_send_quorum_report_bad(type, !!msg, msg, node_name, start_sector, qapi_event_send_quorum_report_bad(type, msg, node_name, start_sector,
end_sector - start_sector); end_sector - start_sector);
} }

17
block/rbd.c
View File

@ -536,13 +536,13 @@ static int qemu_rbd_do_create(BlockdevCreateOptions *options,
int ret; int ret;
assert(options->driver == BLOCKDEV_DRIVER_RBD); assert(options->driver == BLOCKDEV_DRIVER_RBD);
if (opts->location->has_snapshot) { if (opts->location->snapshot) {
error_setg(errp, "Can't use snapshot name for image creation"); error_setg(errp, "Can't use snapshot name for image creation");
return -EINVAL; return -EINVAL;
} }
#ifndef LIBRBD_SUPPORTS_ENCRYPTION #ifndef LIBRBD_SUPPORTS_ENCRYPTION
if (opts->has_encrypt) { if (opts->encrypt) {
error_setg(errp, "RBD library does not support image encryption"); error_setg(errp, "RBD library does not support image encryption");
return -ENOTSUP; return -ENOTSUP;
} }
@ -574,7 +574,7 @@ static int qemu_rbd_do_create(BlockdevCreateOptions *options,
} }
#ifdef LIBRBD_SUPPORTS_ENCRYPTION #ifdef LIBRBD_SUPPORTS_ENCRYPTION
if (opts->has_encrypt) { if (opts->encrypt) {
rbd_image_t image; rbd_image_t image;
ret = rbd_open(io_ctx, opts->location->image, &image, NULL); ret = rbd_open(io_ctx, opts->location->image, &image, NULL);
@ -686,7 +686,6 @@ static int coroutine_fn qemu_rbd_co_create_opts(BlockDriver *drv,
goto exit; goto exit;
} }
rbd_opts->encrypt = encrypt; rbd_opts->encrypt = encrypt;
rbd_opts->has_encrypt = !!encrypt;
/* /*
* Caution: while qdict_get_try_str() is fine, getting non-string * Caution: while qdict_get_try_str() is fine, getting non-string
@ -697,11 +696,8 @@ static int coroutine_fn qemu_rbd_co_create_opts(BlockDriver *drv,
loc = rbd_opts->location; loc = rbd_opts->location;
loc->pool = g_strdup(qdict_get_try_str(options, "pool")); loc->pool = g_strdup(qdict_get_try_str(options, "pool"));
loc->conf = g_strdup(qdict_get_try_str(options, "conf")); loc->conf = g_strdup(qdict_get_try_str(options, "conf"));
loc->has_conf = !!loc->conf;
loc->user = g_strdup(qdict_get_try_str(options, "user")); loc->user = g_strdup(qdict_get_try_str(options, "user"));
loc->has_user = !!loc->user;
loc->q_namespace = g_strdup(qdict_get_try_str(options, "namespace")); loc->q_namespace = g_strdup(qdict_get_try_str(options, "namespace"));
loc->has_q_namespace = !!loc->q_namespace;
loc->image = g_strdup(qdict_get_try_str(options, "image")); loc->image = g_strdup(qdict_get_try_str(options, "image"));
keypairs = qdict_get_try_str(options, "=keyvalue-pairs"); keypairs = qdict_get_try_str(options, "=keyvalue-pairs");
@ -767,7 +763,6 @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
return -EINVAL; return -EINVAL;
} }
opts->key_secret = g_strdup(secretid); opts->key_secret = g_strdup(secretid);
opts->has_key_secret = true;
} }
mon_host = qemu_rbd_mon_host(opts, &local_err); mon_host = qemu_rbd_mon_host(opts, &local_err);
@ -785,7 +780,7 @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
/* try default location when conf=NULL, but ignore failure */ /* try default location when conf=NULL, but ignore failure */
r = rados_conf_read_file(*cluster, opts->conf); r = rados_conf_read_file(*cluster, opts->conf);
if (opts->has_conf && r < 0) { if (opts->conf && r < 0) {
error_setg_errno(errp, -r, "error reading conf file %s", opts->conf); error_setg_errno(errp, -r, "error reading conf file %s", opts->conf);
goto failed_shutdown; goto failed_shutdown;
} }
@ -833,7 +828,7 @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
} }
#ifdef HAVE_RBD_NAMESPACE_EXISTS #ifdef HAVE_RBD_NAMESPACE_EXISTS
if (opts->has_q_namespace && strlen(opts->q_namespace) > 0) { if (opts->q_namespace && strlen(opts->q_namespace) > 0) {
bool exists; bool exists;
r = rbd_namespace_exists(*io_ctx, opts->q_namespace, &exists); r = rbd_namespace_exists(*io_ctx, opts->q_namespace, &exists);
@ -991,7 +986,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
goto failed_open; goto failed_open;
} }
if (opts->has_encrypt) { if (opts->encrypt) {
#ifdef LIBRBD_SUPPORTS_ENCRYPTION #ifdef LIBRBD_SUPPORTS_ENCRYPTION
r = qemu_rbd_encryption_load(s->image, opts->encrypt, errp); r = qemu_rbd_encryption_load(s->image, opts->encrypt, errp);
if (r < 0) { if (r < 0) {

2
block/ssh.c
View File

@ -643,7 +643,7 @@ static int connect_to_ssh(BDRVSSHState *s, BlockdevOptionsSsh *opts,
unsigned int port = 0; unsigned int port = 0;
int new_sock = -1; int new_sock = -1;
if (opts->has_user) { if (opts->user) {
s->user = g_strdup(opts->user); s->user = g_strdup(opts->user);
} else { } else {
s->user = g_strdup(g_get_user_name()); s->user = g_strdup(g_get_user_name());

9
blockdev-nbd.c
View File

@ -173,8 +173,8 @@ void nbd_server_start_options(NbdServerOptions *arg, Error **errp)
} }
void qmp_nbd_server_start(SocketAddressLegacy *addr, void qmp_nbd_server_start(SocketAddressLegacy *addr,
bool has_tls_creds, const char *tls_creds, const char *tls_creds,
bool has_tls_authz, const char *tls_authz, const char *tls_authz,
bool has_max_connections, uint32_t max_connections, bool has_max_connections, uint32_t max_connections,
Error **errp) Error **errp)
{ {
@ -200,8 +200,7 @@ void qmp_nbd_server_add(NbdServerAddOptions *arg, Error **errp)
* block-export-add would default to the node-name, but we may have to use * block-export-add would default to the node-name, but we may have to use
* the device name as a default here for compatibility. * the device name as a default here for compatibility.
*/ */
if (!arg->has_name) { if (!arg->name) {
arg->has_name = true;
arg->name = g_strdup(arg->device); arg->name = g_strdup(arg->device);
} }
@ -215,7 +214,7 @@ void qmp_nbd_server_add(NbdServerAddOptions *arg, Error **errp)
}; };
QAPI_CLONE_MEMBERS(BlockExportOptionsNbdBase, &export_opts->u.nbd, QAPI_CLONE_MEMBERS(BlockExportOptionsNbdBase, &export_opts->u.nbd,
qapi_NbdServerAddOptions_base(arg)); qapi_NbdServerAddOptions_base(arg));
if (arg->has_bitmap) { if (arg->bitmap) {
BlockDirtyBitmapOrStr *el = g_new(BlockDirtyBitmapOrStr, 1); BlockDirtyBitmapOrStr *el = g_new(BlockDirtyBitmapOrStr, 1);
*el = (BlockDirtyBitmapOrStr) { *el = (BlockDirtyBitmapOrStr) {

185
blockdev.c
View File

@ -1048,26 +1048,20 @@ static void blockdev_do_action(TransactionAction *action, Error **errp)
list.value = action; list.value = action;
list.next = NULL; list.next = NULL;
qmp_transaction(&list, false, NULL, errp); qmp_transaction(&list, NULL, errp);
} }
void qmp_blockdev_snapshot_sync(bool has_device, const char *device, void qmp_blockdev_snapshot_sync(const char *device, const char *node_name,
bool has_node_name, const char *node_name,
const char *snapshot_file, const char *snapshot_file,
bool has_snapshot_node_name,
const char *snapshot_node_name, const char *snapshot_node_name,
bool has_format, const char *format, const char *format,
bool has_mode, NewImageMode mode, Error **errp) bool has_mode, NewImageMode mode, Error **errp)
{ {
BlockdevSnapshotSync snapshot = { BlockdevSnapshotSync snapshot = {
.has_device = has_device,
.device = (char *) device, .device = (char *) device,
.has_node_name = has_node_name,
.node_name = (char *) node_name, .node_name = (char *) node_name,
.snapshot_file = (char *) snapshot_file, .snapshot_file = (char *) snapshot_file,
.has_snapshot_node_name = has_snapshot_node_name,
.snapshot_node_name = (char *) snapshot_node_name, .snapshot_node_name = (char *) snapshot_node_name,
.has_format = has_format,
.format = (char *) format, .format = (char *) format,
.has_mode = has_mode, .has_mode = has_mode,
.mode = mode, .mode = mode,
@ -1109,9 +1103,7 @@ void qmp_blockdev_snapshot_internal_sync(const char *device,
} }
SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device, SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
bool has_id,
const char *id, const char *id,
bool has_name,
const char *name, const char *name,
Error **errp) Error **errp)
{ {
@ -1129,14 +1121,6 @@ SnapshotInfo *qmp_blockdev_snapshot_delete_internal_sync(const char *device,
aio_context = bdrv_get_aio_context(bs); aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context); aio_context_acquire(aio_context);
if (!has_id) {
id = NULL;
}
if (!has_name) {
name = NULL;
}
if (!id && !name) { if (!id && !name) {
error_setg(errp, "Name or id must be provided"); error_setg(errp, "Name or id must be provided");
goto out_aio_context; goto out_aio_context;
@ -1450,8 +1434,8 @@ static void external_snapshot_prepare(BlkActionState *common,
case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC: case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
{ {
BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data; BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
device = s->has_device ? s->device : NULL; device = s->device;
node_name = s->has_node_name ? s->node_name : NULL; node_name = s->node_name;
new_image_file = s->snapshot_file; new_image_file = s->snapshot_file;
snapshot_ref = NULL; snapshot_ref = NULL;
} }
@ -1495,10 +1479,9 @@ static void external_snapshot_prepare(BlkActionState *common,
if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) { if (action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC) {
BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data; BlockdevSnapshotSync *s = action->u.blockdev_snapshot_sync.data;
const char *format = s->has_format ? s->format : "qcow2"; const char *format = s->format ?: "qcow2";
enum NewImageMode mode; enum NewImageMode mode;
const char *snapshot_node_name = const char *snapshot_node_name = s->snapshot_node_name;
s->has_snapshot_node_name ? s->snapshot_node_name : NULL;
if (node_name && !snapshot_node_name) { if (node_name && !snapshot_node_name) {
error_setg(errp, "New overlay node-name missing"); error_setg(errp, "New overlay node-name missing");
@ -1686,6 +1669,7 @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)
BlockDriverState *source = NULL; BlockDriverState *source = NULL;
AioContext *aio_context; AioContext *aio_context;
AioContext *old_context; AioContext *old_context;
const char *format;
QDict *options; QDict *options;
Error *local_err = NULL; Error *local_err = NULL;
int flags; int flags;
@ -1717,9 +1701,9 @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)
/* Paired with .clean() */ /* Paired with .clean() */
bdrv_drained_begin(bs); bdrv_drained_begin(bs);
if (!backup->has_format) { format = backup->format;
backup->format = backup->mode == NEW_IMAGE_MODE_EXISTING ? if (!format && backup->mode != NEW_IMAGE_MODE_EXISTING) {
NULL : (char *) bs->drv->format_name; format = bs->drv->format_name;
} }
/* Early check to avoid creating target */ /* Early check to avoid creating target */
@ -1758,19 +1742,19 @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)
} }
if (backup->mode != NEW_IMAGE_MODE_EXISTING) { if (backup->mode != NEW_IMAGE_MODE_EXISTING) {
assert(backup->format); assert(format);
if (source) { if (source) {
/* Implicit filters should not appear in the filename */ /* Implicit filters should not appear in the filename */
BlockDriverState *explicit_backing = BlockDriverState *explicit_backing =
bdrv_skip_implicit_filters(source); bdrv_skip_implicit_filters(source);
bdrv_refresh_filename(explicit_backing); bdrv_refresh_filename(explicit_backing);
bdrv_img_create(backup->target, backup->format, bdrv_img_create(backup->target, format,
explicit_backing->filename, explicit_backing->filename,
explicit_backing->drv->format_name, NULL, explicit_backing->drv->format_name, NULL,
size, flags, false, &local_err); size, flags, false, &local_err);
} else { } else {
bdrv_img_create(backup->target, backup->format, NULL, NULL, NULL, bdrv_img_create(backup->target, format, NULL, NULL, NULL,
size, flags, false, &local_err); size, flags, false, &local_err);
} }
} }
@ -1783,8 +1767,8 @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)
options = qdict_new(); options = qdict_new();
qdict_put_str(options, "discard", "unmap"); qdict_put_str(options, "discard", "unmap");
qdict_put_str(options, "detect-zeroes", "unmap"); qdict_put_str(options, "detect-zeroes", "unmap");
if (backup->format) { if (format) {
qdict_put_str(options, "driver", backup->format); qdict_put_str(options, "driver", format);
} }
target_bs = bdrv_open(backup->target, NULL, options, flags, errp); target_bs = bdrv_open(backup->target, NULL, options, flags, errp);
@ -2305,11 +2289,11 @@ static TransactionProperties *get_transaction_properties(
* Always run under BQL. * Always run under BQL.
*/ */
void qmp_transaction(TransactionActionList *dev_list, void qmp_transaction(TransactionActionList *dev_list,
bool has_props,
struct TransactionProperties *props, struct TransactionProperties *props,
Error **errp) Error **errp)
{ {
TransactionActionList *dev_entry = dev_list; TransactionActionList *dev_entry = dev_list;
bool has_props = !!props;
JobTxn *block_job_txn = NULL; JobTxn *block_job_txn = NULL;
BlkActionState *state, *next; BlkActionState *state, *next;
Error *local_err = NULL; Error *local_err = NULL;
@ -2411,8 +2395,7 @@ BlockDirtyBitmapSha256 *qmp_x_debug_block_dirty_bitmap_sha256(const char *node,
return ret; return ret;
} }
void coroutine_fn qmp_block_resize(bool has_device, const char *device, void coroutine_fn qmp_block_resize(const char *device, const char *node_name,
bool has_node_name, const char *node_name,
int64_t size, Error **errp) int64_t size, Error **errp)
{ {
Error *local_err = NULL; Error *local_err = NULL;
@ -2420,9 +2403,7 @@ void coroutine_fn qmp_block_resize(bool has_device, const char *device,
BlockDriverState *bs; BlockDriverState *bs;
AioContext *old_ctx; AioContext *old_ctx;
bs = bdrv_lookup_bs(has_device ? device : NULL, bs = bdrv_lookup_bs(device, node_name, &local_err);
has_node_name ? node_name : NULL,
&local_err);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
return; return;
@ -2457,14 +2438,14 @@ void coroutine_fn qmp_block_resize(bool has_device, const char *device,
bdrv_co_unlock(bs); bdrv_co_unlock(bs);
} }
void qmp_block_stream(bool has_job_id, const char *job_id, const char *device, void qmp_block_stream(const char *job_id, const char *device,
bool has_base, const char *base, const char *base,
bool has_base_node, const char *base_node, const char *base_node,
bool has_backing_file, const char *backing_file, const char *backing_file,
bool has_bottom, const char *bottom, const char *bottom,
bool has_speed, int64_t speed, bool has_speed, int64_t speed,
bool has_on_error, BlockdevOnError on_error, bool has_on_error, BlockdevOnError on_error,
bool has_filter_node_name, const char *filter_node_name, const char *filter_node_name,
bool has_auto_finalize, bool auto_finalize, bool has_auto_finalize, bool auto_finalize,
bool has_auto_dismiss, bool auto_dismiss, bool has_auto_dismiss, bool auto_dismiss,
Error **errp) Error **errp)
@ -2476,19 +2457,19 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
Error *local_err = NULL; Error *local_err = NULL;
int job_flags = JOB_DEFAULT; int job_flags = JOB_DEFAULT;
if (has_base && has_base_node) { if (base && base_node) {
error_setg(errp, "'base' and 'base-node' cannot be specified " error_setg(errp, "'base' and 'base-node' cannot be specified "
"at the same time"); "at the same time");
return; return;
} }
if (has_base && has_bottom) { if (base && bottom) {
error_setg(errp, "'base' and 'bottom' cannot be specified " error_setg(errp, "'base' and 'bottom' cannot be specified "
"at the same time"); "at the same time");
return; return;
} }
if (has_bottom && has_base_node) { if (bottom && base_node) {
error_setg(errp, "'bottom' and 'base-node' cannot be specified " error_setg(errp, "'bottom' and 'base-node' cannot be specified "
"at the same time"); "at the same time");
return; return;
@ -2506,7 +2487,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
aio_context = bdrv_get_aio_context(bs); aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context); aio_context_acquire(aio_context);
if (has_base) { if (base) {
base_bs = bdrv_find_backing_image(bs, base); base_bs = bdrv_find_backing_image(bs, base);
if (base_bs == NULL) { if (base_bs == NULL) {
error_setg(errp, "Can't find '%s' in the backing chain", base); error_setg(errp, "Can't find '%s' in the backing chain", base);
@ -2515,7 +2496,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
assert(bdrv_get_aio_context(base_bs) == aio_context); assert(bdrv_get_aio_context(base_bs) == aio_context);
} }
if (has_base_node) { if (base_node) {
base_bs = bdrv_lookup_bs(NULL, base_node, errp); base_bs = bdrv_lookup_bs(NULL, base_node, errp);
if (!base_bs) { if (!base_bs) {
goto out; goto out;
@ -2529,7 +2510,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
bdrv_refresh_filename(base_bs); bdrv_refresh_filename(base_bs);
} }
if (has_bottom) { if (bottom) {
bottom_bs = bdrv_lookup_bs(NULL, bottom, errp); bottom_bs = bdrv_lookup_bs(NULL, bottom, errp);
if (!bottom_bs) { if (!bottom_bs) {
goto out; goto out;
@ -2554,7 +2535,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
/* /*
* Check for op blockers in the whole chain between bs and base (or bottom) * Check for op blockers in the whole chain between bs and base (or bottom)
*/ */
iter_end = has_bottom ? bdrv_filter_or_cow_bs(bottom_bs) : base_bs; iter_end = bottom ? bdrv_filter_or_cow_bs(bottom_bs) : base_bs;
for (iter = bs; iter && iter != iter_end; for (iter = bs; iter && iter != iter_end;
iter = bdrv_filter_or_cow_bs(iter)) iter = bdrv_filter_or_cow_bs(iter))
{ {
@ -2565,7 +2546,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
/* if we are streaming the entire chain, the result will have no backing /* if we are streaming the entire chain, the result will have no backing
* file, and specifying one is therefore an error */ * file, and specifying one is therefore an error */
if (base_bs == NULL && has_backing_file) { if (!base_bs && backing_file) {
error_setg(errp, "backing file specified, but streaming the " error_setg(errp, "backing file specified, but streaming the "
"entire chain"); "entire chain");
goto out; goto out;
@ -2578,7 +2559,7 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device,
job_flags |= JOB_MANUAL_DISMISS; job_flags |= JOB_MANUAL_DISMISS;
} }
stream_start(has_job_id ? job_id : NULL, bs, base_bs, backing_file, stream_start(job_id, bs, base_bs, backing_file,
bottom_bs, job_flags, has_speed ? speed : 0, on_error, bottom_bs, job_flags, has_speed ? speed : 0, on_error,
filter_node_name, &local_err); filter_node_name, &local_err);
if (local_err) { if (local_err) {
@ -2592,15 +2573,15 @@ out:
aio_context_release(aio_context); aio_context_release(aio_context);
} }
void qmp_block_commit(bool has_job_id, const char *job_id, const char *device, void qmp_block_commit(const char *job_id, const char *device,
bool has_base_node, const char *base_node, const char *base_node,
bool has_base, const char *base, const char *base,
bool has_top_node, const char *top_node, const char *top_node,
bool has_top, const char *top, const char *top,
bool has_backing_file, const char *backing_file, const char *backing_file,
bool has_speed, int64_t speed, bool has_speed, int64_t speed,
bool has_on_error, BlockdevOnError on_error, bool has_on_error, BlockdevOnError on_error,
bool has_filter_node_name, const char *filter_node_name, const char *filter_node_name,
bool has_auto_finalize, bool auto_finalize, bool has_auto_finalize, bool auto_finalize,
bool has_auto_dismiss, bool auto_dismiss, bool has_auto_dismiss, bool auto_dismiss,
Error **errp) Error **errp)
@ -2619,9 +2600,6 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
if (!has_on_error) { if (!has_on_error) {
on_error = BLOCKDEV_ON_ERROR_REPORT; on_error = BLOCKDEV_ON_ERROR_REPORT;
} }
if (!has_filter_node_name) {
filter_node_name = NULL;
}
if (has_auto_finalize && !auto_finalize) { if (has_auto_finalize && !auto_finalize) {
job_flags |= JOB_MANUAL_FINALIZE; job_flags |= JOB_MANUAL_FINALIZE;
} }
@ -2657,10 +2635,10 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
/* default top_bs is the active layer */ /* default top_bs is the active layer */
top_bs = bs; top_bs = bs;
if (has_top_node && has_top) { if (top_node && top) {
error_setg(errp, "'top-node' and 'top' are mutually exclusive"); error_setg(errp, "'top-node' and 'top' are mutually exclusive");
goto out; goto out;
} else if (has_top_node) { } else if (top_node) {
top_bs = bdrv_lookup_bs(NULL, top_node, errp); top_bs = bdrv_lookup_bs(NULL, top_node, errp);
if (top_bs == NULL) { if (top_bs == NULL) {
goto out; goto out;
@ -2670,7 +2648,7 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
top_node); top_node);
goto out; goto out;
} }
} else if (has_top && top) { } else if (top) {
/* This strcmp() is just a shortcut, there is no need to /* This strcmp() is just a shortcut, there is no need to
* refresh @bs's filename. If it mismatches, * refresh @bs's filename. If it mismatches,
* bdrv_find_backing_image() will do the refresh and may still * bdrv_find_backing_image() will do the refresh and may still
@ -2687,10 +2665,10 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
assert(bdrv_get_aio_context(top_bs) == aio_context); assert(bdrv_get_aio_context(top_bs) == aio_context);
if (has_base_node && has_base) { if (base_node && base) {
error_setg(errp, "'base-node' and 'base' are mutually exclusive"); error_setg(errp, "'base-node' and 'base' are mutually exclusive");
goto out; goto out;
} else if (has_base_node) { } else if (base_node) {
base_bs = bdrv_lookup_bs(NULL, base_node, errp); base_bs = bdrv_lookup_bs(NULL, base_node, errp);
if (base_bs == NULL) { if (base_bs == NULL) {
goto out; goto out;
@ -2700,7 +2678,7 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
base_node); base_node);
goto out; goto out;
} }
} else if (has_base && base) { } else if (base) {
base_bs = bdrv_find_backing_image(top_bs, base); base_bs = bdrv_find_backing_image(top_bs, base);
if (base_bs == NULL) { if (base_bs == NULL) {
error_setg(errp, "Can't find '%s' in the backing chain", base); error_setg(errp, "Can't find '%s' in the backing chain", base);
@ -2742,7 +2720,7 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
if (top_perm & BLK_PERM_WRITE || if (top_perm & BLK_PERM_WRITE ||
bdrv_skip_filters(top_bs) == bdrv_skip_filters(bs)) bdrv_skip_filters(top_bs) == bdrv_skip_filters(bs))
{ {
if (has_backing_file) { if (backing_file) {
if (bdrv_skip_filters(top_bs) == bdrv_skip_filters(bs)) { if (bdrv_skip_filters(top_bs) == bdrv_skip_filters(bs)) {
error_setg(errp, "'backing-file' specified," error_setg(errp, "'backing-file' specified,"
" but 'top' is the active layer"); " but 'top' is the active layer");
@ -2752,7 +2730,7 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
} }
goto out; goto out;
} }
if (!has_job_id) { if (!job_id) {
/* /*
* Emulate here what block_job_create() does, because it * Emulate here what block_job_create() does, because it
* is possible that @bs != @top_bs (the block job should * is possible that @bs != @top_bs (the block job should
@ -2768,8 +2746,8 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,
if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) { if (bdrv_op_is_blocked(overlay_bs, BLOCK_OP_TYPE_COMMIT_TARGET, errp)) {
goto out; goto out;
} }
commit_start(has_job_id ? job_id : NULL, bs, base_bs, top_bs, job_flags, commit_start(job_id, bs, base_bs, top_bs, job_flags,
speed, on_error, has_backing_file ? backing_file : NULL, speed, on_error, backing_file,
filter_node_name, &local_err); filter_node_name, &local_err);
} }
if (local_err != NULL) { if (local_err != NULL) {
@ -2802,9 +2780,6 @@ static BlockJob *do_backup_common(BackupCommon *backup,
if (!backup->has_on_target_error) { if (!backup->has_on_target_error) {
backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT; backup->on_target_error = BLOCKDEV_ON_ERROR_REPORT;
} }
if (!backup->has_job_id) {
backup->job_id = NULL;
}
if (!backup->has_auto_finalize) { if (!backup->has_auto_finalize) {
backup->auto_finalize = true; backup->auto_finalize = true;
} }
@ -2830,7 +2805,7 @@ static BlockJob *do_backup_common(BackupCommon *backup,
if ((backup->sync == MIRROR_SYNC_MODE_BITMAP) || if ((backup->sync == MIRROR_SYNC_MODE_BITMAP) ||
(backup->sync == MIRROR_SYNC_MODE_INCREMENTAL)) { (backup->sync == MIRROR_SYNC_MODE_INCREMENTAL)) {
/* done before desugaring 'incremental' to print the right message */ /* done before desugaring 'incremental' to print the right message */
if (!backup->has_bitmap) { if (!backup->bitmap) {
error_setg(errp, "must provide a valid bitmap name for " error_setg(errp, "must provide a valid bitmap name for "
"'%s' sync mode", MirrorSyncMode_str(backup->sync)); "'%s' sync mode", MirrorSyncMode_str(backup->sync));
return NULL; return NULL;
@ -2851,7 +2826,7 @@ static BlockJob *do_backup_common(BackupCommon *backup,
backup->bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS; backup->bitmap_mode = BITMAP_SYNC_MODE_ON_SUCCESS;
} }
if (backup->has_bitmap) { if (backup->bitmap) {
bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap); bmap = bdrv_find_dirty_bitmap(bs, backup->bitmap);
if (!bmap) { if (!bmap) {
error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap); error_setg(errp, "Bitmap '%s' could not be found", backup->bitmap);
@ -2884,7 +2859,7 @@ static BlockJob *do_backup_common(BackupCommon *backup,
} }
} }
if (!backup->has_bitmap && backup->has_bitmap_mode) { if (!backup->bitmap && backup->has_bitmap_mode) {
error_setg(errp, "Cannot specify bitmap sync mode without a bitmap"); error_setg(errp, "Cannot specify bitmap sync mode without a bitmap");
return NULL; return NULL;
} }
@ -2944,7 +2919,7 @@ void qmp_blockdev_backup(BlockdevBackup *backup, Error **errp)
**/ **/
static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs, static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
BlockDriverState *target, BlockDriverState *target,
bool has_replaces, const char *replaces, const char *replaces,
enum MirrorSyncMode sync, enum MirrorSyncMode sync,
BlockMirrorBackingMode backing_mode, BlockMirrorBackingMode backing_mode,
bool zero_target, bool zero_target,
@ -2956,7 +2931,6 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
bool has_on_target_error, bool has_on_target_error,
BlockdevOnError on_target_error, BlockdevOnError on_target_error,
bool has_unmap, bool unmap, bool has_unmap, bool unmap,
bool has_filter_node_name,
const char *filter_node_name, const char *filter_node_name,
bool has_copy_mode, MirrorCopyMode copy_mode, bool has_copy_mode, MirrorCopyMode copy_mode,
bool has_auto_finalize, bool auto_finalize, bool has_auto_finalize, bool auto_finalize,
@ -2984,9 +2958,6 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
if (!has_unmap) { if (!has_unmap) {
unmap = true; unmap = true;
} }
if (!has_filter_node_name) {
filter_node_name = NULL;
}
if (!has_copy_mode) { if (!has_copy_mode) {
copy_mode = MIRROR_COPY_MODE_BACKGROUND; copy_mode = MIRROR_COPY_MODE_BACKGROUND;
} }
@ -3019,16 +2990,15 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
sync = MIRROR_SYNC_MODE_FULL; sync = MIRROR_SYNC_MODE_FULL;
} }
if (!has_replaces) { if (!replaces) {
/* We want to mirror from @bs, but keep implicit filters on top */ /* We want to mirror from @bs, but keep implicit filters on top */
unfiltered_bs = bdrv_skip_implicit_filters(bs); unfiltered_bs = bdrv_skip_implicit_filters(bs);
if (unfiltered_bs != bs) { if (unfiltered_bs != bs) {
replaces = unfiltered_bs->node_name; replaces = unfiltered_bs->node_name;
has_replaces = true;
} }
} }
if (has_replaces) { if (replaces) {
BlockDriverState *to_replace_bs; BlockDriverState *to_replace_bs;
AioContext *replace_aio_context; AioContext *replace_aio_context;
int64_t bs_size, replace_size; int64_t bs_size, replace_size;
@ -3065,7 +3035,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,
* and will allow to check whether the node still exist at mirror completion * and will allow to check whether the node still exist at mirror completion
*/ */
mirror_start(job_id, bs, target, mirror_start(job_id, bs, target,
has_replaces ? replaces : NULL, job_flags, replaces, job_flags,
speed, granularity, buf_size, sync, backing_mode, zero_target, speed, granularity, buf_size, sync, backing_mode, zero_target,
on_source_error, on_target_error, unmap, filter_node_name, on_source_error, on_target_error, unmap, filter_node_name,
copy_mode, errp); copy_mode, errp);
@ -3103,7 +3073,7 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
arg->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS; arg->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
} }
if (!arg->has_format) { if (!arg->format) {
format = (arg->mode == NEW_IMAGE_MODE_EXISTING format = (arg->mode == NEW_IMAGE_MODE_EXISTING
? NULL : bs->drv->format_name); ? NULL : bs->drv->format_name);
} }
@ -3123,8 +3093,8 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
goto out; goto out;
} }
if (arg->has_replaces) { if (arg->replaces) {
if (!arg->has_node_name) { if (!arg->node_name) {
error_setg(errp, "a node-name must be provided when replacing a" error_setg(errp, "a node-name must be provided when replacing a"
" named node of the graph"); " named node of the graph");
goto out; goto out;
@ -3174,7 +3144,7 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
} }
options = qdict_new(); options = qdict_new();
if (arg->has_node_name) { if (arg->node_name) {
qdict_put_str(options, "node-name", arg->node_name); qdict_put_str(options, "node-name", arg->node_name);
} }
if (format) { if (format) {
@ -3209,8 +3179,8 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
aio_context_release(old_context); aio_context_release(old_context);
aio_context_acquire(aio_context); aio_context_acquire(aio_context);
blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs, blockdev_mirror_common(arg->job_id, bs, target_bs,
arg->has_replaces, arg->replaces, arg->sync, arg->replaces, arg->sync,
backing_mode, zero_target, backing_mode, zero_target,
arg->has_speed, arg->speed, arg->has_speed, arg->speed,
arg->has_granularity, arg->granularity, arg->has_granularity, arg->granularity,
@ -3218,7 +3188,7 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)
arg->has_on_source_error, arg->on_source_error, arg->has_on_source_error, arg->on_source_error,
arg->has_on_target_error, arg->on_target_error, arg->has_on_target_error, arg->on_target_error,
arg->has_unmap, arg->unmap, arg->has_unmap, arg->unmap,
false, NULL, NULL,
arg->has_copy_mode, arg->copy_mode, arg->has_copy_mode, arg->copy_mode,
arg->has_auto_finalize, arg->auto_finalize, arg->has_auto_finalize, arg->auto_finalize,
arg->has_auto_dismiss, arg->auto_dismiss, arg->has_auto_dismiss, arg->auto_dismiss,
@ -3228,9 +3198,9 @@ out:
aio_context_release(aio_context); aio_context_release(aio_context);
} }
void qmp_blockdev_mirror(bool has_job_id, const char *job_id, void qmp_blockdev_mirror(const char *job_id,
const char *device, const char *target, const char *device, const char *target,
bool has_replaces, const char *replaces, const char *replaces,
MirrorSyncMode sync, MirrorSyncMode sync,
bool has_speed, int64_t speed, bool has_speed, int64_t speed,
bool has_granularity, uint32_t granularity, bool has_granularity, uint32_t granularity,
@ -3239,7 +3209,6 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
BlockdevOnError on_source_error, BlockdevOnError on_source_error,
bool has_on_target_error, bool has_on_target_error,
BlockdevOnError on_target_error, BlockdevOnError on_target_error,
bool has_filter_node_name,
const char *filter_node_name, const char *filter_node_name,
bool has_copy_mode, MirrorCopyMode copy_mode, bool has_copy_mode, MirrorCopyMode copy_mode,
bool has_auto_finalize, bool auto_finalize, bool has_auto_finalize, bool auto_finalize,
@ -3280,15 +3249,14 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,
goto out; goto out;
} }
blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs, blockdev_mirror_common(job_id, bs, target_bs,
has_replaces, replaces, sync, backing_mode, replaces, sync, backing_mode,
zero_target, has_speed, speed, zero_target, has_speed, speed,
has_granularity, granularity, has_granularity, granularity,
has_buf_size, buf_size, has_buf_size, buf_size,
has_on_source_error, on_source_error, has_on_source_error, on_source_error,
has_on_target_error, on_target_error, has_on_target_error, on_target_error,
true, true, true, true, filter_node_name,
has_filter_node_name, filter_node_name,
has_copy_mode, copy_mode, has_copy_mode, copy_mode,
has_auto_finalize, auto_finalize, has_auto_finalize, auto_finalize,
has_auto_dismiss, auto_dismiss, has_auto_dismiss, auto_dismiss,
@ -3560,7 +3528,7 @@ void qmp_blockdev_reopen(BlockdevOptionsList *reopen_list, Error **errp)
QDict *qdict; QDict *qdict;
/* Check for the selected node name */ /* Check for the selected node name */
if (!options->has_node_name) { if (!options->node_name) {
error_setg(errp, "node-name not specified"); error_setg(errp, "node-name not specified");
goto fail; goto fail;
} }
@ -3665,8 +3633,7 @@ static BdrvChild *bdrv_find_child(BlockDriverState *parent_bs,
return NULL; return NULL;
} }
void qmp_x_blockdev_change(const char *parent, bool has_child, void qmp_x_blockdev_change(const char *parent, const char *child,
const char *child, bool has_node,
const char *node, Error **errp) const char *node, Error **errp)
{ {
BlockDriverState *parent_bs, *new_bs = NULL; BlockDriverState *parent_bs, *new_bs = NULL;
@ -3677,8 +3644,8 @@ void qmp_x_blockdev_change(const char *parent, bool has_child,
return; return;
} }
if (has_child == has_node) { if (!child == !node) {
if (has_child) { if (child) {
error_setg(errp, "The parameters child and node are in conflict"); error_setg(errp, "The parameters child and node are in conflict");
} else { } else {
error_setg(errp, "Either child or node must be specified"); error_setg(errp, "Either child or node must be specified");
@ -3686,7 +3653,7 @@ void qmp_x_blockdev_change(const char *parent, bool has_child,
return; return;
} }
if (has_child) { if (child) {
p_child = bdrv_find_child(parent_bs, child); p_child = bdrv_find_child(parent_bs, child);
if (!p_child) { if (!p_child) {
error_setg(errp, "Node '%s' does not have child '%s'", error_setg(errp, "Node '%s' does not have child '%s'",
@ -3696,7 +3663,7 @@ void qmp_x_blockdev_change(const char *parent, bool has_child,
bdrv_del_child(parent_bs, p_child, errp); bdrv_del_child(parent_bs, p_child, errp);
} }
if (has_node) { if (node) {
new_bs = bdrv_find_node(node); new_bs = bdrv_find_node(node);
if (!new_bs) { if (!new_bs) {
error_setg(errp, "Node '%s' not found", node); error_setg(errp, "Node '%s' not found", node);

2
blockjob.c
View File

@ -354,7 +354,6 @@ BlockJobInfo *block_job_query_locked(BlockJob *job, Error **errp)
info->auto_finalize = job->job.auto_finalize; info->auto_finalize = job->job.auto_finalize;
info->auto_dismiss = job->job.auto_dismiss; info->auto_dismiss = job->job.auto_dismiss;
if (job->job.ret) { if (job->job.ret) {
info->has_error = true;
info->error = job->job.err ? info->error = job->job.err ?
g_strdup(error_get_pretty(job->job.err)) : g_strdup(error_get_pretty(job->job.err)) :
g_strdup(strerror(-job->job.ret)); g_strdup(strerror(-job->job.ret));
@ -414,7 +413,6 @@ static void block_job_event_completed_locked(Notifier *n, void *opaque)
progress_total, progress_total,
progress_current, progress_current,
job->speed, job->speed,
!!msg,
msg); msg);
} }

4
chardev/char-file.c
View File

@ -45,7 +45,7 @@ static void qmp_chardev_open_file(Chardev *chr,
DWORD accessmode; DWORD accessmode;
DWORD flags; DWORD flags;
if (file->has_in) { if (file->in) {
error_setg(errp, "input file not supported"); error_setg(errp, "input file not supported");
return; return;
} }
@ -83,7 +83,7 @@ static void qmp_chardev_open_file(Chardev *chr,
return; return;
} }
if (file->has_in) { if (file->in) {
flags = O_RDONLY; flags = O_RDONLY;
in = qmp_chardev_open_file_source(file->in, flags, errp); in = qmp_chardev_open_file_source(file->in, flags, errp);
if (in < 0) { if (in < 0) {

10
chardev/char-socket.c
View File

@ -1251,7 +1251,7 @@ static bool qmp_chardev_validate_socket(ChardevSocket *sock,
"'fd' address type"); "'fd' address type");
return false; return false;
} }
if (sock->has_tls_creds && if (sock->tls_creds &&
!(sock->has_server && sock->server)) { !(sock->has_server && sock->server)) {
error_setg(errp, error_setg(errp,
"'tls_creds' option is incompatible with " "'tls_creds' option is incompatible with "
@ -1261,7 +1261,7 @@ static bool qmp_chardev_validate_socket(ChardevSocket *sock,
break; break;
case SOCKET_ADDRESS_TYPE_UNIX: case SOCKET_ADDRESS_TYPE_UNIX:
if (sock->has_tls_creds) { if (sock->tls_creds) {
error_setg(errp, error_setg(errp,
"'tls_creds' option is incompatible with " "'tls_creds' option is incompatible with "
"'unix' address type"); "'unix' address type");
@ -1273,7 +1273,7 @@ static bool qmp_chardev_validate_socket(ChardevSocket *sock,
break; break;
case SOCKET_ADDRESS_TYPE_VSOCK: case SOCKET_ADDRESS_TYPE_VSOCK:
if (sock->has_tls_creds) { if (sock->tls_creds) {
error_setg(errp, error_setg(errp,
"'tls_creds' option is incompatible with " "'tls_creds' option is incompatible with "
"'vsock' address type"); "'vsock' address type");
@ -1284,7 +1284,7 @@ static bool qmp_chardev_validate_socket(ChardevSocket *sock,
break; break;
} }
if (sock->has_tls_authz && !sock->has_tls_creds) { if (sock->tls_authz && !sock->tls_creds) {
error_setg(errp, "'tls_authz' option requires 'tls_creds' option"); error_setg(errp, "'tls_authz' option requires 'tls_creds' option");
return false; return false;
} }
@ -1465,9 +1465,7 @@ static void qemu_chr_parse_socket(QemuOpts *opts, ChardevBackend *backend,
sock->wait = qemu_opt_get_bool(opts, "wait", true); sock->wait = qemu_opt_get_bool(opts, "wait", true);
sock->has_reconnect = qemu_opt_find(opts, "reconnect"); sock->has_reconnect = qemu_opt_find(opts, "reconnect");
sock->reconnect = qemu_opt_get_number(opts, "reconnect", 0); sock->reconnect = qemu_opt_get_number(opts, "reconnect", 0);
sock->has_tls_creds = qemu_opt_get(opts, "tls-creds");
sock->tls_creds = g_strdup(qemu_opt_get(opts, "tls-creds")); sock->tls_creds = g_strdup(qemu_opt_get(opts, "tls-creds"));
sock->has_tls_authz = qemu_opt_get(opts, "tls-authz");
sock->tls_authz = g_strdup(qemu_opt_get(opts, "tls-authz")); sock->tls_authz = g_strdup(qemu_opt_get(opts, "tls-authz"));
addr = g_new0(SocketAddressLegacy, 1); addr = g_new0(SocketAddressLegacy, 1);

1
chardev/char-udp.c
View File

@ -178,7 +178,6 @@ static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
udp->remote = addr; udp->remote = addr;
if (has_local) { if (has_local) {
udp->has_local = true;
addr = g_new0(SocketAddressLegacy, 1); addr = g_new0(SocketAddressLegacy, 1);
addr->type = SOCKET_ADDRESS_TYPE_INET; addr->type = SOCKET_ADDRESS_TYPE_INET;
addr->u.inet.data = g_new(InetSocketAddress, 1); addr->u.inet.data = g_new(InetSocketAddress, 1);

6
chardev/char.c
View File

@ -240,7 +240,7 @@ static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
/* Any ChardevCommon member would work */ /* Any ChardevCommon member would work */
ChardevCommon *common = backend ? backend->u.null.data : NULL; ChardevCommon *common = backend ? backend->u.null.data : NULL;
if (common && common->has_logfile) { if (common && common->logfile) {
int flags = O_WRONLY; int flags = O_WRONLY;
if (common->has_logappend && if (common->has_logappend &&
common->logappend) { common->logappend) {
@ -496,9 +496,7 @@ void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
{ {
const char *logfile = qemu_opt_get(opts, "logfile"); const char *logfile = qemu_opt_get(opts, "logfile");
backend->has_logfile = logfile != NULL;
backend->logfile = g_strdup(logfile); backend->logfile = g_strdup(logfile);
backend->has_logappend = true; backend->has_logappend = true;
backend->logappend = qemu_opt_get_bool(opts, "logappend", false); backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
} }
@ -1057,7 +1055,6 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
ret = g_new0(ChardevReturn, 1); ret = g_new0(ChardevReturn, 1);
if (CHARDEV_IS_PTY(chr)) { if (CHARDEV_IS_PTY(chr)) {
ret->pty = g_strdup(chr->filename + 4); ret->pty = g_strdup(chr->filename + 4);
ret->has_pty = true;
} }
return ret; return ret;
@ -1160,7 +1157,6 @@ ChardevReturn *qmp_chardev_change(const char *id, ChardevBackend *backend,
ret = g_new0(ChardevReturn, 1); ret = g_new0(ChardevReturn, 1);
if (CHARDEV_IS_PTY(chr_new)) { if (CHARDEV_IS_PTY(chr_new)) {
ret->pty = g_strdup(chr_new->filename + 4); ret->pty = g_strdup(chr_new->filename + 4);
ret->has_pty = true;
} }
return ret; return ret;

16
crypto/block-luks.c
View File

@ -1597,13 +1597,13 @@ qcrypto_block_luks_amend_add_keyslot(QCryptoBlock *block,
g_autofree char *new_password = NULL; g_autofree char *new_password = NULL;
g_autofree uint8_t *master_key = NULL; g_autofree uint8_t *master_key = NULL;
char *secret = opts_luks->has_secret ? opts_luks->secret : luks->secret; char *secret = opts_luks->secret ?: luks->secret;
if (!opts_luks->has_new_secret) { if (!opts_luks->new_secret) {
error_setg(errp, "'new-secret' is required to activate a keyslot"); error_setg(errp, "'new-secret' is required to activate a keyslot");
return -1; return -1;
} }
if (opts_luks->has_old_secret) { if (opts_luks->old_secret) {
error_setg(errp, error_setg(errp,
"'old-secret' must not be given when activating keyslots"); "'old-secret' must not be given when activating keyslots");
return -1; return -1;
@ -1677,7 +1677,7 @@ qcrypto_block_luks_amend_erase_keyslots(QCryptoBlock *block,
g_autofree uint8_t *tmpkey = NULL; g_autofree uint8_t *tmpkey = NULL;
g_autofree char *old_password = NULL; g_autofree char *old_password = NULL;
if (opts_luks->has_new_secret) { if (opts_luks->new_secret) {
error_setg(errp, error_setg(errp,
"'new-secret' must not be given when erasing keyslots"); "'new-secret' must not be given when erasing keyslots");
return -1; return -1;
@ -1687,14 +1687,14 @@ qcrypto_block_luks_amend_erase_keyslots(QCryptoBlock *block,
"'iter-time' must not be given when erasing keyslots"); "'iter-time' must not be given when erasing keyslots");
return -1; return -1;
} }
if (opts_luks->has_secret) { if (opts_luks->secret) {
error_setg(errp, error_setg(errp,
"'secret' must not be given when erasing keyslots"); "'secret' must not be given when erasing keyslots");
return -1; return -1;
} }
/* Load the old password if given */ /* Load the old password if given */
if (opts_luks->has_old_secret) { if (opts_luks->old_secret) {
old_password = qcrypto_secret_lookup_as_utf8(opts_luks->old_secret, old_password = qcrypto_secret_lookup_as_utf8(opts_luks->old_secret,
errp); errp);
if (!old_password) { if (!old_password) {
@ -1719,7 +1719,7 @@ qcrypto_block_luks_amend_erase_keyslots(QCryptoBlock *block,
return -1; return -1;
} }
if (opts_luks->has_old_secret) { if (opts_luks->old_secret) {
int rv = qcrypto_block_luks_load_key(block, int rv = qcrypto_block_luks_load_key(block,
keyslot, keyslot,
old_password, old_password,
@ -1761,7 +1761,7 @@ qcrypto_block_luks_amend_erase_keyslots(QCryptoBlock *block,
} }
/* Erase all keyslots that match the given old password */ /* Erase all keyslots that match the given old password */
} else if (opts_luks->has_old_secret) { } else if (opts_luks->old_secret) {
unsigned long slots_to_erase_bitmap = 0; unsigned long slots_to_erase_bitmap = 0;
size_t i; size_t i;

29
docs/devel/qapi-code-gen.rst
View File

@ -1357,7 +1357,7 @@ qmp_my_command(); everything else is produced by the generator. ::
$ cat example-schema.json $ cat example-schema.json
{ 'struct': 'UserDefOne', { 'struct': 'UserDefOne',
'data': { 'integer': 'int', '*string': 'str' } } 'data': { 'integer': 'int', '*string': 'str', '*flag': 'bool' } }
{ 'command': 'my-command', { 'command': 'my-command',
'data': { 'arg1': ['UserDefOne'] }, 'data': { 'arg1': ['UserDefOne'] },
@ -1410,8 +1410,9 @@ Example::
struct UserDefOne { struct UserDefOne {
int64_t integer; int64_t integer;
bool has_string;
char *string; char *string;
bool has_flag;
bool flag;
}; };
void qapi_free_UserDefOne(UserDefOne *obj); void qapi_free_UserDefOne(UserDefOne *obj);
@ -1523,14 +1524,21 @@ Example::
bool visit_type_UserDefOne_members(Visitor *v, UserDefOne *obj, Error **errp) bool visit_type_UserDefOne_members(Visitor *v, UserDefOne *obj, Error **errp)
{ {
bool has_string = !!obj->string;
if (!visit_type_int(v, "integer", &obj->integer, errp)) { if (!visit_type_int(v, "integer", &obj->integer, errp)) {
return false; return false;
} }
if (visit_optional(v, "string", &obj->has_string)) { if (visit_optional(v, "string", &has_string)) {
if (!visit_type_str(v, "string", &obj->string, errp)) { if (!visit_type_str(v, "string", &obj->string, errp)) {
return false; return false;
} }
} }
if (visit_optional(v, "flag", &obj->has_flag)) {
if (!visit_type_bool(v, "flag", &obj->flag, errp)) {
return false;
}
}
return true; return true;
} }
@ -1664,7 +1672,6 @@ Example::
$ cat qapi-generated/example-qapi-commands.c $ cat qapi-generated/example-qapi-commands.c
[Uninteresting stuff omitted...] [Uninteresting stuff omitted...]
static void qmp_marshal_output_UserDefOne(UserDefOne *ret_in, static void qmp_marshal_output_UserDefOne(UserDefOne *ret_in,
QObject **ret_out, Error **errp) QObject **ret_out, Error **errp)
{ {
@ -1748,7 +1755,7 @@ Example::
QTAILQ_INIT(cmds); QTAILQ_INIT(cmds);
qmp_register_command(cmds, "my-command", qmp_register_command(cmds, "my-command",
qmp_marshal_my_command, QCO_NO_OPTIONS); qmp_marshal_my_command, 0, 0);
} }
[Uninteresting stuff omitted...] [Uninteresting stuff omitted...]
@ -1917,6 +1924,12 @@ Example::
{ "type", QLIT_QSTR("str"), }, { "type", QLIT_QSTR("str"), },
{} {}
})), })),
QLIT_QDICT(((QLitDictEntry[]) {
{ "default", QLIT_QNULL, },
{ "name", QLIT_QSTR("flag"), },
{ "type", QLIT_QSTR("bool"), },
{}
})),
{} {}
})), }, })), },
{ "meta-type", QLIT_QSTR("object"), }, { "meta-type", QLIT_QSTR("object"), },
@ -1950,6 +1963,12 @@ Example::
{ "name", QLIT_QSTR("str"), }, { "name", QLIT_QSTR("str"), },
{} {}
})), })),
QLIT_QDICT(((QLitDictEntry[]) {
{ "json-type", QLIT_QSTR("boolean"), },
{ "meta-type", QLIT_QSTR("builtin"), },
{ "name", QLIT_QSTR("bool"), },
{}
})),
{} {}
})); }));

14
docs/devel/writing-monitor-commands.rst
View File

@ -166,9 +166,9 @@ and user defined types.
Now, let's update our C implementation in monitor/qmp-cmds.c:: Now, let's update our C implementation in monitor/qmp-cmds.c::
void qmp_hello_world(bool has_message, const char *message, Error **errp) void qmp_hello_world(const char *message, Error **errp)
{ {
if (has_message) { if (message) {
printf("%s\n", message); printf("%s\n", message);
} else { } else {
printf("Hello, world\n"); printf("Hello, world\n");
@ -210,9 +210,9 @@ file. Basically, most errors are set by calling the error_setg() function.
Let's say we don't accept the string "message" to contain the word "love". If Let's say we don't accept the string "message" to contain the word "love". If
it does contain it, we want the "hello-world" command to return an error:: it does contain it, we want the "hello-world" command to return an error::
void qmp_hello_world(bool has_message, const char *message, Error **errp) void qmp_hello_world(const char *message, Error **errp)
{ {
if (has_message) { if (message) {
if (strstr(message, "love")) { if (strstr(message, "love")) {
error_setg(errp, "the word 'love' is not allowed"); error_setg(errp, "the word 'love' is not allowed");
return; return;
@ -467,9 +467,9 @@ There are a number of things to be noticed:
allocated by the regular g_malloc0() function. Note that we chose to allocated by the regular g_malloc0() function. Note that we chose to
initialize the memory to zero. This is recommended for all QAPI types, as initialize the memory to zero. This is recommended for all QAPI types, as
it helps avoiding bad surprises (specially with booleans) it helps avoiding bad surprises (specially with booleans)
4. Remember that "next_deadline" is optional? All optional members have a 4. Remember that "next_deadline" is optional? Non-pointer optional
'has_TYPE_NAME' member that should be properly set by the implementation, members have a 'has_TYPE_NAME' member that should be properly set
as shown above by the implementation, as shown above
5. Even static strings, such as "alarm_timer->name", should be dynamically 5. Even static strings, such as "alarm_timer->name", should be dynamically
allocated by the implementation. This is so because the QAPI also generates allocated by the implementation. This is so because the QAPI also generates
a function to free its types and it cannot distinguish between dynamically a function to free its types and it cannot distinguish between dynamically

4
dump/dump.c
View File

@ -2044,8 +2044,8 @@ static void dump_process(DumpState *s, Error **errp)
result = qmp_query_dump(NULL); result = qmp_query_dump(NULL);
/* should never fail */ /* should never fail */
assert(result); assert(result);
qapi_event_send_dump_completed(result, !!*errp, (*errp ? qapi_event_send_dump_completed(result,
error_get_pretty(*errp) : NULL)); *errp ? error_get_pretty(*errp) : NULL);
qapi_free_DumpQueryResult(result); qapi_free_DumpQueryResult(result);
dump_cleanup(s); dump_cleanup(s);

14
hw/acpi/core.c
View File

@ -185,7 +185,7 @@ static void acpi_table_install(const char unsigned *blob, size_t bloblen,
changed_fields = 0; changed_fields = 0;
ext_hdr->_length = cpu_to_le16(acpi_payload_size); ext_hdr->_length = cpu_to_le16(acpi_payload_size);
if (hdrs->has_sig) { if (hdrs->sig) {
strncpy(ext_hdr->sig, hdrs->sig, sizeof ext_hdr->sig); strncpy(ext_hdr->sig, hdrs->sig, sizeof ext_hdr->sig);
++changed_fields; ++changed_fields;
} }
@ -204,11 +204,11 @@ static void acpi_table_install(const char unsigned *blob, size_t bloblen,
ext_hdr->checksum = 0; ext_hdr->checksum = 0;
if (hdrs->has_oem_id) { if (hdrs->oem_id) {
strncpy(ext_hdr->oem_id, hdrs->oem_id, sizeof ext_hdr->oem_id); strncpy(ext_hdr->oem_id, hdrs->oem_id, sizeof ext_hdr->oem_id);
++changed_fields; ++changed_fields;
} }
if (hdrs->has_oem_table_id) { if (hdrs->oem_table_id) {
strncpy(ext_hdr->oem_table_id, hdrs->oem_table_id, strncpy(ext_hdr->oem_table_id, hdrs->oem_table_id,
sizeof ext_hdr->oem_table_id); sizeof ext_hdr->oem_table_id);
++changed_fields; ++changed_fields;
@ -217,7 +217,7 @@ static void acpi_table_install(const char unsigned *blob, size_t bloblen,
ext_hdr->oem_revision = cpu_to_le32(hdrs->oem_rev); ext_hdr->oem_revision = cpu_to_le32(hdrs->oem_rev);
++changed_fields; ++changed_fields;
} }
if (hdrs->has_asl_compiler_id) { if (hdrs->asl_compiler_id) {
strncpy(ext_hdr->asl_compiler_id, hdrs->asl_compiler_id, strncpy(ext_hdr->asl_compiler_id, hdrs->asl_compiler_id,
sizeof ext_hdr->asl_compiler_id); sizeof ext_hdr->asl_compiler_id);
++changed_fields; ++changed_fields;
@ -255,12 +255,12 @@ void acpi_table_add(const QemuOpts *opts, Error **errp)
if (!hdrs) { if (!hdrs) {
goto out; goto out;
} }
if (hdrs->has_file == hdrs->has_data) { if (!hdrs->file == !hdrs->data) {
error_setg(errp, "'-acpitable' requires one of 'data' or 'file'"); error_setg(errp, "'-acpitable' requires one of 'data' or 'file'");
goto out; goto out;
} }
pathnames = g_strsplit(hdrs->has_file ? hdrs->file : hdrs->data, ":", 0); pathnames = g_strsplit(hdrs->file ?: hdrs->data, ":", 0);
if (pathnames == NULL || pathnames[0] == NULL) { if (pathnames == NULL || pathnames[0] == NULL) {
error_setg(errp, "'-acpitable' requires at least one pathname"); error_setg(errp, "'-acpitable' requires at least one pathname");
goto out; goto out;
@ -297,7 +297,7 @@ void acpi_table_add(const QemuOpts *opts, Error **errp)
close(fd); close(fd);
} }
acpi_table_install(blob, bloblen, hdrs->has_file, hdrs, errp); acpi_table_install(blob, bloblen, !!hdrs->file, hdrs, errp);
out: out:
g_free(blob); g_free(blob);

1
hw/acpi/cpu.c
View File

@ -35,7 +35,6 @@ static ACPIOSTInfo *acpi_cpu_device_status(int idx, AcpiCpuStatus *cdev)
DeviceState *dev = DEVICE(cdev->cpu); DeviceState *dev = DEVICE(cdev->cpu);
if (dev->id) { if (dev->id) {
info->device = g_strdup(dev->id); info->device = g_strdup(dev->id);
info->has_device = true;
} }
} }
return info; return info;

3
hw/acpi/memory_hotplug.c
View File

@ -44,7 +44,6 @@ static ACPIOSTInfo *acpi_memory_device_status(int slot, MemStatus *mdev)
DeviceState *dev = DEVICE(mdev->dimm); DeviceState *dev = DEVICE(mdev->dimm);
if (dev->id) { if (dev->id) {
info->device = g_strdup(dev->id); info->device = g_strdup(dev->id);
info->has_device = true;
} }
} }
return info; return info;
@ -186,7 +185,7 @@ static void acpi_memory_hotplug_write(void *opaque, hwaddr addr, uint64_t data,
*/ */
qapi_event_send_mem_unplug_error(dev->id ? : "", qapi_event_send_mem_unplug_error(dev->id ? : "",
error_get_pretty(local_err)); error_get_pretty(local_err));
qapi_event_send_device_unplug_guest_error(!!dev->id, dev->id, qapi_event_send_device_unplug_guest_error(dev->id,
dev->canonical_path); dev->canonical_path);
error_free(local_err); error_free(local_err);
break; break;

2
hw/core/machine-hmp-cmds.c
View File

@ -62,7 +62,7 @@ void hmp_hotpluggable_cpus(Monitor *mon, const QDict *qdict)
monitor_printf(mon, " type: \"%s\"\n", l->value->type); monitor_printf(mon, " type: \"%s\"\n", l->value->type);
monitor_printf(mon, " vcpus_count: \"%" PRIu64 "\"\n", monitor_printf(mon, " vcpus_count: \"%" PRIu64 "\"\n",
l->value->vcpus_count); l->value->vcpus_count);
if (l->value->has_qom_path) { if (l->value->qom_path) {
monitor_printf(mon, " qom_path: \"%s\"\n", l->value->qom_path); monitor_printf(mon, " qom_path: \"%s\"\n", l->value->qom_path);
} }

9
hw/core/machine-qmp-cmds.c
View File

@ -55,8 +55,7 @@ CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
value->qom_path = object_get_canonical_path(OBJECT(cpu)); value->qom_path = object_get_canonical_path(OBJECT(cpu));
value->thread_id = cpu->thread_id; value->thread_id = cpu->thread_id;
value->has_props = !!mc->cpu_index_to_instance_props; if (mc->cpu_index_to_instance_props) {
if (value->has_props) {
CpuInstanceProperties *props; CpuInstanceProperties *props;
props = g_malloc0(sizeof(*props)); props = g_malloc0(sizeof(*props));
*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index); *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
@ -90,7 +89,6 @@ MachineInfoList *qmp_query_machines(Error **errp)
} }
if (mc->alias) { if (mc->alias) {
info->has_alias = true;
info->alias = g_strdup(mc->alias); info->alias = g_strdup(mc->alias);
} }
@ -101,11 +99,9 @@ MachineInfoList *qmp_query_machines(Error **errp)
info->deprecated = !!mc->deprecation_reason; info->deprecated = !!mc->deprecation_reason;
if (mc->default_cpu_type) { if (mc->default_cpu_type) {
info->default_cpu_type = g_strdup(mc->default_cpu_type); info->default_cpu_type = g_strdup(mc->default_cpu_type);
info->has_default_cpu_type = true;
} }
if (mc->default_ram_id) { if (mc->default_ram_id) {
info->default_ram_id = g_strdup(mc->default_ram_id); info->default_ram_id = g_strdup(mc->default_ram_id);
info->has_default_ram_id = true;
} }
QAPI_LIST_PREPEND(mach_list, info); QAPI_LIST_PREPEND(mach_list, info);
@ -168,7 +164,6 @@ static int query_memdev(Object *obj, void *opaque)
m = g_malloc0(sizeof(*m)); m = g_malloc0(sizeof(*m));
m->id = g_strdup(object_get_canonical_path_component(obj)); m->id = g_strdup(object_get_canonical_path_component(obj));
m->has_id = !!m->id;
m->size = object_property_get_uint(obj, "size", &error_abort); m->size = object_property_get_uint(obj, "size", &error_abort);
m->merge = object_property_get_bool(obj, "merge", &error_abort); m->merge = object_property_get_bool(obj, "merge", &error_abort);
@ -227,7 +222,7 @@ HumanReadableText *qmp_x_query_numa(Error **errp)
for (i = 0; i < nb_numa_nodes; i++) { for (i = 0; i < nb_numa_nodes; i++) {
g_string_append_printf(buf, "node %d cpus:", i); g_string_append_printf(buf, "node %d cpus:", i);
for (cpu = cpu_list; cpu; cpu = cpu->next) { for (cpu = cpu_list; cpu; cpu = cpu->next) {
if (cpu->value->has_props && cpu->value->props->has_node_id && if (cpu->value->props && cpu->value->props->has_node_id &&
cpu->value->props->node_id == i) { cpu->value->props->node_id == i) {
g_string_append_printf(buf, " %" PRIi64, cpu->value->cpu_index); g_string_append_printf(buf, " %" PRIi64, cpu->value->cpu_index);
} }

10
hw/core/machine.c
View File

@ -684,7 +684,6 @@ HotpluggableCPUList *machine_query_hotpluggable_cpus(MachineState *machine)
cpu = machine->possible_cpus->cpus[i].cpu; cpu = machine->possible_cpus->cpus[i].cpu;
if (cpu) { if (cpu) {
cpu_item->has_qom_path = true;
cpu_item->qom_path = object_get_canonical_path(cpu); cpu_item->qom_path = object_get_canonical_path(cpu);
} }
QAPI_LIST_PREPEND(head, cpu_item); QAPI_LIST_PREPEND(head, cpu_item);
@ -873,8 +872,7 @@ static void machine_copy_boot_config(MachineState *ms, BootConfiguration *config
machine_free_boot_config(ms); machine_free_boot_config(ms);
ms->boot_config = *config; ms->boot_config = *config;
if (!config->has_order) { if (!config->order) {
ms->boot_config.has_order = true;
ms->boot_config.order = g_strdup(machine_class->default_boot_order); ms->boot_config.order = g_strdup(machine_class->default_boot_order);
} }
} }
@ -889,13 +887,13 @@ static void machine_set_boot(Object *obj, Visitor *v, const char *name,
if (!visit_type_BootConfiguration(v, name, &config, errp)) { if (!visit_type_BootConfiguration(v, name, &config, errp)) {
return; return;
} }
if (config->has_order) { if (config->order) {
validate_bootdevices(config->order, errp); validate_bootdevices(config->order, errp);
if (*errp) { if (*errp) {
goto out_free; goto out_free;
} }
} }
if (config->has_once) { if (config->once) {
validate_bootdevices(config->once, errp); validate_bootdevices(config->once, errp);
if (*errp) { if (*errp) {
goto out_free; goto out_free;
@ -1424,7 +1422,7 @@ void qdev_machine_creation_done(void)
{ {
cpu_synchronize_all_post_init(); cpu_synchronize_all_post_init();
if (current_machine->boot_config.has_once) { if (current_machine->boot_config.once) {
qemu_boot_set(current_machine->boot_config.once, &error_fatal); qemu_boot_set(current_machine->boot_config.once, &error_fatal);
qemu_register_reset(restore_boot_order, g_strdup(current_machine->boot_config.order)); qemu_register_reset(restore_boot_order, g_strdup(current_machine->boot_config.order));
} }

8
hw/core/numa.c
View File

@ -130,9 +130,9 @@ static void parse_numa_node(MachineState *ms, NumaNodeOptions *node,
} }
} }
have_memdevs = have_memdevs ? : node->has_memdev; have_memdevs = have_memdevs || node->memdev;
have_mem = have_mem ? : node->has_mem; have_mem = have_mem || node->has_mem;
if ((node->has_mem && have_memdevs) || (node->has_memdev && have_mem)) { if ((node->has_mem && have_memdevs) || (node->memdev && have_mem)) {
error_setg(errp, "numa configuration should use either mem= or memdev=," error_setg(errp, "numa configuration should use either mem= or memdev=,"
"mixing both is not allowed"); "mixing both is not allowed");
return; return;
@ -152,7 +152,7 @@ static void parse_numa_node(MachineState *ms, NumaNodeOptions *node,
" use -numa node,memdev instead"); " use -numa node,memdev instead");
} }
} }
if (node->has_memdev) { if (node->memdev) {
Object *o; Object *o;
o = object_resolve_path_type(node->memdev, TYPE_MEMORY_BACKEND, NULL); o = object_resolve_path_type(node->memdev, TYPE_MEMORY_BACKEND, NULL);
if (!o) { if (!o) {

2
hw/core/qdev.c
View File

@ -757,7 +757,7 @@ static void device_finalize(Object *obj)
if (dev->pending_deleted_event) { if (dev->pending_deleted_event) {
g_assert(dev->canonical_path); g_assert(dev->canonical_path);
qapi_event_send_device_deleted(!!dev->id, dev->id, dev->canonical_path); qapi_event_send_device_deleted(dev->id, dev->canonical_path);
g_free(dev->canonical_path); g_free(dev->canonical_path);
dev->canonical_path = NULL; dev->canonical_path = NULL;
} }

1
hw/mem/pc-dimm.c
View File

@ -252,7 +252,6 @@ static void pc_dimm_md_fill_device_info(const MemoryDeviceState *md,
const DeviceState *dev = DEVICE(md); const DeviceState *dev = DEVICE(md);
if (dev->id) { if (dev->id) {
di->has_id = true;
di->id = g_strdup(dev->id); di->id = g_strdup(dev->id);
} }
di->hotplugged = dev->hotplugged; di->hotplugged = dev->hotplugged;

13
hw/net/rocker/rocker_of_dpa.c
View File

@ -2348,23 +2348,19 @@ static void of_dpa_flow_fill(void *cookie, void *value, void *user_data)
if (memcmp(key->eth.src.a, zero_mac.a, ETH_ALEN) || if (memcmp(key->eth.src.a, zero_mac.a, ETH_ALEN) ||
memcmp(mask->eth.src.a, zero_mac.a, ETH_ALEN)) { memcmp(mask->eth.src.a, zero_mac.a, ETH_ALEN)) {
nkey->has_eth_src = true;
nkey->eth_src = qemu_mac_strdup_printf(key->eth.src.a); nkey->eth_src = qemu_mac_strdup_printf(key->eth.src.a);
} }
if (nkey->has_eth_src && memcmp(mask->eth.src.a, ff_mac.a, ETH_ALEN)) { if (nkey->eth_src && memcmp(mask->eth.src.a, ff_mac.a, ETH_ALEN)) {
nmask->has_eth_src = true;
nmask->eth_src = qemu_mac_strdup_printf(mask->eth.src.a); nmask->eth_src = qemu_mac_strdup_printf(mask->eth.src.a);
} }
if (memcmp(key->eth.dst.a, zero_mac.a, ETH_ALEN) || if (memcmp(key->eth.dst.a, zero_mac.a, ETH_ALEN) ||
memcmp(mask->eth.dst.a, zero_mac.a, ETH_ALEN)) { memcmp(mask->eth.dst.a, zero_mac.a, ETH_ALEN)) {
nkey->has_eth_dst = true;
nkey->eth_dst = qemu_mac_strdup_printf(key->eth.dst.a); nkey->eth_dst = qemu_mac_strdup_printf(key->eth.dst.a);
} }
if (nkey->has_eth_dst && memcmp(mask->eth.dst.a, ff_mac.a, ETH_ALEN)) { if (nkey->eth_dst && memcmp(mask->eth.dst.a, ff_mac.a, ETH_ALEN)) {
nmask->has_eth_dst = true;
nmask->eth_dst = qemu_mac_strdup_printf(mask->eth.dst.a); nmask->eth_dst = qemu_mac_strdup_printf(mask->eth.dst.a);
} }
@ -2400,7 +2396,6 @@ static void of_dpa_flow_fill(void *cookie, void *value, void *user_data)
if (key->ipv4.addr.dst || mask->ipv4.addr.dst) { if (key->ipv4.addr.dst || mask->ipv4.addr.dst) {
char *dst = inet_ntoa(*(struct in_addr *)&key->ipv4.addr.dst); char *dst = inet_ntoa(*(struct in_addr *)&key->ipv4.addr.dst);
int dst_len = of_dpa_mask2prefix(mask->ipv4.addr.dst); int dst_len = of_dpa_mask2prefix(mask->ipv4.addr.dst);
nkey->has_ip_dst = true;
nkey->ip_dst = g_strdup_printf("%s/%d", dst, dst_len); nkey->ip_dst = g_strdup_printf("%s/%d", dst, dst_len);
} }
break; break;
@ -2501,12 +2496,10 @@ static void of_dpa_group_fill(void *key, void *value, void *user_data)
ngroup->set_vlan_id = ntohs(group->l2_rewrite.vlan_id); ngroup->set_vlan_id = ntohs(group->l2_rewrite.vlan_id);
} }
if (memcmp(group->l2_rewrite.src_mac.a, zero_mac.a, ETH_ALEN)) { if (memcmp(group->l2_rewrite.src_mac.a, zero_mac.a, ETH_ALEN)) {
ngroup->has_set_eth_src = true;
ngroup->set_eth_src = ngroup->set_eth_src =
qemu_mac_strdup_printf(group->l2_rewrite.src_mac.a); qemu_mac_strdup_printf(group->l2_rewrite.src_mac.a);
} }
if (memcmp(group->l2_rewrite.dst_mac.a, zero_mac.a, ETH_ALEN)) { if (memcmp(group->l2_rewrite.dst_mac.a, zero_mac.a, ETH_ALEN)) {
ngroup->has_set_eth_dst = true;
ngroup->set_eth_dst = ngroup->set_eth_dst =
qemu_mac_strdup_printf(group->l2_rewrite.dst_mac.a); qemu_mac_strdup_printf(group->l2_rewrite.dst_mac.a);
} }
@ -2532,12 +2525,10 @@ static void of_dpa_group_fill(void *key, void *value, void *user_data)
ngroup->set_vlan_id = ntohs(group->l3_unicast.vlan_id); ngroup->set_vlan_id = ntohs(group->l3_unicast.vlan_id);
} }
if (memcmp(group->l3_unicast.src_mac.a, zero_mac.a, ETH_ALEN)) { if (memcmp(group->l3_unicast.src_mac.a, zero_mac.a, ETH_ALEN)) {
ngroup->has_set_eth_src = true;
ngroup->set_eth_src = ngroup->set_eth_src =
qemu_mac_strdup_printf(group->l3_unicast.src_mac.a); qemu_mac_strdup_printf(group->l3_unicast.src_mac.a);
} }
if (memcmp(group->l3_unicast.dst_mac.a, zero_mac.a, ETH_ALEN)) { if (memcmp(group->l3_unicast.dst_mac.a, zero_mac.a, ETH_ALEN)) {
ngroup->has_set_eth_dst = true;
ngroup->set_eth_dst = ngroup->set_eth_dst =
qemu_mac_strdup_printf(group->l3_unicast.dst_mac.a); qemu_mac_strdup_printf(group->l3_unicast.dst_mac.a);
} }

3
hw/net/virtio-net.c
View File

@ -457,8 +457,7 @@ static void rxfilter_notify(NetClientState *nc)
if (nc->rxfilter_notify_enabled) { if (nc->rxfilter_notify_enabled) {
char *path = object_get_canonical_path(OBJECT(n->qdev)); char *path = object_get_canonical_path(OBJECT(n->qdev));
qapi_event_send_nic_rx_filter_changed(!!n->netclient_name, qapi_event_send_nic_rx_filter_changed(n->netclient_name, path);
n->netclient_name, path);
g_free(path); g_free(path);
/* disable event notification to avoid events flooding */ /* disable event notification to avoid events flooding */

2
hw/nvram/fw_cfg.c
View File

@ -201,7 +201,7 @@ static void fw_cfg_bootsplash(FWCfgState *s)
} }
/* insert splash file if user configurated */ /* insert splash file if user configurated */
if (current_machine->boot_config.has_splash) { if (current_machine->boot_config.splash) {
const char *boot_splash_filename = current_machine->boot_config.splash; const char *boot_splash_filename = current_machine->boot_config.splash;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, boot_splash_filename); filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, boot_splash_filename);
if (filename == NULL) { if (filename == NULL) {

2
hw/pci/pci.c
View File

@ -1879,7 +1879,6 @@ static PciDeviceInfo *qmp_query_pci_device(PCIDevice *dev, PCIBus *bus,
info->class_info->q_class = class; info->class_info->q_class = class;
desc = get_class_desc(class); desc = get_class_desc(class);
if (desc->desc) { if (desc->desc) {
info->class_info->has_desc = true;
info->class_info->desc = g_strdup(desc->desc); info->class_info->desc = g_strdup(desc->desc);
} }
@ -1897,7 +1896,6 @@ static PciDeviceInfo *qmp_query_pci_device(PCIDevice *dev, PCIBus *bus,
type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION; type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION;
if (type == PCI_HEADER_TYPE_BRIDGE) { if (type == PCI_HEADER_TYPE_BRIDGE) {
info->has_pci_bridge = true;
info->pci_bridge = qmp_query_pci_bridge(dev, bus, bus_num); info->pci_bridge = qmp_query_pci_bridge(dev, bus, bus_num);
} else if (type == PCI_HEADER_TYPE_NORMAL) { } else if (type == PCI_HEADER_TYPE_NORMAL) {
info->id->has_subsystem = info->id->has_subsystem_vendor = true; info->id->has_subsystem = info->id->has_subsystem_vendor = true;

2
hw/ppc/spapr.c
View File

@ -3728,7 +3728,7 @@ void spapr_memory_unplug_rollback(SpaprMachineState *spapr, DeviceState *dev)
qapi_event_send_mem_unplug_error(dev->id ? : "", qapi_error); qapi_event_send_mem_unplug_error(dev->id ? : "", qapi_error);
qapi_event_send_device_unplug_guest_error(!!dev->id, dev->id, qapi_event_send_device_unplug_guest_error(dev->id,
dev->canonical_path); dev->canonical_path);
} }

3
hw/ppc/spapr_drc.c
View File

@ -175,8 +175,7 @@ static uint32_t drc_unisolate_logical(SpaprDrc *drc)
"for device %s", drc->dev->id); "for device %s", drc->dev->id);
} }
qapi_event_send_device_unplug_guest_error(!!drc->dev->id, qapi_event_send_device_unplug_guest_error(drc->dev->id,
drc->dev->id,
drc->dev->canonical_path); drc->dev->canonical_path);
} }

4
hw/virtio/virtio-mem-pci.c
View File

@ -65,7 +65,6 @@ static void virtio_mem_pci_fill_device_info(const MemoryDeviceState *md,
DeviceState *dev = DEVICE(md); DeviceState *dev = DEVICE(md);
if (dev->id) { if (dev->id) {
vi->has_id = true;
vi->id = g_strdup(dev->id); vi->id = g_strdup(dev->id);
} }
@ -90,8 +89,7 @@ static void virtio_mem_pci_size_change_notify(Notifier *notifier, void *data)
char *qom_path = object_get_canonical_path(OBJECT(dev)); char *qom_path = object_get_canonical_path(OBJECT(dev));
const uint64_t * const size_p = data; const uint64_t * const size_p = data;
qapi_event_send_memory_device_size_change(!!dev->id, dev->id, *size_p, qapi_event_send_memory_device_size_change(dev->id, *size_p, qom_path);
qom_path);
g_free(qom_path); g_free(qom_path);
} }

1
hw/virtio/virtio-pmem-pci.c
View File

@ -70,7 +70,6 @@ static void virtio_pmem_pci_fill_device_info(const MemoryDeviceState *md,
DeviceState *dev = DEVICE(md); DeviceState *dev = DEVICE(md);
if (dev->id) { if (dev->id) {
vi->has_id = true;
vi->id = g_strdup(dev->id); vi->id = g_strdup(dev->id);
} }

1
hw/virtio/virtio.c
View File

@ -4701,7 +4701,6 @@ VirtioStatus *qmp_x_query_virtio_status(const char *path, Error **errp)
status->disable_legacy_check = vdev->disable_legacy_check; status->disable_legacy_check = vdev->disable_legacy_check;
status->bus_name = g_strdup(vdev->bus_name); status->bus_name = g_strdup(vdev->bus_name);
status->use_guest_notifier_mask = vdev->use_guest_notifier_mask; status->use_guest_notifier_mask = vdev->use_guest_notifier_mask;
status->has_vhost_dev = vdev->vhost_started;
if (vdev->vhost_started) { if (vdev->vhost_started) {
VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);

3
include/monitor/monitor.h
View File

@ -46,8 +46,7 @@ int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
void *opaque); void *opaque);
AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id, AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
bool has_opaque, const char *opaque, const char *opaque, Error **errp);
Error **errp);
int monitor_fdset_dup_fd_add(int64_t fdset_id, int flags); int monitor_fdset_dup_fd_add(int64_t fdset_id, int flags);
void monitor_fdset_dup_fd_remove(int dup_fd); void monitor_fdset_dup_fd_remove(int dup_fd);
int64_t monitor_fdset_dup_fd_find(int dup_fd); int64_t monitor_fdset_dup_fd_find(int dup_fd);

3
job-qmp.c
View File

@ -156,8 +156,7 @@ static JobInfo *job_query_single_locked(Job *job, Error **errp)
.status = job->status, .status = job->status,
.current_progress = progress_current, .current_progress = progress_current,
.total_progress = progress_total, .total_progress = progress_total,
.has_error = !!job->err, .error = job->err ?
.error = job->err ? \
g_strdup(error_get_pretty(job->err)) : NULL, g_strdup(error_get_pretty(job->err)) : NULL,
}; };

4
migration/block-dirty-bitmap.c
View File

@ -551,7 +551,7 @@ static int add_bitmaps_to_list(DBMSaveState *s, BlockDriverState *bs,
} }
bitmap_alias = bmap_inner->alias; bitmap_alias = bmap_inner->alias;
if (bmap_inner->has_transform) { if (bmap_inner->transform) {
bitmap_transform = bmap_inner->transform; bitmap_transform = bmap_inner->transform;
} }
} else { } else {
@ -821,7 +821,7 @@ static int dirty_bitmap_load_start(QEMUFile *f, DBMLoadState *s)
} }
if (s->bmap_inner && if (s->bmap_inner &&
s->bmap_inner->has_transform && s->bmap_inner->transform &&
s->bmap_inner->transform->has_persistent) { s->bmap_inner->transform->has_persistent) {
persistent = s->bmap_inner->transform->persistent; persistent = s->bmap_inner->transform->persistent;
} else { } else {

1
migration/colo.c
View File

@ -250,7 +250,6 @@ ReplicationStatus *qmp_query_xen_replication_status(Error **errp)
replication_get_error_all(&err); replication_get_error_all(&err);
if (err) { if (err) {
s->error = true; s->error = true;
s->has_desc = true;
s->desc = g_strdup(error_get_pretty(err)); s->desc = g_strdup(error_get_pretty(err));
} else { } else {
s->error = false; s->error = false;

27
migration/migration.c
View File

@ -918,11 +918,8 @@ MigrationParameters *qmp_query_migrate_parameters(Error **errp)
params->cpu_throttle_increment = s->parameters.cpu_throttle_increment; params->cpu_throttle_increment = s->parameters.cpu_throttle_increment;
params->has_cpu_throttle_tailslow = true; params->has_cpu_throttle_tailslow = true;
params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow; params->cpu_throttle_tailslow = s->parameters.cpu_throttle_tailslow;
params->has_tls_creds = true;
params->tls_creds = g_strdup(s->parameters.tls_creds); params->tls_creds = g_strdup(s->parameters.tls_creds);
params->has_tls_hostname = true;
params->tls_hostname = g_strdup(s->parameters.tls_hostname); params->tls_hostname = g_strdup(s->parameters.tls_hostname);
params->has_tls_authz = true;
params->tls_authz = g_strdup(s->parameters.tls_authz ? params->tls_authz = g_strdup(s->parameters.tls_authz ?
s->parameters.tls_authz : ""); s->parameters.tls_authz : "");
params->has_max_bandwidth = true; params->has_max_bandwidth = true;
@ -1047,7 +1044,6 @@ static void populate_ram_info(MigrationInfo *info, MigrationState *s)
{ {
size_t page_size = qemu_target_page_size(); size_t page_size = qemu_target_page_size();
info->has_ram = true;
info->ram = g_malloc0(sizeof(*info->ram)); info->ram = g_malloc0(sizeof(*info->ram));
info->ram->transferred = ram_counters.transferred; info->ram->transferred = ram_counters.transferred;
info->ram->total = ram_bytes_total(); info->ram->total = ram_bytes_total();
@ -1069,7 +1065,6 @@ static void populate_ram_info(MigrationInfo *info, MigrationState *s)
info->ram->postcopy_bytes = ram_counters.postcopy_bytes; info->ram->postcopy_bytes = ram_counters.postcopy_bytes;
if (migrate_use_xbzrle()) { if (migrate_use_xbzrle()) {
info->has_xbzrle_cache = true;
info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache)); info->xbzrle_cache = g_malloc0(sizeof(*info->xbzrle_cache));
info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size(); info->xbzrle_cache->cache_size = migrate_xbzrle_cache_size();
info->xbzrle_cache->bytes = xbzrle_counters.bytes; info->xbzrle_cache->bytes = xbzrle_counters.bytes;
@ -1081,7 +1076,6 @@ static void populate_ram_info(MigrationInfo *info, MigrationState *s)
} }
if (migrate_use_compression()) { if (migrate_use_compression()) {
info->has_compression = true;
info->compression = g_malloc0(sizeof(*info->compression)); info->compression = g_malloc0(sizeof(*info->compression));
info->compression->pages = compression_counters.pages; info->compression->pages = compression_counters.pages;
info->compression->busy = compression_counters.busy; info->compression->busy = compression_counters.busy;
@ -1106,7 +1100,6 @@ static void populate_ram_info(MigrationInfo *info, MigrationState *s)
static void populate_disk_info(MigrationInfo *info) static void populate_disk_info(MigrationInfo *info)
{ {
if (blk_mig_active()) { if (blk_mig_active()) {
info->has_disk = true;
info->disk = g_malloc0(sizeof(*info->disk)); info->disk = g_malloc0(sizeof(*info->disk));
info->disk->transferred = blk_mig_bytes_transferred(); info->disk->transferred = blk_mig_bytes_transferred();
info->disk->remaining = blk_mig_bytes_remaining(); info->disk->remaining = blk_mig_bytes_remaining();
@ -1171,7 +1164,6 @@ static void fill_source_migration_info(MigrationInfo *info)
case MIGRATION_STATUS_FAILED: case MIGRATION_STATUS_FAILED:
info->has_status = true; info->has_status = true;
if (s->error) { if (s->error) {
info->has_error_desc = true;
info->error_desc = g_strdup(error_get_pretty(s->error)); info->error_desc = g_strdup(error_get_pretty(s->error));
} }
break; break;
@ -1575,7 +1567,7 @@ static bool migrate_params_check(MigrationParameters *params, Error **errp)
#ifdef CONFIG_LINUX #ifdef CONFIG_LINUX
if (migrate_use_zero_copy_send() && if (migrate_use_zero_copy_send() &&
((params->has_multifd_compression && params->multifd_compression) || ((params->has_multifd_compression && params->multifd_compression) ||
(params->has_tls_creds && params->tls_creds && *params->tls_creds))) { (params->tls_creds && *params->tls_creds))) {
error_setg(errp, error_setg(errp,
"Zero copy only available for non-compressed non-TLS multifd migration"); "Zero copy only available for non-compressed non-TLS multifd migration");
return false; return false;
@ -1624,12 +1616,12 @@ static void migrate_params_test_apply(MigrateSetParameters *params,
dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow; dest->cpu_throttle_tailslow = params->cpu_throttle_tailslow;
} }
if (params->has_tls_creds) { if (params->tls_creds) {
assert(params->tls_creds->type == QTYPE_QSTRING); assert(params->tls_creds->type == QTYPE_QSTRING);
dest->tls_creds = params->tls_creds->u.s; dest->tls_creds = params->tls_creds->u.s;
} }
if (params->has_tls_hostname) { if (params->tls_hostname) {
assert(params->tls_hostname->type == QTYPE_QSTRING); assert(params->tls_hostname->type == QTYPE_QSTRING);
dest->tls_hostname = params->tls_hostname->u.s; dest->tls_hostname = params->tls_hostname->u.s;
} }
@ -1721,19 +1713,19 @@ static void migrate_params_apply(MigrateSetParameters *params, Error **errp)
s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow; s->parameters.cpu_throttle_tailslow = params->cpu_throttle_tailslow;
} }
if (params->has_tls_creds) { if (params->tls_creds) {
g_free(s->parameters.tls_creds); g_free(s->parameters.tls_creds);
assert(params->tls_creds->type == QTYPE_QSTRING); assert(params->tls_creds->type == QTYPE_QSTRING);
s->parameters.tls_creds = g_strdup(params->tls_creds->u.s); s->parameters.tls_creds = g_strdup(params->tls_creds->u.s);
} }
if (params->has_tls_hostname) { if (params->tls_hostname) {
g_free(s->parameters.tls_hostname); g_free(s->parameters.tls_hostname);
assert(params->tls_hostname->type == QTYPE_QSTRING); assert(params->tls_hostname->type == QTYPE_QSTRING);
s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s); s->parameters.tls_hostname = g_strdup(params->tls_hostname->u.s);
} }
if (params->has_tls_authz) { if (params->tls_authz) {
g_free(s->parameters.tls_authz); g_free(s->parameters.tls_authz);
assert(params->tls_authz->type == QTYPE_QSTRING); assert(params->tls_authz->type == QTYPE_QSTRING);
s->parameters.tls_authz = g_strdup(params->tls_authz->u.s); s->parameters.tls_authz = g_strdup(params->tls_authz->u.s);
@ -1810,14 +1802,14 @@ void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
MigrationParameters tmp; MigrationParameters tmp;
/* TODO Rewrite "" to null instead */ /* TODO Rewrite "" to null instead */
if (params->has_tls_creds if (params->tls_creds
&& params->tls_creds->type == QTYPE_QNULL) { && params->tls_creds->type == QTYPE_QNULL) {
qobject_unref(params->tls_creds->u.n); qobject_unref(params->tls_creds->u.n);
params->tls_creds->type = QTYPE_QSTRING; params->tls_creds->type = QTYPE_QSTRING;
params->tls_creds->u.s = strdup(""); params->tls_creds->u.s = strdup("");
} }
/* TODO Rewrite "" to null instead */ /* TODO Rewrite "" to null instead */
if (params->has_tls_hostname if (params->tls_hostname
&& params->tls_hostname->type == QTYPE_QNULL) { && params->tls_hostname->type == QTYPE_QNULL) {
qobject_unref(params->tls_hostname->u.n); qobject_unref(params->tls_hostname->u.n);
params->tls_hostname->type = QTYPE_QSTRING; params->tls_hostname->type = QTYPE_QSTRING;
@ -4492,9 +4484,6 @@ static void migration_instance_init(Object *obj)
params->has_announce_max = true; params->has_announce_max = true;
params->has_announce_rounds = true; params->has_announce_rounds = true;
params->has_announce_step = true; params->has_announce_step = true;
params->has_tls_creds = true;
params->has_tls_hostname = true;
params->has_tls_authz = true;
qemu_sem_init(&ms->postcopy_pause_sem, 0); qemu_sem_init(&ms->postcopy_pause_sem, 0);
qemu_sem_init(&ms->postcopy_pause_rp_sem, 0); qemu_sem_init(&ms->postcopy_pause_rp_sem, 0);

84
monitor/hmp-cmds.c
View File

@ -104,7 +104,7 @@ void hmp_info_name(Monitor *mon, const QDict *qdict)
NameInfo *info; NameInfo *info;
info = qmp_query_name(NULL); info = qmp_query_name(NULL);
if (info->has_name) { if (info->name) {
monitor_printf(mon, "%s\n", info->name); monitor_printf(mon, "%s\n", info->name);
} }
qapi_free_NameInfo(info); qapi_free_NameInfo(info);
@ -219,8 +219,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
if (info->has_status) { if (info->has_status) {
monitor_printf(mon, "Migration status: %s", monitor_printf(mon, "Migration status: %s",
MigrationStatus_str(info->status)); MigrationStatus_str(info->status));
if (info->status == MIGRATION_STATUS_FAILED && if (info->status == MIGRATION_STATUS_FAILED && info->error_desc) {
info->has_error_desc) {
monitor_printf(mon, " (%s)\n", info->error_desc); monitor_printf(mon, " (%s)\n", info->error_desc);
} else { } else {
monitor_printf(mon, "\n"); monitor_printf(mon, "\n");
@ -242,7 +241,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
} }
} }
if (info->has_ram) { if (info->ram) {
monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n", monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
info->ram->transferred >> 10); info->ram->transferred >> 10);
monitor_printf(mon, "throughput: %0.2f mbps\n", monitor_printf(mon, "throughput: %0.2f mbps\n",
@ -295,7 +294,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
} }
} }
if (info->has_disk) { if (info->disk) {
monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n", monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
info->disk->transferred >> 10); info->disk->transferred >> 10);
monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n", monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
@ -304,7 +303,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
info->disk->total >> 10); info->disk->total >> 10);
} }
if (info->has_xbzrle_cache) { if (info->xbzrle_cache) {
monitor_printf(mon, "cache size: %" PRIu64 " bytes\n", monitor_printf(mon, "cache size: %" PRIu64 " bytes\n",
info->xbzrle_cache->cache_size); info->xbzrle_cache->cache_size);
monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n", monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n",
@ -321,7 +320,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
info->xbzrle_cache->overflow); info->xbzrle_cache->overflow);
} }
if (info->has_compression) { if (info->compression) {
monitor_printf(mon, "compression pages: %" PRIu64 " pages\n", monitor_printf(mon, "compression pages: %" PRIu64 " pages\n",
info->compression->pages); info->compression->pages);
monitor_printf(mon, "compression busy: %" PRIu64 "\n", monitor_printf(mon, "compression busy: %" PRIu64 "\n",
@ -368,7 +367,7 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
monitor_printf(mon, "]\n"); monitor_printf(mon, "]\n");
} }
if (info->has_vfio) { if (info->vfio) {
monitor_printf(mon, "vfio device transferred: %" PRIu64 " kbytes\n", monitor_printf(mon, "vfio device transferred: %" PRIu64 " kbytes\n",
info->vfio->transferred >> 10); info->vfio->transferred >> 10);
} }
@ -448,11 +447,11 @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
monitor_printf(mon, "%s: %u\n", monitor_printf(mon, "%s: %u\n",
MigrationParameter_str(MIGRATION_PARAMETER_MAX_CPU_THROTTLE), MigrationParameter_str(MIGRATION_PARAMETER_MAX_CPU_THROTTLE),
params->max_cpu_throttle); params->max_cpu_throttle);
assert(params->has_tls_creds); assert(params->tls_creds);
monitor_printf(mon, "%s: '%s'\n", monitor_printf(mon, "%s: '%s'\n",
MigrationParameter_str(MIGRATION_PARAMETER_TLS_CREDS), MigrationParameter_str(MIGRATION_PARAMETER_TLS_CREDS),
params->tls_creds); params->tls_creds);
assert(params->has_tls_hostname); assert(params->tls_hostname);
monitor_printf(mon, "%s: '%s'\n", monitor_printf(mon, "%s: '%s'\n",
MigrationParameter_str(MIGRATION_PARAMETER_TLS_HOSTNAME), MigrationParameter_str(MIGRATION_PARAMETER_TLS_HOSTNAME),
params->tls_hostname); params->tls_hostname);
@ -549,11 +548,9 @@ static void hmp_info_vnc_clients(Monitor *mon, VncClientInfoList *client)
hmp_info_VncBasicInfo(mon, qapi_VncClientInfo_base(cinfo), "Client"); hmp_info_VncBasicInfo(mon, qapi_VncClientInfo_base(cinfo), "Client");
monitor_printf(mon, " x509_dname: %s\n", monitor_printf(mon, " x509_dname: %s\n",
cinfo->has_x509_dname ? cinfo->x509_dname ?: "none");
cinfo->x509_dname : "none");
monitor_printf(mon, " sasl_username: %s\n", monitor_printf(mon, " sasl_username: %s\n",
cinfo->has_sasl_username ? cinfo->sasl_username ?: "none");
cinfo->sasl_username : "none");
client = client->next; client = client->next;
} }
@ -598,7 +595,7 @@ void hmp_info_vnc(Monitor *mon, const QDict *qdict)
hmp_info_vnc_authcrypt(mon, " ", info->auth, hmp_info_vnc_authcrypt(mon, " ", info->auth,
info->has_vencrypt ? &info->vencrypt : NULL); info->has_vencrypt ? &info->vencrypt : NULL);
} }
if (info->has_display) { if (info->display) {
monitor_printf(mon, " Display: %s\n", info->display); monitor_printf(mon, " Display: %s\n", info->display);
} }
info2l = info2l->next; info2l = info2l->next;
@ -710,7 +707,7 @@ static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
dev->slot, dev->function); dev->slot, dev->function);
monitor_printf(mon, " "); monitor_printf(mon, " ");
if (dev->class_info->has_desc) { if (dev->class_info->desc) {
monitor_puts(mon, dev->class_info->desc); monitor_puts(mon, dev->class_info->desc);
} else { } else {
monitor_printf(mon, "Class %04" PRId64, dev->class_info->q_class); monitor_printf(mon, "Class %04" PRId64, dev->class_info->q_class);
@ -728,7 +725,7 @@ static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
dev->irq, (char)('A' + dev->irq_pin - 1)); dev->irq, (char)('A' + dev->irq_pin - 1));
} }
if (dev->has_pci_bridge) { if (dev->pci_bridge) {
monitor_printf(mon, " BUS %" PRId64 ".\n", monitor_printf(mon, " BUS %" PRId64 ".\n",
dev->pci_bridge->bus->number); dev->pci_bridge->bus->number);
monitor_printf(mon, " secondary bus %" PRId64 ".\n", monitor_printf(mon, " secondary bus %" PRId64 ".\n",
@ -774,7 +771,7 @@ static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)
monitor_printf(mon, " id \"%s\"\n", dev->qdev_id); monitor_printf(mon, " id \"%s\"\n", dev->qdev_id);
if (dev->has_pci_bridge) { if (dev->pci_bridge) {
if (dev->pci_bridge->has_devices) { if (dev->pci_bridge->has_devices) {
PciDeviceInfoList *cdev; PciDeviceInfoList *cdev;
for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) { for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {
@ -865,10 +862,10 @@ void hmp_info_tpm(Monitor *mon, const QDict *qdict)
case TPM_TYPE_PASSTHROUGH: case TPM_TYPE_PASSTHROUGH:
tpo = ti->options->u.passthrough.data; tpo = ti->options->u.passthrough.data;
monitor_printf(mon, "%s%s%s%s", monitor_printf(mon, "%s%s%s%s",
tpo->has_path ? ",path=" : "", tpo->path ? ",path=" : "",
tpo->has_path ? tpo->path : "", tpo->path ?: "",
tpo->has_cancel_path ? ",cancel-path=" : "", tpo->cancel_path ? ",cancel-path=" : "",
tpo->has_cancel_path ? tpo->cancel_path : ""); tpo->cancel_path ?: "");
break; break;
case TPM_TYPE_EMULATOR: case TPM_TYPE_EMULATOR:
teo = ti->options->u.emulator.data; teo = ti->options->u.emulator.data;
@ -1105,7 +1102,6 @@ void hmp_announce_self(Monitor *mon, const QDict *qdict)
params->interfaces = strList_from_comma_list(interfaces_str); params->interfaces = strList_from_comma_list(interfaces_str);
params->has_interfaces = params->interfaces != NULL; params->has_interfaces = params->interfaces != NULL;
params->id = g_strdup(id); params->id = g_strdup(id);
params->has_id = !!params->id;
qmp_announce_self(params, NULL); qmp_announce_self(params, NULL);
qapi_free_AnnounceParameters(params); qapi_free_AnnounceParameters(params);
} }
@ -1237,19 +1233,16 @@ void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
visit_type_uint8(v, param, &p->max_cpu_throttle, &err); visit_type_uint8(v, param, &p->max_cpu_throttle, &err);
break; break;
case MIGRATION_PARAMETER_TLS_CREDS: case MIGRATION_PARAMETER_TLS_CREDS:
p->has_tls_creds = true;
p->tls_creds = g_new0(StrOrNull, 1); p->tls_creds = g_new0(StrOrNull, 1);
p->tls_creds->type = QTYPE_QSTRING; p->tls_creds->type = QTYPE_QSTRING;
visit_type_str(v, param, &p->tls_creds->u.s, &err); visit_type_str(v, param, &p->tls_creds->u.s, &err);
break; break;
case MIGRATION_PARAMETER_TLS_HOSTNAME: case MIGRATION_PARAMETER_TLS_HOSTNAME:
p->has_tls_hostname = true;
p->tls_hostname = g_new0(StrOrNull, 1); p->tls_hostname = g_new0(StrOrNull, 1);
p->tls_hostname->type = QTYPE_QSTRING; p->tls_hostname->type = QTYPE_QSTRING;
visit_type_str(v, param, &p->tls_hostname->u.s, &err); visit_type_str(v, param, &p->tls_hostname->u.s, &err);
break; break;
case MIGRATION_PARAMETER_TLS_AUTHZ: case MIGRATION_PARAMETER_TLS_AUTHZ:
p->has_tls_authz = true;
p->tls_authz = g_new0(StrOrNull, 1); p->tls_authz = g_new0(StrOrNull, 1);
p->tls_authz->type = QTYPE_QSTRING; p->tls_authz->type = QTYPE_QSTRING;
visit_type_str(v, param, &p->tls_authz->u.s, &err); visit_type_str(v, param, &p->tls_authz->u.s, &err);
@ -1361,7 +1354,7 @@ void hmp_client_migrate_info(Monitor *mon, const QDict *qdict)
qmp_client_migrate_info(protocol, hostname, qmp_client_migrate_info(protocol, hostname,
has_port, port, has_tls_port, tls_port, has_port, port, has_tls_port, tls_port,
!!cert_subject, cert_subject, &err); cert_subject, &err);
hmp_handle_error(mon, err); hmp_handle_error(mon, err);
} }
@ -1406,7 +1399,6 @@ void hmp_set_password(Monitor *mon, const QDict *qdict)
} }
if (opts.protocol == DISPLAY_PROTOCOL_VNC) { if (opts.protocol == DISPLAY_PROTOCOL_VNC) {
opts.u.vnc.has_display = !!display;
opts.u.vnc.display = (char *)display; opts.u.vnc.display = (char *)display;
} }
@ -1434,7 +1426,6 @@ void hmp_expire_password(Monitor *mon, const QDict *qdict)
} }
if (opts.protocol == DISPLAY_PROTOCOL_VNC) { if (opts.protocol == DISPLAY_PROTOCOL_VNC) {
opts.u.vnc.has_display = !!display;
opts.u.vnc.display = (char *)display; opts.u.vnc.display = (char *)display;
} }
@ -1496,8 +1487,7 @@ void hmp_change(Monitor *mon, const QDict *qdict)
} }
} }
qmp_blockdev_change_medium(true, device, false, NULL, target, qmp_blockdev_change_medium(device, NULL, target, arg, true, force,
!!arg, arg, true, force,
!!read_only, read_only_mode, !!read_only, read_only_mode,
&err); &err);
} }
@ -1520,7 +1510,7 @@ static void hmp_migrate_status_cb(void *opaque)
info = qmp_query_migrate(NULL); info = qmp_query_migrate(NULL);
if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE || if (!info->has_status || info->status == MIGRATION_STATUS_ACTIVE ||
info->status == MIGRATION_STATUS_SETUP) { info->status == MIGRATION_STATUS_SETUP) {
if (info->has_disk) { if (info->disk) {
int progress; int progress;
if (info->disk->remaining) { if (info->disk->remaining) {
@ -1538,7 +1528,7 @@ static void hmp_migrate_status_cb(void *opaque)
if (status->is_block_migration) { if (status->is_block_migration) {
monitor_printf(status->mon, "\n"); monitor_printf(status->mon, "\n");
} }
if (info->has_error_desc) { if (info->error_desc) {
error_report("%s", info->error_desc); error_report("%s", info->error_desc);
} }
monitor_resume(status->mon); monitor_resume(status->mon);
@ -1720,7 +1710,7 @@ hmp_screendump(Monitor *mon, const QDict *qdict)
goto end; goto end;
} }
qmp_screendump(filename, id != NULL, id, id != NULL, head, qmp_screendump(filename, id, id != NULL, head,
input_format != NULL, format, &err); input_format != NULL, format, &err);
end: end:
hmp_handle_error(mon, err); hmp_handle_error(mon, err);
@ -2016,35 +2006,35 @@ void hmp_rocker_of_dpa_flows(Monitor *mon, const QDict *qdict)
} }
} }
if (key->has_eth_src) { if (key->eth_src) {
if ((strcmp(key->eth_src, "01:00:00:00:00:00") == 0) && if ((strcmp(key->eth_src, "01:00:00:00:00:00") == 0) &&
(mask->has_eth_src) && mask->eth_src &&
(strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) { (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
monitor_printf(mon, " src <any mcast/bcast>"); monitor_printf(mon, " src <any mcast/bcast>");
} else if ((strcmp(key->eth_src, "00:00:00:00:00:00") == 0) && } else if ((strcmp(key->eth_src, "00:00:00:00:00:00") == 0) &&
(mask->has_eth_src) && mask->eth_src &&
(strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) { (strcmp(mask->eth_src, "01:00:00:00:00:00") == 0)) {
monitor_printf(mon, " src <any ucast>"); monitor_printf(mon, " src <any ucast>");
} else { } else {
monitor_printf(mon, " src %s", key->eth_src); monitor_printf(mon, " src %s", key->eth_src);
if (mask->has_eth_src) { if (mask->eth_src) {
monitor_printf(mon, "(%s)", mask->eth_src); monitor_printf(mon, "(%s)", mask->eth_src);
} }
} }
} }
if (key->has_eth_dst) { if (key->eth_dst) {
if ((strcmp(key->eth_dst, "01:00:00:00:00:00") == 0) && if ((strcmp(key->eth_dst, "01:00:00:00:00:00") == 0) &&
(mask->has_eth_dst) && mask->eth_dst &&
(strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) { (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
monitor_printf(mon, " dst <any mcast/bcast>"); monitor_printf(mon, " dst <any mcast/bcast>");
} else if ((strcmp(key->eth_dst, "00:00:00:00:00:00") == 0) && } else if ((strcmp(key->eth_dst, "00:00:00:00:00:00") == 0) &&
(mask->has_eth_dst) && mask->eth_dst &&
(strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) { (strcmp(mask->eth_dst, "01:00:00:00:00:00") == 0)) {
monitor_printf(mon, " dst <any ucast>"); monitor_printf(mon, " dst <any ucast>");
} else { } else {
monitor_printf(mon, " dst %s", key->eth_dst); monitor_printf(mon, " dst %s", key->eth_dst);
if (mask->has_eth_dst) { if (mask->eth_dst) {
monitor_printf(mon, "(%s)", mask->eth_dst); monitor_printf(mon, "(%s)", mask->eth_dst);
} }
} }
@ -2064,7 +2054,7 @@ void hmp_rocker_of_dpa_flows(Monitor *mon, const QDict *qdict)
} }
} }
if (key->has_ip_dst) { if (key->ip_dst) {
monitor_printf(mon, " dst %s", key->ip_dst); monitor_printf(mon, " dst %s", key->ip_dst);
} }
@ -2143,7 +2133,7 @@ void hmp_rocker_of_dpa_groups(Monitor *mon, const QDict *qdict)
group->set_vlan_id & VLAN_VID_MASK); group->set_vlan_id & VLAN_VID_MASK);
} }
if (group->has_set_eth_src) { if (group->set_eth_src) {
if (!set) { if (!set) {
set = true; set = true;
monitor_printf(mon, " set"); monitor_printf(mon, " set");
@ -2151,7 +2141,7 @@ void hmp_rocker_of_dpa_groups(Monitor *mon, const QDict *qdict)
monitor_printf(mon, " src %s", group->set_eth_src); monitor_printf(mon, " src %s", group->set_eth_src);
} }
if (group->has_set_eth_dst) { if (group->set_eth_dst) {
if (!set) { if (!set) {
monitor_printf(mon, " set"); monitor_printf(mon, " set");
} }
@ -2559,7 +2549,7 @@ void hmp_virtio_status(Monitor *mon, const QDict *qdict)
monitor_printf(mon, "%s:\n", path); monitor_printf(mon, "%s:\n", path);
monitor_printf(mon, " device_name: %s %s\n", monitor_printf(mon, " device_name: %s %s\n",
s->name, s->has_vhost_dev ? "(vhost)" : ""); s->name, s->vhost_dev ? "(vhost)" : "");
monitor_printf(mon, " device_id: %d\n", s->device_id); monitor_printf(mon, " device_id: %d\n", s->device_id);
monitor_printf(mon, " vhost_started: %s\n", monitor_printf(mon, " vhost_started: %s\n",
s->vhost_started ? "true" : "false"); s->vhost_started ? "true" : "false");
@ -2595,7 +2585,7 @@ void hmp_virtio_status(Monitor *mon, const QDict *qdict)
monitor_printf(mon, " Backend features:\n"); monitor_printf(mon, " Backend features:\n");
hmp_virtio_dump_features(mon, s->backend_features); hmp_virtio_dump_features(mon, s->backend_features);
if (s->has_vhost_dev) { if (s->vhost_dev) {
monitor_printf(mon, " VHost:\n"); monitor_printf(mon, " VHost:\n");
monitor_printf(mon, " nvqs: %d\n", monitor_printf(mon, " nvqs: %d\n",
s->vhost_dev->nvqs); s->vhost_dev->nvqs);

21
monitor/misc.c
View File

@ -398,7 +398,7 @@ static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
void qmp_client_migrate_info(const char *protocol, const char *hostname, void qmp_client_migrate_info(const char *protocol, const char *hostname,
bool has_port, int64_t port, bool has_port, int64_t port,
bool has_tls_port, int64_t tls_port, bool has_tls_port, int64_t tls_port,
bool has_cert_subject, const char *cert_subject, const char *cert_subject,
Error **errp) Error **errp)
{ {
if (strcmp(protocol, "spice") == 0) { if (strcmp(protocol, "spice") == 0) {
@ -1132,7 +1132,7 @@ void monitor_fdsets_cleanup(void)
} }
} }
AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque, AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id,
const char *opaque, Error **errp) const char *opaque, Error **errp)
{ {
int fd; int fd;
@ -1145,8 +1145,7 @@ AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
goto error; goto error;
} }
fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id, fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id, opaque, errp);
has_opaque, opaque, errp);
if (fdinfo) { if (fdinfo) {
return fdinfo; return fdinfo;
} }
@ -1214,12 +1213,7 @@ FdsetInfoList *qmp_query_fdsets(Error **errp)
fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info)); fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
fdsetfd_info->fd = mon_fdset_fd->fd; fdsetfd_info->fd = mon_fdset_fd->fd;
if (mon_fdset_fd->opaque) { fdsetfd_info->opaque = g_strdup(mon_fdset_fd->opaque);
fdsetfd_info->has_opaque = true;
fdsetfd_info->opaque = g_strdup(mon_fdset_fd->opaque);
} else {
fdsetfd_info->has_opaque = false;
}
QAPI_LIST_PREPEND(fdset_info->fds, fdsetfd_info); QAPI_LIST_PREPEND(fdset_info->fds, fdsetfd_info);
} }
@ -1231,8 +1225,7 @@ FdsetInfoList *qmp_query_fdsets(Error **errp)
} }
AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id, AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
bool has_opaque, const char *opaque, const char *opaque, Error **errp)
Error **errp)
{ {
MonFdset *mon_fdset = NULL; MonFdset *mon_fdset = NULL;
MonFdsetFd *mon_fdset_fd; MonFdsetFd *mon_fdset_fd;
@ -1300,9 +1293,7 @@ AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd)); mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
mon_fdset_fd->fd = fd; mon_fdset_fd->fd = fd;
mon_fdset_fd->removed = false; mon_fdset_fd->removed = false;
if (has_opaque) { mon_fdset_fd->opaque = g_strdup(opaque);
mon_fdset_fd->opaque = g_strdup(opaque);
}
QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next); QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
fdinfo = g_malloc0(sizeof(*fdinfo)); fdinfo = g_malloc0(sizeof(*fdinfo));

11
monitor/qmp-cmds.c
View File

@ -50,11 +50,7 @@ NameInfo *qmp_query_name(Error **errp)
{ {
NameInfo *info = g_malloc0(sizeof(*info)); NameInfo *info = g_malloc0(sizeof(*info));
if (qemu_name) { info->name = g_strdup(qemu_name);
info->has_name = true;
info->name = g_strdup(qemu_name);
}
return info; return info;
} }
@ -564,10 +560,7 @@ void add_stats_entry(StatsResultList **stats_results, StatsProvider provider,
StatsResult *entry = g_new0(StatsResult, 1); StatsResult *entry = g_new0(StatsResult, 1);
entry->provider = provider; entry->provider = provider;
if (qom_path) { entry->qom_path = g_strdup(qom_path);
entry->has_qom_path = true;
entry->qom_path = g_strdup(qom_path);
}
entry->stats = stats_list; entry->stats = stats_list;
QAPI_LIST_PREPEND(*stats_results, entry); QAPI_LIST_PREPEND(*stats_results, entry);

15
nbd/server.c
View File

@ -1638,6 +1638,7 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
{ {
NBDExport *exp = container_of(blk_exp, NBDExport, common); NBDExport *exp = container_of(blk_exp, NBDExport, common);
BlockExportOptionsNbd *arg = &exp_args->u.nbd; BlockExportOptionsNbd *arg = &exp_args->u.nbd;
const char *name = arg->name ?: exp_args->node_name;
BlockBackend *blk = blk_exp->blk; BlockBackend *blk = blk_exp->blk;
int64_t size; int64_t size;
uint64_t perm, shared_perm; uint64_t perm, shared_perm;
@ -1653,12 +1654,8 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
return -EINVAL; return -EINVAL;
} }
if (!arg->has_name) { if (strlen(name) > NBD_MAX_STRING_SIZE) {
arg->name = exp_args->node_name; error_setg(errp, "export name '%s' too long", name);
}
if (strlen(arg->name) > NBD_MAX_STRING_SIZE) {
error_setg(errp, "export name '%s' too long", arg->name);
return -EINVAL; return -EINVAL;
} }
@ -1667,8 +1664,8 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
return -EINVAL; return -EINVAL;
} }
if (nbd_export_find(arg->name)) { if (nbd_export_find(name)) {
error_setg(errp, "NBD server already has export named '%s'", arg->name); error_setg(errp, "NBD server already has export named '%s'", name);
return -EEXIST; return -EEXIST;
} }
@ -1688,7 +1685,7 @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
} }
QTAILQ_INIT(&exp->clients); QTAILQ_INIT(&exp->clients);
exp->name = g_strdup(arg->name); exp->name = g_strdup(name);
exp->description = g_strdup(arg->description); exp->description = g_strdup(arg->description);
exp->nbdflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_FLUSH | exp->nbdflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_FLUSH |
NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_CACHE); NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_CACHE);

8
net/announce.c
View File

@ -46,7 +46,7 @@ void qemu_announce_timer_del(AnnounceTimer *timer, bool free_named)
} }
qapi_free_strList(timer->params.interfaces); qapi_free_strList(timer->params.interfaces);
timer->params.interfaces = NULL; timer->params.interfaces = NULL;
if (free_named && timer->params.has_id) { if (free_named && timer->params.id) {
AnnounceTimer *list_timer; AnnounceTimer *list_timer;
/* /*
* Sanity check: There should only be one timer on the list with * Sanity check: There should only be one timer on the list with
@ -157,7 +157,7 @@ static void qemu_announce_self_iter(NICState *nic, void *opaque)
skip = false; skip = false;
} }
trace_qemu_announce_self_iter(timer->params.has_id ? timer->params.id : "_", trace_qemu_announce_self_iter(timer->params.id ?: "_",
nic->ncs->name, nic->ncs->name,
qemu_ether_ntoa(&nic->conf->macaddr), skip); qemu_ether_ntoa(&nic->conf->macaddr), skip);
@ -199,9 +199,9 @@ void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)
void qmp_announce_self(AnnounceParameters *params, Error **errp) void qmp_announce_self(AnnounceParameters *params, Error **errp)
{ {
AnnounceTimer *named_timer; AnnounceTimer *named_timer;
if (!params->has_id) {
if (!params->id) {
params->id = g_strdup(""); params->id = g_strdup("");
params->has_id = true;
} }
named_timer = g_datalist_get_data(&named_timers, params->id); named_timer = g_datalist_get_data(&named_timers, params->id);

2
net/hub.c
View File

@ -274,7 +274,7 @@ int net_init_hubport(const Netdev *netdev, const char *name,
assert(!peer); assert(!peer);
hubport = &netdev->u.hubport; hubport = &netdev->u.hubport;
if (hubport->has_netdev) { if (hubport->netdev) {
hubpeer = qemu_find_netdev(hubport->netdev); hubpeer = qemu_find_netdev(hubport->netdev);
if (!hubpeer) { if (!hubpeer) {
error_setg(errp, "netdev '%s' not found", hubport->netdev); error_setg(errp, "netdev '%s' not found", hubport->netdev);

2
net/l2tpv3.c
View File

@ -578,7 +578,7 @@ int net_init_l2tpv3(const Netdev *netdev,
if (l2tpv3->has_udp && l2tpv3->udp) { if (l2tpv3->has_udp && l2tpv3->udp) {
s->udp = true; s->udp = true;
if (!(l2tpv3->has_srcport && l2tpv3->has_dstport)) { if (!(l2tpv3->srcport && l2tpv3->dstport)) {
error_setg(errp, "need both src and dst port for udp"); error_setg(errp, "need both src and dst port for udp");
goto outerr; goto outerr;
} else { } else {

25
net/net.c
View File

@ -964,7 +964,7 @@ static int net_init_nic(const Netdev *netdev, const char *name,
memset(nd, 0, sizeof(*nd)); memset(nd, 0, sizeof(*nd));
if (nic->has_netdev) { if (nic->netdev) {
nd->netdev = qemu_find_netdev(nic->netdev); nd->netdev = qemu_find_netdev(nic->netdev);
if (!nd->netdev) { if (!nd->netdev) {
error_setg(errp, "netdev '%s' not found", nic->netdev); error_setg(errp, "netdev '%s' not found", nic->netdev);
@ -975,19 +975,19 @@ static int net_init_nic(const Netdev *netdev, const char *name,
nd->netdev = peer; nd->netdev = peer;
} }
nd->name = g_strdup(name); nd->name = g_strdup(name);
if (nic->has_model) { if (nic->model) {
nd->model = g_strdup(nic->model); nd->model = g_strdup(nic->model);
} }
if (nic->has_addr) { if (nic->addr) {
nd->devaddr = g_strdup(nic->addr); nd->devaddr = g_strdup(nic->addr);
} }
if (nic->has_macaddr && if (nic->macaddr &&
net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) { net_parse_macaddr(nd->macaddr.a, nic->macaddr) < 0) {
error_setg(errp, "invalid syntax for ethernet address"); error_setg(errp, "invalid syntax for ethernet address");
return -1; return -1;
} }
if (nic->has_macaddr && if (nic->macaddr &&
is_multicast_ether_addr(nd->macaddr.a)) { is_multicast_ether_addr(nd->macaddr.a)) {
error_setg(errp, error_setg(errp,
"NIC cannot have multicast MAC address (odd 1st byte)"); "NIC cannot have multicast MAC address (odd 1st byte)");
@ -1081,7 +1081,7 @@ static int net_client_init1(const Netdev *netdev, bool is_netdev, Error **errp)
/* Do not add to a hub if it's a nic with a netdev= parameter. */ /* Do not add to a hub if it's a nic with a netdev= parameter. */
if (netdev->type != NET_CLIENT_DRIVER_NIC || if (netdev->type != NET_CLIENT_DRIVER_NIC ||
!netdev->u.nic.has_netdev) { !netdev->u.nic.netdev) {
peer = net_hub_add_port(0, NULL, NULL); peer = net_hub_add_port(0, NULL, NULL);
} }
} }
@ -1295,8 +1295,7 @@ void print_net_client(Monitor *mon, NetClientState *nc)
} }
} }
RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name, RxFilterInfoList *qmp_query_rx_filter(const char *name, Error **errp)
Error **errp)
{ {
NetClientState *nc; NetClientState *nc;
RxFilterInfoList *filter_list = NULL, **tail = &filter_list; RxFilterInfoList *filter_list = NULL, **tail = &filter_list;
@ -1304,13 +1303,13 @@ RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
QTAILQ_FOREACH(nc, &net_clients, next) { QTAILQ_FOREACH(nc, &net_clients, next) {
RxFilterInfo *info; RxFilterInfo *info;
if (has_name && strcmp(nc->name, name) != 0) { if (name && strcmp(nc->name, name) != 0) {
continue; continue;
} }
/* only query rx-filter information of NIC */ /* only query rx-filter information of NIC */
if (nc->info->type != NET_CLIENT_DRIVER_NIC) { if (nc->info->type != NET_CLIENT_DRIVER_NIC) {
if (has_name) { if (name) {
error_setg(errp, "net client(%s) isn't a NIC", name); error_setg(errp, "net client(%s) isn't a NIC", name);
assert(!filter_list); assert(!filter_list);
return NULL; return NULL;
@ -1327,19 +1326,19 @@ RxFilterInfoList *qmp_query_rx_filter(bool has_name, const char *name,
if (nc->info->query_rx_filter) { if (nc->info->query_rx_filter) {
info = nc->info->query_rx_filter(nc); info = nc->info->query_rx_filter(nc);
QAPI_LIST_APPEND(tail, info); QAPI_LIST_APPEND(tail, info);
} else if (has_name) { } else if (name) {
error_setg(errp, "net client(%s) doesn't support" error_setg(errp, "net client(%s) doesn't support"
" rx-filter querying", name); " rx-filter querying", name);
assert(!filter_list); assert(!filter_list);
return NULL; return NULL;
} }
if (has_name) { if (name) {
break; break;
} }
} }
if (filter_list == NULL && has_name) { if (filter_list == NULL && name) {
error_setg(errp, "invalid net client name: %s", name); error_setg(errp, "invalid net client name: %s", name);
} }

4
net/slirp.c
View File

@ -1153,8 +1153,8 @@ int net_init_slirp(const Netdev *netdev, const char *name,
ipv6 = 0; ipv6 = 0;
} }
vnet = user->has_net ? g_strdup(user->net) : vnet = user->net ? g_strdup(user->net) :
user->has_ip ? g_strdup_printf("%s/24", user->ip) : user->ip ? g_strdup_printf("%s/24", user->ip) :
NULL; NULL;
dnssearch = slirp_dnssearch(user->dnssearch); dnssearch = slirp_dnssearch(user->dnssearch);

18
net/socket.c
View File

@ -705,19 +705,19 @@ int net_init_socket(const Netdev *netdev, const char *name,
assert(netdev->type == NET_CLIENT_DRIVER_SOCKET); assert(netdev->type == NET_CLIENT_DRIVER_SOCKET);
sock = &netdev->u.socket; sock = &netdev->u.socket;
if (sock->has_fd + sock->has_listen + sock->has_connect + sock->has_mcast + if (!!sock->fd + !!sock->listen + !!sock->connect + !!sock->mcast +
sock->has_udp != 1) { !!sock->udp != 1) {
error_setg(errp, "exactly one of listen=, connect=, mcast= or udp=" error_setg(errp, "exactly one of listen=, connect=, mcast= or udp="
" is required"); " is required");
return -1; return -1;
} }
if (sock->has_localaddr && !sock->has_mcast && !sock->has_udp) { if (sock->localaddr && !sock->mcast && !sock->udp) {
error_setg(errp, "localaddr= is only valid with mcast= or udp="); error_setg(errp, "localaddr= is only valid with mcast= or udp=");
return -1; return -1;
} }
if (sock->has_fd) { if (sock->fd) {
int fd, ret; int fd, ret;
fd = monitor_fd_param(monitor_cur(), sock->fd, errp); fd = monitor_fd_param(monitor_cur(), sock->fd, errp);
@ -737,7 +737,7 @@ int net_init_socket(const Netdev *netdev, const char *name,
return 0; return 0;
} }
if (sock->has_listen) { if (sock->listen) {
if (net_socket_listen_init(peer, "socket", name, sock->listen, errp) if (net_socket_listen_init(peer, "socket", name, sock->listen, errp)
< 0) { < 0) {
return -1; return -1;
@ -745,7 +745,7 @@ int net_init_socket(const Netdev *netdev, const char *name,
return 0; return 0;
} }
if (sock->has_connect) { if (sock->connect) {
if (net_socket_connect_init(peer, "socket", name, sock->connect, errp) if (net_socket_connect_init(peer, "socket", name, sock->connect, errp)
< 0) { < 0) {
return -1; return -1;
@ -753,7 +753,7 @@ int net_init_socket(const Netdev *netdev, const char *name,
return 0; return 0;
} }
if (sock->has_mcast) { if (sock->mcast) {
/* if sock->localaddr is missing, it has been initialized to "all bits /* if sock->localaddr is missing, it has been initialized to "all bits
* zero" */ * zero" */
if (net_socket_mcast_init(peer, "socket", name, sock->mcast, if (net_socket_mcast_init(peer, "socket", name, sock->mcast,
@ -763,8 +763,8 @@ int net_init_socket(const Netdev *netdev, const char *name,
return 0; return 0;
} }
assert(sock->has_udp); assert(sock->udp);
if (!sock->has_localaddr) { if (!sock->localaddr) {
error_setg(errp, "localaddr= is mandatory with udp="); error_setg(errp, "localaddr= is mandatory with udp=");
return -1; return -1;
} }

2
net/tap-win32.c
View File

@ -807,7 +807,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
assert(netdev->type == NET_CLIENT_DRIVER_TAP); assert(netdev->type == NET_CLIENT_DRIVER_TAP);
tap = &netdev->u.tap; tap = &netdev->u.tap;
if (!tap->has_ifname) { if (!tap->ifname) {
error_report("tap: no interface name"); error_report("tap: no interface name");
return -1; return -1;
} }

51
net/tap.c
View File

@ -611,8 +611,8 @@ int net_init_bridge(const Netdev *netdev, const char *name,
assert(netdev->type == NET_CLIENT_DRIVER_BRIDGE); assert(netdev->type == NET_CLIENT_DRIVER_BRIDGE);
bridge = &netdev->u.bridge; bridge = &netdev->u.bridge;
helper = bridge->has_helper ? bridge->helper : NULL; helper = bridge->helper;
br = bridge->has_br ? bridge->br : DEFAULT_BRIDGE_INTERFACE; br = bridge->br ?: DEFAULT_BRIDGE_INTERFACE;
fd = net_bridge_run_helper(helper, br, errp); fd = net_bridge_run_helper(helper, br, errp);
if (fd == -1) { if (fd == -1) {
@ -688,9 +688,9 @@ static void net_init_tap_one(const NetdevTapOptions *tap, NetClientState *peer,
goto failed; goto failed;
} }
if (tap->has_fd || tap->has_fds) { if (tap->fd || tap->fds) {
qemu_set_info_str(&s->nc, "fd=%d", fd); qemu_set_info_str(&s->nc, "fd=%d", fd);
} else if (tap->has_helper) { } else if (tap->helper) {
qemu_set_info_str(&s->nc, "helper=%s", tap->helper); qemu_set_info_str(&s->nc, "helper=%s", tap->helper);
} else { } else {
qemu_set_info_str(&s->nc, "ifname=%s,script=%s,downscript=%s", ifname, qemu_set_info_str(&s->nc, "ifname=%s,script=%s,downscript=%s", ifname,
@ -812,21 +812,21 @@ int net_init_tap(const Netdev *netdev, const char *name,
assert(netdev->type == NET_CLIENT_DRIVER_TAP); assert(netdev->type == NET_CLIENT_DRIVER_TAP);
tap = &netdev->u.tap; tap = &netdev->u.tap;
queues = tap->has_queues ? tap->queues : 1; queues = tap->has_queues ? tap->queues : 1;
vhostfdname = tap->has_vhostfd ? tap->vhostfd : NULL; vhostfdname = tap->vhostfd;
script = tap->has_script ? tap->script : NULL; script = tap->script;
downscript = tap->has_downscript ? tap->downscript : NULL; downscript = tap->downscript;
/* QEMU hubs do not support multiqueue tap, in this case peer is set. /* QEMU hubs do not support multiqueue tap, in this case peer is set.
* For -netdev, peer is always NULL. */ * For -netdev, peer is always NULL. */
if (peer && (tap->has_queues || tap->has_fds || tap->has_vhostfds)) { if (peer && (tap->has_queues || tap->fds || tap->vhostfds)) {
error_setg(errp, "Multiqueue tap cannot be used with hubs"); error_setg(errp, "Multiqueue tap cannot be used with hubs");
return -1; return -1;
} }
if (tap->has_fd) { if (tap->fd) {
if (tap->has_ifname || tap->has_script || tap->has_downscript || if (tap->ifname || tap->script || tap->downscript ||
tap->has_vnet_hdr || tap->has_helper || tap->has_queues || tap->has_vnet_hdr || tap->helper || tap->has_queues ||
tap->has_fds || tap->has_vhostfds) { tap->fds || tap->vhostfds) {
error_setg(errp, "ifname=, script=, downscript=, vnet_hdr=, " error_setg(errp, "ifname=, script=, downscript=, vnet_hdr=, "
"helper=, queues=, fds=, and vhostfds= " "helper=, queues=, fds=, and vhostfds= "
"are invalid with fd="); "are invalid with fd=");
@ -859,14 +859,14 @@ int net_init_tap(const Netdev *netdev, const char *name,
close(fd); close(fd);
return -1; return -1;
} }
} else if (tap->has_fds) { } else if (tap->fds) {
char **fds; char **fds;
char **vhost_fds; char **vhost_fds;
int nfds = 0, nvhosts = 0; int nfds = 0, nvhosts = 0;
if (tap->has_ifname || tap->has_script || tap->has_downscript || if (tap->ifname || tap->script || tap->downscript ||
tap->has_vnet_hdr || tap->has_helper || tap->has_queues || tap->has_vnet_hdr || tap->helper || tap->has_queues ||
tap->has_vhostfd) { tap->vhostfd) {
error_setg(errp, "ifname=, script=, downscript=, vnet_hdr=, " error_setg(errp, "ifname=, script=, downscript=, vnet_hdr=, "
"helper=, queues=, and vhostfd= " "helper=, queues=, and vhostfd= "
"are invalid with fds="); "are invalid with fds=");
@ -877,7 +877,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
vhost_fds = g_new0(char *, MAX_TAP_QUEUES); vhost_fds = g_new0(char *, MAX_TAP_QUEUES);
nfds = get_fds(tap->fds, fds, MAX_TAP_QUEUES); nfds = get_fds(tap->fds, fds, MAX_TAP_QUEUES);
if (tap->has_vhostfds) { if (tap->vhostfds) {
nvhosts = get_fds(tap->vhostfds, vhost_fds, MAX_TAP_QUEUES); nvhosts = get_fds(tap->vhostfds, vhost_fds, MAX_TAP_QUEUES);
if (nfds != nvhosts) { if (nfds != nvhosts) {
error_setg(errp, "The number of fds passed does not match " error_setg(errp, "The number of fds passed does not match "
@ -916,7 +916,7 @@ int net_init_tap(const Netdev *netdev, const char *name,
net_init_tap_one(tap, peer, "tap", name, ifname, net_init_tap_one(tap, peer, "tap", name, ifname,
script, downscript, script, downscript,
tap->has_vhostfds ? vhost_fds[i] : NULL, tap->vhostfds ? vhost_fds[i] : NULL,
vnet_hdr, fd, &err); vnet_hdr, fd, &err);
if (err) { if (err) {
error_propagate(errp, err); error_propagate(errp, err);
@ -935,17 +935,16 @@ free_fail:
g_free(fds); g_free(fds);
g_free(vhost_fds); g_free(vhost_fds);
return ret; return ret;
} else if (tap->has_helper) { } else if (tap->helper) {
if (tap->has_ifname || tap->has_script || tap->has_downscript || if (tap->ifname || tap->script || tap->downscript ||
tap->has_vnet_hdr || tap->has_queues || tap->has_vhostfds) { tap->has_vnet_hdr || tap->has_queues || tap->vhostfds) {
error_setg(errp, "ifname=, script=, downscript=, vnet_hdr=, " error_setg(errp, "ifname=, script=, downscript=, vnet_hdr=, "
"queues=, and vhostfds= are invalid with helper="); "queues=, and vhostfds= are invalid with helper=");
return -1; return -1;
} }
fd = net_bridge_run_helper(tap->helper, fd = net_bridge_run_helper(tap->helper,
tap->has_br ? tap->br ?: DEFAULT_BRIDGE_INTERFACE,
tap->br : DEFAULT_BRIDGE_INTERFACE,
errp); errp);
if (fd == -1) { if (fd == -1) {
return -1; return -1;
@ -972,7 +971,7 @@ free_fail:
} else { } else {
g_autofree char *default_script = NULL; g_autofree char *default_script = NULL;
g_autofree char *default_downscript = NULL; g_autofree char *default_downscript = NULL;
if (tap->has_vhostfds) { if (tap->vhostfds) {
error_setg(errp, "vhostfds= is invalid if fds= wasn't specified"); error_setg(errp, "vhostfds= is invalid if fds= wasn't specified");
return -1; return -1;
} }
@ -985,7 +984,7 @@ free_fail:
get_relocated_path(DEFAULT_NETWORK_DOWN_SCRIPT); get_relocated_path(DEFAULT_NETWORK_DOWN_SCRIPT);
} }
if (tap->has_ifname) { if (tap->ifname) {
pstrcpy(ifname, sizeof ifname, tap->ifname); pstrcpy(ifname, sizeof ifname, tap->ifname);
} else { } else {
ifname[0] = '\0'; ifname[0] = '\0';
@ -998,7 +997,7 @@ free_fail:
return -1; return -1;
} }
if (queues > 1 && i == 0 && !tap->has_ifname) { if (queues > 1 && i == 0 && !tap->ifname) {
if (tap_fd_get_ifname(fd, ifname)) { if (tap_fd_get_ifname(fd, ifname)) {
error_setg(errp, "Fail to get ifname"); error_setg(errp, "Fail to get ifname");
close(fd); close(fd);

6
net/vhost-vdpa.c
View File

@ -635,19 +635,19 @@ int net_init_vhost_vdpa(const Netdev *netdev, const char *name,
assert(netdev->type == NET_CLIENT_DRIVER_VHOST_VDPA); assert(netdev->type == NET_CLIENT_DRIVER_VHOST_VDPA);
opts = &netdev->u.vhost_vdpa; opts = &netdev->u.vhost_vdpa;
if (!opts->has_vhostdev && !opts->has_vhostfd) { if (!opts->vhostdev && !opts->vhostfd) {
error_setg(errp, error_setg(errp,
"vhost-vdpa: neither vhostdev= nor vhostfd= was specified"); "vhost-vdpa: neither vhostdev= nor vhostfd= was specified");
return -1; return -1;
} }
if (opts->has_vhostdev && opts->has_vhostfd) { if (opts->vhostdev && opts->vhostfd) {
error_setg(errp, error_setg(errp,
"vhost-vdpa: vhostdev= and vhostfd= are mutually exclusive"); "vhost-vdpa: vhostdev= and vhostfd= are mutually exclusive");
return -1; return -1;
} }
if (opts->has_vhostdev) { if (opts->vhostdev) {
vdpa_device_fd = qemu_open(opts->vhostdev, O_RDWR, errp); vdpa_device_fd = qemu_open(opts->vhostdev, O_RDWR, errp);
if (vdpa_device_fd == -1) { if (vdpa_device_fd == -1) {
return -errno; return -errno;

20
net/vmnet-host.c
View File

@ -26,7 +26,7 @@ static bool validate_options(const Netdev *netdev, Error **errp)
MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0 MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_VERSION_11_0
QemuUUID net_uuid; QemuUUID net_uuid;
if (options->has_net_uuid && if (options->net_uuid &&
qemu_uuid_parse(options->net_uuid, &net_uuid) < 0) { qemu_uuid_parse(options->net_uuid, &net_uuid) < 0) {
error_setg(errp, "Invalid UUID provided in 'net-uuid'"); error_setg(errp, "Invalid UUID provided in 'net-uuid'");
return false; return false;
@ -39,7 +39,7 @@ static bool validate_options(const Netdev *netdev, Error **errp)
return false; return false;
} }
if (options->has_net_uuid) { if (options->net_uuid) {
error_setg(errp, error_setg(errp,
"vmnet-host.net-uuid feature is " "vmnet-host.net-uuid feature is "
"unavailable: outdated vmnet.framework API"); "unavailable: outdated vmnet.framework API");
@ -47,12 +47,12 @@ static bool validate_options(const Netdev *netdev, Error **errp)
} }
#endif #endif
if ((options->has_start_address || if ((options->start_address ||
options->has_end_address || options->end_address ||
options->has_subnet_mask) && options->subnet_mask) &&
!(options->has_start_address && !(options->start_address &&
options->has_end_address && options->end_address &&
options->has_subnet_mask)) { options->subnet_mask)) {
error_setg(errp, error_setg(errp,
"'start-address', 'end-address', 'subnet-mask' " "'start-address', 'end-address', 'subnet-mask' "
"should be provided together"); "should be provided together");
@ -79,7 +79,7 @@ static xpc_object_t build_if_desc(const Netdev *netdev)
options->isolated); options->isolated);
QemuUUID net_uuid; QemuUUID net_uuid;
if (options->has_net_uuid) { if (options->net_uuid) {
qemu_uuid_parse(options->net_uuid, &net_uuid); qemu_uuid_parse(options->net_uuid, &net_uuid);
xpc_dictionary_set_uuid(if_desc, xpc_dictionary_set_uuid(if_desc,
vmnet_network_identifier_key, vmnet_network_identifier_key,
@ -87,7 +87,7 @@ static xpc_object_t build_if_desc(const Netdev *netdev)
} }
#endif #endif
if (options->has_start_address) { if (options->start_address) {
xpc_dictionary_set_string(if_desc, xpc_dictionary_set_string(if_desc,
vmnet_start_address_key, vmnet_start_address_key,
options->start_address); options->start_address);

16
net/vmnet-shared.c
View File

@ -31,12 +31,12 @@ static bool validate_options(const Netdev *netdev, Error **errp)
} }
#endif #endif
if ((options->has_start_address || if ((options->start_address ||
options->has_end_address || options->end_address ||
options->has_subnet_mask) && options->subnet_mask) &&
!(options->has_start_address && !(options->start_address &&
options->has_end_address && options->end_address &&
options->has_subnet_mask)) { options->subnet_mask)) {
error_setg(errp, error_setg(errp,
"'start-address', 'end-address', 'subnet-mask' " "'start-address', 'end-address', 'subnet-mask' "
"should be provided together" "should be provided together"
@ -58,13 +58,13 @@ static xpc_object_t build_if_desc(const Netdev *netdev)
VMNET_SHARED_MODE VMNET_SHARED_MODE
); );
if (options->has_nat66_prefix) { if (options->nat66_prefix) {
xpc_dictionary_set_string(if_desc, xpc_dictionary_set_string(if_desc,
vmnet_nat66_prefix_key, vmnet_nat66_prefix_key,
options->nat66_prefix); options->nat66_prefix);
} }
if (options->has_start_address) { if (options->start_address) {
xpc_dictionary_set_string(if_desc, xpc_dictionary_set_string(if_desc,
vmnet_start_address_key, vmnet_start_address_key,
options->start_address); options->start_address);

13
qemu-img.c
View File

@ -2915,15 +2915,15 @@ static ImageInfoList *collect_image_info_list(bool image_opts,
image_opts = false; image_opts = false;
if (chain) { if (chain) {
if (info->has_full_backing_filename) { if (info->full_backing_filename) {
filename = info->full_backing_filename; filename = info->full_backing_filename;
} else if (info->has_backing_filename) { } else if (info->backing_filename) {
error_report("Could not determine absolute backing filename," error_report("Could not determine absolute backing filename,"
" but backing filename '%s' present", " but backing filename '%s' present",
info->backing_filename); info->backing_filename);
goto err; goto err;
} }
if (info->has_backing_filename_format) { if (info->backing_filename_format) {
fmt = info->backing_filename_format; fmt = info->backing_filename_format;
} }
} }
@ -3046,7 +3046,7 @@ static int dump_map_entry(OutputFormat output_format, MapEntry *e,
printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n", printf("%#-16"PRIx64"%#-16"PRIx64"%#-16"PRIx64"%s\n",
e->start, e->length, e->start, e->length,
e->has_offset ? e->offset : 0, e->has_offset ? e->offset : 0,
e->has_filename ? e->filename : ""); e->filename ?: "");
} }
/* This format ignores the distinction between 0, ZERO and ZERO|DATA. /* This format ignores the distinction between 0, ZERO and ZERO|DATA.
* Modify the flags here to allow more coalescing. * Modify the flags here to allow more coalescing.
@ -3127,7 +3127,6 @@ static int get_block_status(BlockDriverState *bs, int64_t offset,
.has_offset = has_offset, .has_offset = has_offset,
.depth = depth, .depth = depth,
.present = !!(ret & BDRV_BLOCK_ALLOCATED), .present = !!(ret & BDRV_BLOCK_ALLOCATED),
.has_filename = filename,
.filename = filename, .filename = filename,
}; };
@ -3143,11 +3142,11 @@ static inline bool entry_mergeable(const MapEntry *curr, const MapEntry *next)
curr->data != next->data || curr->data != next->data ||
curr->depth != next->depth || curr->depth != next->depth ||
curr->present != next->present || curr->present != next->present ||
curr->has_filename != next->has_filename || !curr->filename != !next->filename ||
curr->has_offset != next->has_offset) { curr->has_offset != next->has_offset) {
return false; return false;
} }
if (curr->has_filename && strcmp(curr->filename, next->filename)) { if (curr->filename && strcmp(curr->filename, next->filename)) {
return false; return false;
} }
if (curr->has_offset && curr->offset + curr->length != next->offset) { if (curr->has_offset && curr->offset + curr->length != next->offset) {

2
qemu-nbd.c
View File

@ -1107,9 +1107,7 @@ int main(int argc, char **argv)
.has_writable = true, .has_writable = true,
.writable = !readonly, .writable = !readonly,
.u.nbd = { .u.nbd = {
.has_name = true,
.name = g_strdup(export_name), .name = g_strdup(export_name),
.has_description = !!export_description,
.description = g_strdup(export_description), .description = g_strdup(export_description),
.has_bitmaps = !!bitmaps, .has_bitmaps = !!bitmaps,
.bitmaps = bitmaps, .bitmaps = bitmaps,

32
qga/commands-posix.c
View File

@ -71,7 +71,7 @@ static void ga_wait_child(pid_t pid, int *status, Error **errp)
g_assert(rpid == pid); g_assert(rpid == pid);
} }
void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp) void qmp_guest_shutdown(const char *mode, Error **errp)
{ {
const char *shutdown_flag; const char *shutdown_flag;
Error *local_err = NULL; Error *local_err = NULL;
@ -93,7 +93,7 @@ void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp)
#endif #endif
slog("guest-shutdown called, mode: %s", mode); slog("guest-shutdown called, mode: %s", mode);
if (!has_mode || strcmp(mode, "powerdown") == 0) { if (!mode || strcmp(mode, "powerdown") == 0) {
shutdown_flag = powerdown_flag; shutdown_flag = powerdown_flag;
} else if (strcmp(mode, "halt") == 0) { } else if (strcmp(mode, "halt") == 0) {
shutdown_flag = halt_flag; shutdown_flag = halt_flag;
@ -404,14 +404,14 @@ end:
return f; return f;
} }
int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, int64_t qmp_guest_file_open(const char *path, const char *mode,
Error **errp) Error **errp)
{ {
FILE *fh; FILE *fh;
Error *local_err = NULL; Error *local_err = NULL;
int64_t handle; int64_t handle;
if (!has_mode) { if (!mode) {
mode = "r"; mode = "r";
} }
slog("guest-file-open called, filepath: %s, mode: %s", path, mode); slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
@ -1037,7 +1037,6 @@ static bool build_guest_fsinfo_for_ccw_dev(char const *syspath,
return false; return false;
} }
disk->has_ccw_address = true;
disk->ccw_address = g_new0(GuestCCWAddress, 1); disk->ccw_address = g_new0(GuestCCWAddress, 1);
disk->ccw_address->cssid = cssid; disk->ccw_address->cssid = cssid;
disk->ccw_address->ssid = ssid; disk->ccw_address->ssid = ssid;
@ -1084,12 +1083,10 @@ static void build_guest_fsinfo_for_real_device(char const *syspath,
devnode = udev_device_get_devnode(udevice); devnode = udev_device_get_devnode(udevice);
if (devnode != NULL) { if (devnode != NULL) {
disk->dev = g_strdup(devnode); disk->dev = g_strdup(devnode);
disk->has_dev = true;
} }
serial = udev_device_get_property_value(udevice, "ID_SERIAL"); serial = udev_device_get_property_value(udevice, "ID_SERIAL");
if (serial != NULL && *serial != 0) { if (serial != NULL && *serial != 0) {
disk->serial = g_strdup(serial); disk->serial = g_strdup(serial);
disk->has_serial = true;
} }
} }
@ -1108,7 +1105,7 @@ static void build_guest_fsinfo_for_real_device(char const *syspath,
has_hwinf = false; has_hwinf = false;
} }
if (has_hwinf || disk->has_dev || disk->has_serial) { if (has_hwinf || disk->dev || disk->serial) {
QAPI_LIST_PREPEND(fs->disk, disk); QAPI_LIST_PREPEND(fs->disk, disk);
} else { } else {
qapi_free_GuestDiskAddress(disk); qapi_free_GuestDiskAddress(disk);
@ -1411,7 +1408,6 @@ static void get_nvme_smart(GuestDiskInfo *disk)
return; return;
} }
disk->has_smart = true;
disk->smart = g_new0(GuestDiskSmart, 1); disk->smart = g_new0(GuestDiskSmart, 1);
disk->smart->type = GUEST_DISK_BUS_TYPE_NVME; disk->smart->type = GUEST_DISK_BUS_TYPE_NVME;
@ -1449,7 +1445,7 @@ static void get_nvme_smart(GuestDiskInfo *disk)
static void get_disk_smart(GuestDiskInfo *disk) static void get_disk_smart(GuestDiskInfo *disk)
{ {
if (disk->has_address if (disk->address
&& (disk->address->bus_type == GUEST_DISK_BUS_TYPE_NVME)) { && (disk->address->bus_type == GUEST_DISK_BUS_TYPE_NVME)) {
get_nvme_smart(disk); get_nvme_smart(disk);
} }
@ -1502,7 +1498,6 @@ GuestDiskInfoList *qmp_guest_get_disks(Error **errp)
disk->name = dev_name; disk->name = dev_name;
disk->partition = false; disk->partition = false;
disk->alias = get_alias_for_syspath(disk_dir); disk->alias = get_alias_for_syspath(disk_dir);
disk->has_alias = (disk->alias != NULL);
QAPI_LIST_PREPEND(ret, disk); QAPI_LIST_PREPEND(ret, disk);
/* Get address for non-virtual devices */ /* Get address for non-virtual devices */
@ -1522,8 +1517,6 @@ GuestDiskInfoList *qmp_guest_get_disks(Error **errp)
error_get_pretty(local_err)); error_get_pretty(local_err));
error_free(local_err); error_free(local_err);
local_err = NULL; local_err = NULL;
} else if (disk->address != NULL) {
disk->has_address = true;
} }
} }
@ -1641,7 +1634,6 @@ qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
if (fd == -1) { if (fd == -1) {
result->error = g_strdup_printf("failed to open: %s", result->error = g_strdup_printf("failed to open: %s",
strerror(errno)); strerror(errno));
result->has_error = true;
continue; continue;
} }
@ -1656,7 +1648,6 @@ qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
r.minlen = has_minimum ? minimum : 0; r.minlen = has_minimum ? minimum : 0;
ret = ioctl(fd, FITRIM, &r); ret = ioctl(fd, FITRIM, &r);
if (ret == -1) { if (ret == -1) {
result->has_error = true;
if (errno == ENOTTY || errno == EOPNOTSUPP) { if (errno == ENOTTY || errno == EOPNOTSUPP) {
result->error = g_strdup("trim not supported"); result->error = g_strdup("trim not supported");
} else { } else {
@ -2967,7 +2958,7 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
QAPI_LIST_APPEND(tail, info); QAPI_LIST_APPEND(tail, info);
} }
if (!info->has_hardware_address) { if (!info->hardware_address) {
if (!guest_get_hw_addr(ifa, mac_addr, &obtained, errp)) { if (!guest_get_hw_addr(ifa, mac_addr, &obtained, errp)) {
goto error; goto error;
} }
@ -2977,7 +2968,6 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
(int) mac_addr[0], (int) mac_addr[1], (int) mac_addr[0], (int) mac_addr[1],
(int) mac_addr[2], (int) mac_addr[3], (int) mac_addr[2], (int) mac_addr[3],
(int) mac_addr[4], (int) mac_addr[5]); (int) mac_addr[4], (int) mac_addr[5]);
info->has_hardware_address = true;
} }
} }
@ -3037,14 +3027,12 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
info->has_ip_addresses = true; info->has_ip_addresses = true;
if (!info->has_statistics) { if (!info->statistics) {
interface_stat = g_malloc0(sizeof(*interface_stat)); interface_stat = g_malloc0(sizeof(*interface_stat));
if (guest_get_network_stats(info->name, interface_stat) == -1) { if (guest_get_network_stats(info->name, interface_stat) == -1) {
info->has_statistics = false;
g_free(interface_stat); g_free(interface_stat);
} else { } else {
info->statistics = interface_stat; info->statistics = interface_stat;
info->has_statistics = true;
} }
} }
} }
@ -3351,11 +3339,8 @@ GuestOSInfo *qmp_guest_get_osinfo(Error **errp)
if (uname(&kinfo) != 0) { if (uname(&kinfo) != 0) {
error_setg_errno(errp, errno, "uname failed"); error_setg_errno(errp, errno, "uname failed");
} else { } else {
info->has_kernel_version = true;
info->kernel_version = g_strdup(kinfo.version); info->kernel_version = g_strdup(kinfo.version);
info->has_kernel_release = true;
info->kernel_release = g_strdup(kinfo.release); info->kernel_release = g_strdup(kinfo.release);
info->has_machine = true;
info->machine = g_strdup(kinfo.machine); info->machine = g_strdup(kinfo.machine);
} }
@ -3375,7 +3360,6 @@ GuestOSInfo *qmp_guest_get_osinfo(Error **errp)
value = g_key_file_get_value(osrelease, "os-release", osfield, NULL); \ value = g_key_file_get_value(osrelease, "os-release", osfield, NULL); \
if (value != NULL) { \ if (value != NULL) { \
ga_osrelease_replace_special(value); \ ga_osrelease_replace_special(value); \
info->has_ ## field = true; \
info->field = value; \ info->field = value; \
} \ } \
} while (0) } while (0)

40
qga/commands-win32.c
View File

@ -193,8 +193,7 @@ static void handle_set_nonblocking(HANDLE fh)
SetNamedPipeHandleState(fh, &pipe_state, NULL, NULL); SetNamedPipeHandleState(fh, &pipe_state, NULL, NULL);
} }
int64_t qmp_guest_file_open(const char *path, bool has_mode, int64_t qmp_guest_file_open(const char *path, const char *mode, Error **errp)
const char *mode, Error **errp)
{ {
int64_t fd = -1; int64_t fd = -1;
HANDLE fh; HANDLE fh;
@ -206,7 +205,7 @@ int64_t qmp_guest_file_open(const char *path, bool has_mode,
GError *gerr = NULL; GError *gerr = NULL;
wchar_t *w_path = NULL; wchar_t *w_path = NULL;
if (!has_mode) { if (!mode) {
mode = "r"; mode = "r";
} }
slog("guest-file-open called, filepath: %s, mode: %s", path, mode); slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
@ -317,14 +316,14 @@ static void execute_async(DWORD WINAPI (*func)(LPVOID), LPVOID opaque,
} }
} }
void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp) void qmp_guest_shutdown(const char *mode, Error **errp)
{ {
Error *local_err = NULL; Error *local_err = NULL;
UINT shutdown_flag = EWX_FORCE; UINT shutdown_flag = EWX_FORCE;
slog("guest-shutdown called, mode: %s", mode); slog("guest-shutdown called, mode: %s", mode);
if (!has_mode || strcmp(mode, "powerdown") == 0) { if (!mode || strcmp(mode, "powerdown") == 0) {
shutdown_flag |= EWX_POWEROFF; shutdown_flag |= EWX_POWEROFF;
} else if (strcmp(mode, "halt") == 0) { } else if (strcmp(mode, "halt") == 0) {
shutdown_flag |= EWX_SHUTDOWN; shutdown_flag |= EWX_SHUTDOWN;
@ -833,7 +832,6 @@ static void get_disk_properties(HANDLE vol_h, GuestDiskAddress *disk,
g_debug("serial number \"%s\"", serial); g_debug("serial number \"%s\"", serial);
if (*serial != 0) { if (*serial != 0) {
disk->serial = g_strndup(serial, len); disk->serial = g_strndup(serial, len);
disk->has_serial = true;
} }
} }
out_free: out_free:
@ -951,7 +949,6 @@ static GuestDiskAddressList *build_guest_disk_info(char *guid, Error **errp)
/* Possibly CD-ROM or a shared drive. Try to pass the volume */ /* Possibly CD-ROM or a shared drive. Try to pass the volume */
g_debug("volume not on disk"); g_debug("volume not on disk");
disk = g_new0(GuestDiskAddress, 1); disk = g_new0(GuestDiskAddress, 1);
disk->has_dev = true;
disk->dev = g_strdup(name); disk->dev = g_strdup(name);
get_single_disk_info(0xffffffff, disk, &local_err); get_single_disk_info(0xffffffff, disk, &local_err);
if (local_err) { if (local_err) {
@ -983,7 +980,6 @@ static GuestDiskAddressList *build_guest_disk_info(char *guid, Error **errp)
* See also Naming Files, Paths and Namespaces: * See also Naming Files, Paths and Namespaces:
* https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#win32-device-namespaces * https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#win32-device-namespaces
*/ */
disk->has_dev = true;
disk->dev = g_strdup_printf("\\\\.\\PhysicalDrive%lu", disk->dev = g_strdup_printf("\\\\.\\PhysicalDrive%lu",
extents->Extents[i].DiskNumber); extents->Extents[i].DiskNumber);
@ -1078,7 +1074,6 @@ GuestDiskInfoList *qmp_guest_get_disks(Error **errp)
g_debug(" number: %lu", sdn.DeviceNumber); g_debug(" number: %lu", sdn.DeviceNumber);
address = g_new0(GuestDiskAddress, 1); address = g_new0(GuestDiskAddress, 1);
address->has_dev = true;
address->dev = g_strdup(disk->name); address->dev = g_strdup(disk->name);
get_single_disk_info(sdn.DeviceNumber, address, &local_err); get_single_disk_info(sdn.DeviceNumber, address, &local_err);
if (local_err) { if (local_err) {
@ -1089,7 +1084,6 @@ GuestDiskInfoList *qmp_guest_get_disks(Error **errp)
address = NULL; address = NULL;
} else { } else {
disk->address = address; disk->address = address;
disk->has_address = true;
} }
QAPI_LIST_PREPEND(ret, disk); QAPI_LIST_PREPEND(ret, disk);
@ -1369,7 +1363,6 @@ qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
g_free(uc_path); g_free(uc_path);
if (!path) { if (!path) {
res->has_error = true;
res->error = g_strdup(gerr->message); res->error = g_strdup(gerr->message);
g_error_free(gerr); g_error_free(gerr);
break; break;
@ -1387,7 +1380,6 @@ qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
if (!g_spawn_sync(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, if (!g_spawn_sync(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL,
&out /* stdout */, NULL /* stdin */, &out /* stdout */, NULL /* stdin */,
NULL, &gerr)) { NULL, &gerr)) {
res->has_error = true;
res->error = g_strdup(gerr->message); res->error = g_strdup(gerr->message);
g_error_free(gerr); g_error_free(gerr);
} else { } else {
@ -1403,7 +1395,6 @@ qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
if (g_strstr_len(lines[i], -1, "(0x") == NULL) { if (g_strstr_len(lines[i], -1, "(0x") == NULL) {
continue; continue;
} }
res->has_error = true;
res->error = g_strdup(lines[i]); res->error = g_strdup(lines[i]);
break; break;
} }
@ -1683,8 +1674,6 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
(int) mac_addr[0], (int) mac_addr[1], (int) mac_addr[0], (int) mac_addr[1],
(int) mac_addr[2], (int) mac_addr[3], (int) mac_addr[2], (int) mac_addr[3],
(int) mac_addr[4], (int) mac_addr[5]); (int) mac_addr[4], (int) mac_addr[5]);
info->has_hardware_address = true;
} }
head_addr = NULL; head_addr = NULL;
@ -1713,15 +1702,13 @@ GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
info->has_ip_addresses = true; info->has_ip_addresses = true;
info->ip_addresses = head_addr; info->ip_addresses = head_addr;
} }
if (!info->has_statistics) { if (!info->statistics) {
interface_stat = g_malloc0(sizeof(*interface_stat)); interface_stat = g_malloc0(sizeof(*interface_stat));
if (guest_get_network_stats(addr->AdapterName, if (guest_get_network_stats(addr->AdapterName, interface_stat)
interface_stat) == -1) { == -1) {
info->has_statistics = false;
g_free(interface_stat); g_free(interface_stat);
} else { } else {
info->statistics = interface_stat; info->statistics = interface_stat;
info->has_statistics = true;
} }
} }
} }
@ -2113,7 +2100,6 @@ GuestUserList *qmp_guest_get_users(Error **errp)
user->user = g_strdup(info->UserName); user->user = g_strdup(info->UserName);
user->domain = g_strdup(info->Domain); user->domain = g_strdup(info->Domain);
user->has_domain = true;
user->login_time = login_time; user->login_time = login_time;
@ -2332,29 +2318,19 @@ GuestOSInfo *qmp_guest_get_osinfo(Error **errp)
info = g_new0(GuestOSInfo, 1); info = g_new0(GuestOSInfo, 1);
info->has_kernel_version = true;
info->kernel_version = g_strdup_printf("%lu.%lu", info->kernel_version = g_strdup_printf("%lu.%lu",
os_version.dwMajorVersion, os_version.dwMajorVersion,
os_version.dwMinorVersion); os_version.dwMinorVersion);
info->has_kernel_release = true;
info->kernel_release = g_strdup_printf("%lu", info->kernel_release = g_strdup_printf("%lu",
os_version.dwBuildNumber); os_version.dwBuildNumber);
info->has_machine = true;
info->machine = ga_get_current_arch(); info->machine = ga_get_current_arch();
info->has_id = true;
info->id = g_strdup("mswindows"); info->id = g_strdup("mswindows");
info->has_name = true;
info->name = g_strdup("Microsoft Windows"); info->name = g_strdup("Microsoft Windows");
info->has_pretty_name = true;
info->pretty_name = product_name; info->pretty_name = product_name;
info->has_version = true;
info->version = ga_get_win_name(&os_version, false); info->version = ga_get_win_name(&os_version, false);
info->has_version_id = true;
info->version_id = ga_get_win_name(&os_version, true); info->version_id = ga_get_win_name(&os_version, true);
info->has_variant = true;
info->variant = g_strdup(server ? "server" : "client"); info->variant = g_strdup(server ? "server" : "client");
info->has_variant_id = true;
info->variant_id = g_strdup(server ? "server" : "client"); info->variant_id = g_strdup(server ? "server" : "client");
return info; return info;
@ -2478,7 +2454,6 @@ GuestDeviceInfoList *qmp_guest_get_devices(Error **errp)
device_id = g_match_info_fetch(match_info, 2); device_id = g_match_info_fetch(match_info, 2);
device->id = g_new0(GuestDeviceId, 1); device->id = g_new0(GuestDeviceId, 1);
device->has_id = true;
device->id->type = GUEST_DEVICE_TYPE_PCI; device->id->type = GUEST_DEVICE_TYPE_PCI;
id = &device->id->u.pci; id = &device->id->u.pci;
id->vendor_id = g_ascii_strtoull(vendor_id, NULL, 16); id->vendor_id = g_ascii_strtoull(vendor_id, NULL, 16);
@ -2502,7 +2477,6 @@ GuestDeviceInfoList *qmp_guest_get_devices(Error **errp)
error_setg(errp, "conversion to utf8 failed (driver version)"); error_setg(errp, "conversion to utf8 failed (driver version)");
return NULL; return NULL;
} }
device->has_driver_version = true;
date = (LPFILETIME)cm_get_property(dev_info_data.DevInst, date = (LPFILETIME)cm_get_property(dev_info_data.DevInst,
&qga_DEVPKEY_Device_DriverDate, &cm_type); &qga_DEVPKEY_Device_DriverDate, &cm_type);

11
qga/commands.c
View File

@ -206,14 +206,12 @@ GuestExecStatus *qmp_guest_exec_status(int64_t pid, Error **errp)
} }
#endif #endif
if (gei->out.length > 0) { if (gei->out.length > 0) {
ges->has_out_data = true;
ges->out_data = g_base64_encode(gei->out.data, gei->out.length); ges->out_data = g_base64_encode(gei->out.data, gei->out.length);
g_free(gei->out.data); g_free(gei->out.data);
ges->has_out_truncated = gei->out.truncated; ges->has_out_truncated = gei->out.truncated;
} }
if (gei->err.length > 0) { if (gei->err.length > 0) {
ges->has_err_data = true;
ges->err_data = g_base64_encode(gei->err.data, gei->err.length); ges->err_data = g_base64_encode(gei->err.data, gei->err.length);
g_free(gei->err.data); g_free(gei->err.data);
ges->has_err_truncated = gei->err.truncated; ges->has_err_truncated = gei->err.truncated;
@ -385,7 +383,7 @@ close:
GuestExec *qmp_guest_exec(const char *path, GuestExec *qmp_guest_exec(const char *path,
bool has_arg, strList *arg, bool has_arg, strList *arg,
bool has_env, strList *env, bool has_env, strList *env,
bool has_input_data, const char *input_data, const char *input_data,
bool has_capture_output, bool capture_output, bool has_capture_output, bool capture_output,
Error **errp) Error **errp)
{ {
@ -406,7 +404,7 @@ GuestExec *qmp_guest_exec(const char *path,
arglist.value = (char *)path; arglist.value = (char *)path;
arglist.next = has_arg ? arg : NULL; arglist.next = has_arg ? arg : NULL;
if (has_input_data) { if (input_data) {
input = qbase64_decode(input_data, -1, &ninput, errp); input = qbase64_decode(input_data, -1, &ninput, errp);
if (!input) { if (!input) {
return NULL; return NULL;
@ -423,7 +421,7 @@ GuestExec *qmp_guest_exec(const char *path,
} }
ret = g_spawn_async_with_pipes(NULL, argv, envp, flags, ret = g_spawn_async_with_pipes(NULL, argv, envp, flags,
guest_exec_task_setup, NULL, &pid, has_input_data ? &in_fd : NULL, guest_exec_task_setup, NULL, &pid, input_data ? &in_fd : NULL,
has_output ? &out_fd : NULL, has_output ? &err_fd : NULL, &gerr); has_output ? &out_fd : NULL, has_output ? &err_fd : NULL, &gerr);
if (!ret) { if (!ret) {
error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message); error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message);
@ -438,7 +436,7 @@ GuestExec *qmp_guest_exec(const char *path,
gei->has_output = has_output; gei->has_output = has_output;
g_child_watch_add(pid, guest_exec_child_watch, gei); g_child_watch_add(pid, guest_exec_child_watch, gei);
if (has_input_data) { if (input_data) {
gei->in.data = g_steal_pointer(&input); gei->in.data = g_steal_pointer(&input);
gei->in.size = ninput; gei->in.size = ninput;
#ifdef G_OS_WIN32 #ifdef G_OS_WIN32
@ -547,7 +545,6 @@ GuestTimezone *qmp_guest_get_timezone(Error **errp)
info->offset = g_time_zone_get_offset(tz, intv); info->offset = g_time_zone_get_offset(tz, intv);
name = g_time_zone_get_abbreviation(tz, intv); name = g_time_zone_get_abbreviation(tz, intv);
if (name != NULL) { if (name != NULL) {
info->has_zone = true;
info->zone = g_strdup(name); info->zone = g_strdup(name);
} }
g_time_zone_unref(tz); g_time_zone_unref(tz);

7
qom/qom-qmp-cmds.c
View File

@ -99,15 +99,13 @@ static void qom_list_types_tramp(ObjectClass *klass, void *data)
info->name = g_strdup(object_class_get_name(klass)); info->name = g_strdup(object_class_get_name(klass));
info->has_abstract = info->abstract = object_class_is_abstract(klass); info->has_abstract = info->abstract = object_class_is_abstract(klass);
if (parent) { if (parent) {
info->has_parent = true;
info->parent = g_strdup(object_class_get_name(parent)); info->parent = g_strdup(object_class_get_name(parent));
} }
QAPI_LIST_PREPEND(*pret, info); QAPI_LIST_PREPEND(*pret, info);
} }
ObjectTypeInfoList *qmp_qom_list_types(bool has_implements, ObjectTypeInfoList *qmp_qom_list_types(const char *implements,
const char *implements,
bool has_abstract, bool has_abstract,
bool abstract, bool abstract,
Error **errp) Error **errp)
@ -168,10 +166,8 @@ ObjectPropertyInfoList *qmp_device_list_properties(const char *typename,
info = g_new0(ObjectPropertyInfo, 1); info = g_new0(ObjectPropertyInfo, 1);
info->name = g_strdup(prop->name); info->name = g_strdup(prop->name);
info->type = g_strdup(prop->type); info->type = g_strdup(prop->type);
info->has_description = !!prop->description;
info->description = g_strdup(prop->description); info->description = g_strdup(prop->description);
info->default_value = qobject_ref(prop->defval); info->default_value = qobject_ref(prop->defval);
info->has_default_value = !!info->default_value;
QAPI_LIST_PREPEND(prop_list, info); QAPI_LIST_PREPEND(prop_list, info);
} }
@ -215,7 +211,6 @@ ObjectPropertyInfoList *qmp_qom_list_properties(const char *typename,
info = g_malloc0(sizeof(*info)); info = g_malloc0(sizeof(*info));
info->name = g_strdup(prop->name); info->name = g_strdup(prop->name);
info->type = g_strdup(prop->type); info->type = g_strdup(prop->type);
info->has_description = !!prop->description;
info->description = g_strdup(prop->description); info->description = g_strdup(prop->description);
QAPI_LIST_PREPEND(prop_list, info); QAPI_LIST_PREPEND(prop_list, info);

1
replay/replay-debugging.c
View File

@ -50,7 +50,6 @@ ReplayInfo *qmp_query_replay(Error **errp)
retval->mode = replay_mode; retval->mode = replay_mode;
if (replay_get_filename()) { if (replay_get_filename()) {
retval->filename = g_strdup(replay_get_filename()); retval->filename = g_strdup(replay_get_filename());
retval->has_filename = true;
} }
retval->icount = replay_get_current_icount(); retval->icount = replay_get_current_icount();
return retval; return retval;

9
scripts/qapi/commands.py
View File

@ -64,7 +64,7 @@ def gen_call(name: str,
elif arg_type: elif arg_type:
assert not arg_type.variants assert not arg_type.variants
for memb in arg_type.members: for memb in arg_type.members:
if memb.optional: if memb.need_has():
argstr += 'arg.has_%s, ' % c_name(memb.name) argstr += 'arg.has_%s, ' % c_name(memb.name)
argstr += 'arg.%s, ' % c_name(memb.name) argstr += 'arg.%s, ' % c_name(memb.name)
@ -83,7 +83,7 @@ def gen_call(name: str,
trace_qmp_enter_%(name)s(req_json->str); trace_qmp_enter_%(name)s(req_json->str);
} }
''', ''',
upper=upper, name=name) upper=upper, name=name)
ret += mcgen(''' ret += mcgen('''
@ -124,13 +124,13 @@ def gen_call(name: str,
trace_qmp_exit_%(name)s(ret_json->str, true); trace_qmp_exit_%(name)s(ret_json->str, true);
} }
''', ''',
upper=upper, name=name) upper=upper, name=name)
else: else:
ret += mcgen(''' ret += mcgen('''
trace_qmp_exit_%(name)s("{}", true); trace_qmp_exit_%(name)s("{}", true);
''', ''',
name=name) name=name)
return ret return ret
@ -316,7 +316,6 @@ class QAPISchemaGenCommandVisitor(QAPISchemaModularCVisitor):
#include "qapi/error.h" #include "qapi/error.h"
#include "%(visit)s.h" #include "%(visit)s.h"
#include "%(commands)s.h" #include "%(commands)s.h"
''', ''',
commands=commands, visit=visit)) commands=commands, visit=visit))

3
scripts/qapi/events.py
View File

@ -60,7 +60,7 @@ def gen_param_var(typ: QAPISchemaObjectType) -> str:
for memb in typ.members: for memb in typ.members:
ret += sep ret += sep
sep = ', ' sep = ', '
if memb.optional: if memb.need_has():
ret += 'has_' + c_name(memb.name) + sep ret += 'has_' + c_name(memb.name) + sep
if memb.type.name == 'str': if memb.type.name == 'str':
# Cast away const added in build_params() # Cast away const added in build_params()
@ -196,7 +196,6 @@ class QAPISchemaGenEventVisitor(QAPISchemaModularCVisitor):
#include "qapi/error.h" #include "qapi/error.h"
#include "qapi/qmp/qdict.h" #include "qapi/qmp/qdict.h"
#include "qapi/qmp-event.h" #include "qapi/qmp-event.h"
''', ''',
events=events, visit=visit, events=events, visit=visit,
prefix=self._prefix)) prefix=self._prefix))

2
scripts/qapi/gen.py
View File

@ -121,7 +121,7 @@ def build_params(arg_type: Optional[QAPISchemaObjectType],
for memb in arg_type.members: for memb in arg_type.members:
ret += sep ret += sep
sep = ', ' sep = ', '
if memb.optional: if memb.need_has():
ret += 'bool has_%s, ' % c_name(memb.name) ret += 'bool has_%s, ' % c_name(memb.name)
ret += '%s %s' % (memb.type.c_param_type(), ret += '%s %s' % (memb.type.c_param_type(),
c_name(memb.name)) c_name(memb.name))

14
scripts/qapi/schema.py
View File

@ -253,6 +253,11 @@ class QAPISchemaType(QAPISchemaEntity):
return None return None
return self.name return self.name
def need_has_if_optional(self):
# When FOO is a pointer, has_FOO == !!FOO, i.e. has_FOO is redundant.
# Except for arrays; see QAPISchemaArrayType.need_has_if_optional().
return not self.c_type().endswith(POINTER_SUFFIX)
def check(self, schema): def check(self, schema):
QAPISchemaEntity.check(self, schema) QAPISchemaEntity.check(self, schema)
for feat in self.features: for feat in self.features:
@ -352,6 +357,11 @@ class QAPISchemaArrayType(QAPISchemaType):
self._element_type_name = element_type self._element_type_name = element_type
self.element_type = None self.element_type = None
def need_has_if_optional(self):
# When FOO is an array, we still need has_FOO to distinguish
# absent (!has_FOO) from present and empty (has_FOO && !FOO).
return True
def check(self, schema): def check(self, schema):
super().check(schema) super().check(schema)
self.element_type = schema.resolve_type( self.element_type = schema.resolve_type(
@ -745,6 +755,10 @@ class QAPISchemaObjectTypeMember(QAPISchemaMember):
self.optional = optional self.optional = optional
self.features = features or [] self.features = features or []
def need_has(self):
assert self.type
return self.optional and self.type.need_has_if_optional()
def check(self, schema): def check(self, schema):
assert self.defined_in assert self.defined_in
self.type = schema.resolve_type(self._type_name, self.info, self.type = schema.resolve_type(self._type_name, self.info,

2
scripts/qapi/types.py
View File

@ -142,7 +142,7 @@ def gen_struct_members(members: List[QAPISchemaObjectTypeMember]) -> str:
ret = '' ret = ''
for memb in members: for memb in members:
ret += memb.ifcond.gen_if() ret += memb.ifcond.gen_if()
if memb.optional: if memb.need_has():
ret += mcgen(''' ret += mcgen('''
bool has_%(c_name)s; bool has_%(c_name)s;
''', ''',

17
scripts/qapi/visit.py
View File

@ -71,6 +71,16 @@ bool visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp)
''', ''',
c_name=c_name(name)) c_name=c_name(name))
sep = ''
for memb in members:
if memb.optional and not memb.need_has():
ret += mcgen('''
bool has_%(c_name)s = !!obj->%(c_name)s;
''',
c_name=c_name(memb.name))
sep = '\n'
ret += sep
if base: if base:
ret += mcgen(''' ret += mcgen('''
if (!visit_type_%(c_type)s_members(v, (%(c_type)s *)obj, errp)) { if (!visit_type_%(c_type)s_members(v, (%(c_type)s *)obj, errp)) {
@ -82,10 +92,13 @@ bool visit_type_%(c_name)s_members(Visitor *v, %(c_name)s *obj, Error **errp)
for memb in members: for memb in members:
ret += memb.ifcond.gen_if() ret += memb.ifcond.gen_if()
if memb.optional: if memb.optional:
has = 'has_' + c_name(memb.name)
if memb.need_has():
has = 'obj->' + has
ret += mcgen(''' ret += mcgen('''
if (visit_optional(v, "%(name)s", &obj->has_%(c_name)s)) { if (visit_optional(v, "%(name)s", &%(has)s)) {
''', ''',
name=memb.name, c_name=c_name(memb.name)) name=memb.name, has=has)
indent.increase() indent.increase()
special_features = gen_special_features(memb.features) special_features = gen_special_features(memb.features)
if special_features != '0': if special_features != '0':

18
softmmu/runstate.c
View File

@ -484,18 +484,15 @@ void qemu_system_guest_panicked(GuestPanicInformation *info)
*/ */
if (panic_action == PANIC_ACTION_PAUSE if (panic_action == PANIC_ACTION_PAUSE
|| (panic_action == PANIC_ACTION_SHUTDOWN && shutdown_action == SHUTDOWN_ACTION_PAUSE)) { || (panic_action == PANIC_ACTION_SHUTDOWN && shutdown_action == SHUTDOWN_ACTION_PAUSE)) {
qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_PAUSE, info);
!!info, info);
vm_stop(RUN_STATE_GUEST_PANICKED); vm_stop(RUN_STATE_GUEST_PANICKED);
} else if (panic_action == PANIC_ACTION_SHUTDOWN || } else if (panic_action == PANIC_ACTION_SHUTDOWN ||
panic_action == PANIC_ACTION_EXIT_FAILURE) { panic_action == PANIC_ACTION_EXIT_FAILURE) {
qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_POWEROFF, info);
!!info, info);
vm_stop(RUN_STATE_GUEST_PANICKED); vm_stop(RUN_STATE_GUEST_PANICKED);
qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC); qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_PANIC);
} else { } else {
qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN, qapi_event_send_guest_panicked(GUEST_PANIC_ACTION_RUN, info);
!!info, info);
} }
if (info) { if (info) {
@ -522,13 +519,8 @@ void qemu_system_guest_panicked(GuestPanicInformation *info)
void qemu_system_guest_crashloaded(GuestPanicInformation *info) void qemu_system_guest_crashloaded(GuestPanicInformation *info)
{ {
qemu_log_mask(LOG_GUEST_ERROR, "Guest crash loaded"); qemu_log_mask(LOG_GUEST_ERROR, "Guest crash loaded");
qapi_event_send_guest_crashloaded(GUEST_PANIC_ACTION_RUN, info);
qapi_event_send_guest_crashloaded(GUEST_PANIC_ACTION_RUN, qapi_free_GuestPanicInformation(info);
!!info, info);
if (info) {
qapi_free_GuestPanicInformation(info);
}
} }
void qemu_system_reset_request(ShutdownCause reason) void qemu_system_reset_request(ShutdownCause reason)

2
softmmu/vl.c
View File

@ -611,7 +611,7 @@ static int parse_add_fd(void *opaque, QemuOpts *opts, Error **errp)
} }
/* add the duplicate fd, and optionally the opaque string, to the fd set */ /* add the duplicate fd, and optionally the opaque string, to the fd set */
fdinfo = monitor_fdset_add_fd(dupfd, true, fdset_id, !!fd_opaque, fd_opaque, fdinfo = monitor_fdset_add_fd(dupfd, true, fdset_id, fd_opaque,
&error_abort); &error_abort);
g_free(fdinfo); g_free(fdinfo);

6
stubs/qdev.c
View File

@ -15,15 +15,13 @@
#include "qemu/osdep.h" #include "qemu/osdep.h"
#include "qapi/qapi-events-qdev.h" #include "qapi/qapi-events-qdev.h"
void qapi_event_send_device_deleted(bool has_device, void qapi_event_send_device_deleted(const char *device,
const char *device,
const char *path) const char *path)
{ {
/* Nothing to do. */ /* Nothing to do. */
} }
void qapi_event_send_device_unplug_guest_error(bool has_device, void qapi_event_send_device_unplug_guest_error(const char *device,
const char *device,
const char *path) const char *path)
{ {
/* Nothing to do. */ /* Nothing to do. */

1
target/arm/monitor.c
View File

@ -221,7 +221,6 @@ CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type,
qobject_unref(qdict_out); qobject_unref(qdict_out);
} else { } else {
expansion_info->model->props = QOBJECT(qdict_out); expansion_info->model->props = QOBJECT(qdict_out);
expansion_info->model->has_props = true;
} }
object_unref(obj); object_unref(obj);

7
target/i386/cpu-sysemu.c
View File

@ -187,10 +187,8 @@ qmp_query_cpu_model_expansion(CpuModelExpansionType type,
QDict *props = NULL; QDict *props = NULL;
const char *base_name; const char *base_name;
xc = x86_cpu_from_model(model->name, xc = x86_cpu_from_model(model->name, qobject_to(QDict, model->props),
model->has_props ? &err);
qobject_to(QDict, model->props) :
NULL, &err);
if (err) { if (err) {
goto out; goto out;
} }
@ -198,7 +196,6 @@ qmp_query_cpu_model_expansion(CpuModelExpansionType type,
props = qdict_new(); props = qdict_new();
ret->model = g_new0(CpuModelInfo, 1); ret->model = g_new0(CpuModelInfo, 1);
ret->model->props = QOBJECT(props); ret->model->props = QOBJECT(props);
ret->model->has_props = true;
switch (type) { switch (type) {
case CPU_MODEL_EXPANSION_TYPE_STATIC: case CPU_MODEL_EXPANSION_TYPE_STATIC:

1
target/i386/cpu.c
View File

@ -4901,7 +4901,6 @@ static void x86_cpu_definition_entry(gpointer data, gpointer user_data)
*/ */
if (default_cpu_version != CPU_VERSION_LEGACY) { if (default_cpu_version != CPU_VERSION_LEGACY) {
info->alias_of = x86_cpu_class_get_alias_of(cc); info->alias_of = x86_cpu_class_get_alias_of(cc);
info->has_alias_of = !!info->alias_of;
} }
QAPI_LIST_PREPEND(*cpu_list, info); QAPI_LIST_PREPEND(*cpu_list, info);

1
target/s390x/cpu_models_sysemu.c
View File

@ -210,7 +210,6 @@ static void cpu_info_from_model(CpuModelInfo *info, const S390CPUModel *model,
qobject_unref(qdict); qobject_unref(qdict);
} else { } else {
info->props = QOBJECT(qdict); info->props = QOBJECT(qdict);
info->has_props = true;
} }
} }

3
tests/qtest/fuzz/qos_fuzz.c
View File

@ -50,8 +50,7 @@ static void qos_set_machines_devices_available(void)
machines_apply_to_node(mach_info); machines_apply_to_node(mach_info);
qapi_free_MachineInfoList(mach_info); qapi_free_MachineInfoList(mach_info);
type_info = qmp_qom_list_types(true, "device", true, true, type_info = qmp_qom_list_types("device", true, true, &error_abort);
&error_abort);
types_apply_to_node(type_info); types_apply_to_node(type_info);
qapi_free_ObjectTypeInfoList(type_info); qapi_free_ObjectTypeInfoList(type_info);
} }

2
tests/qtest/qmp-cmd-test.c
View File

@ -174,7 +174,7 @@ static bool object_type_has_mandatory_members(SchemaInfo *type)
g_assert(type->meta_type == SCHEMA_META_TYPE_OBJECT); g_assert(type->meta_type == SCHEMA_META_TYPE_OBJECT);
for (tail = type->u.object.members; tail; tail = tail->next) { for (tail = type->u.object.members; tail; tail = tail->next) {
if (!tail->value->has_q_default) { if (!tail->value->q_default) {
return true; return true;
} }
} }

1
tests/unit/test-char.c
View File

@ -1212,7 +1212,6 @@ static void char_file_fifo_test(void)
char *fifo = g_build_filename(tmp_path, "fifo", NULL); char *fifo = g_build_filename(tmp_path, "fifo", NULL);
char *out = g_build_filename(tmp_path, "out", NULL); char *out = g_build_filename(tmp_path, "out", NULL);
ChardevFile file = { .in = fifo, ChardevFile file = { .in = fifo,
.has_in = true,
.out = out }; .out = out };
ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE, ChardevBackend backend = { .type = CHARDEV_BACKEND_KIND_FILE,
.u.file.data = &file }; .u.file.data = &file };

6
tests/unit/test-crypto-block.c
View File

@ -41,7 +41,6 @@
static QCryptoBlockCreateOptions qcow_create_opts = { static QCryptoBlockCreateOptions qcow_create_opts = {
.format = Q_CRYPTO_BLOCK_FORMAT_QCOW, .format = Q_CRYPTO_BLOCK_FORMAT_QCOW,
.u.qcow = { .u.qcow = {
.has_key_secret = true,
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
}, },
}; };
@ -49,7 +48,6 @@ static QCryptoBlockCreateOptions qcow_create_opts = {
static QCryptoBlockOpenOptions qcow_open_opts = { static QCryptoBlockOpenOptions qcow_open_opts = {
.format = Q_CRYPTO_BLOCK_FORMAT_QCOW, .format = Q_CRYPTO_BLOCK_FORMAT_QCOW,
.u.qcow = { .u.qcow = {
.has_key_secret = true,
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
}, },
}; };
@ -59,7 +57,6 @@ static QCryptoBlockOpenOptions qcow_open_opts = {
static QCryptoBlockOpenOptions luks_open_opts = { static QCryptoBlockOpenOptions luks_open_opts = {
.format = Q_CRYPTO_BLOCK_FORMAT_LUKS, .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
.u.luks = { .u.luks = {
.has_key_secret = true,
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
}, },
}; };
@ -69,7 +66,6 @@ static QCryptoBlockOpenOptions luks_open_opts = {
static QCryptoBlockCreateOptions luks_create_opts_default = { static QCryptoBlockCreateOptions luks_create_opts_default = {
.format = Q_CRYPTO_BLOCK_FORMAT_LUKS, .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
.u.luks = { .u.luks = {
.has_key_secret = true,
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
}, },
}; };
@ -79,7 +75,6 @@ static QCryptoBlockCreateOptions luks_create_opts_default = {
static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_plain64 = { static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_plain64 = {
.format = Q_CRYPTO_BLOCK_FORMAT_LUKS, .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
.u.luks = { .u.luks = {
.has_key_secret = true,
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
.has_cipher_alg = true, .has_cipher_alg = true,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256, .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,
@ -94,7 +89,6 @@ static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_plain64 = {
static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_essiv = { static QCryptoBlockCreateOptions luks_create_opts_aes256_cbc_essiv = {
.format = Q_CRYPTO_BLOCK_FORMAT_LUKS, .format = Q_CRYPTO_BLOCK_FORMAT_LUKS,
.u.luks = { .u.luks = {
.has_key_secret = true,
.key_secret = (char *)"sec0", .key_secret = (char *)"sec0",
.has_cipher_alg = true, .has_cipher_alg = true,
.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256, .cipher_alg = QCRYPTO_CIPHER_ALG_AES_256,

26
tests/unit/test-qmp-cmds.c
View File

@ -43,15 +43,15 @@ void qmp_user_def_cmd1(UserDefOne * ud1, Error **errp)
{ {
} }
FeatureStruct1 *qmp_test_features0(bool has_fs0, FeatureStruct0 *fs0, FeatureStruct1 *qmp_test_features0(FeatureStruct0 *fs0,
bool has_fs1, FeatureStruct1 *fs1, FeatureStruct1 *fs1,
bool has_fs2, FeatureStruct2 *fs2, FeatureStruct2 *fs2,
bool has_fs3, FeatureStruct3 *fs3, FeatureStruct3 *fs3,
bool has_fs4, FeatureStruct4 *fs4, FeatureStruct4 *fs4,
bool has_cfs1, CondFeatureStruct1 *cfs1, CondFeatureStruct1 *cfs1,
bool has_cfs2, CondFeatureStruct2 *cfs2, CondFeatureStruct2 *cfs2,
bool has_cfs3, CondFeatureStruct3 *cfs3, CondFeatureStruct3 *cfs3,
bool has_cfs4, CondFeatureStruct4 *cfs4, CondFeatureStruct4 *cfs4,
Error **errp) Error **errp)
{ {
return g_new0(FeatureStruct1, 1); return g_new0(FeatureStruct1, 1);
@ -77,8 +77,7 @@ void qmp_test_command_cond_features3(Error **errp)
{ {
} }
UserDefTwo *qmp_user_def_cmd2(UserDefOne *ud1a, UserDefTwo *qmp_user_def_cmd2(UserDefOne *ud1a, UserDefOne *ud1b,
bool has_udb1, UserDefOne *ud1b,
Error **errp) Error **errp)
{ {
UserDefTwo *ret; UserDefTwo *ret;
@ -87,8 +86,8 @@ UserDefTwo *qmp_user_def_cmd2(UserDefOne *ud1a,
ud1c->string = strdup(ud1a->string); ud1c->string = strdup(ud1a->string);
ud1c->integer = ud1a->integer; ud1c->integer = ud1a->integer;
ud1d->string = strdup(has_udb1 ? ud1b->string : "blah0"); ud1d->string = strdup(ud1b ? ud1b->string : "blah0");
ud1d->integer = has_udb1 ? ud1b->integer : 0; ud1d->integer = ud1b ? ud1b->integer : 0;
ret = g_new0(UserDefTwo, 1); ret = g_new0(UserDefTwo, 1);
ret->string0 = strdup("blah1"); ret->string0 = strdup("blah1");
@ -98,7 +97,6 @@ UserDefTwo *qmp_user_def_cmd2(UserDefOne *ud1a,
ret->dict1->dict2->userdef = ud1c; ret->dict1->dict2->userdef = ud1c;
ret->dict1->dict2->string = strdup("blah3"); ret->dict1->dict2->string = strdup("blah3");
ret->dict1->dict3 = g_new0(UserDefTwoDictDict, 1); ret->dict1->dict3 = g_new0(UserDefTwoDictDict, 1);
ret->dict1->has_dict3 = true;
ret->dict1->dict3->userdef = ud1d; ret->dict1->dict3->userdef = ud1d;
ret->dict1->dict3->string = strdup("blah4"); ret->dict1->dict3->string = strdup("blah4");

4
tests/unit/test-qmp-event.c
View File

@ -109,7 +109,7 @@ static void test_event_c(TestEventData *data,
data->expect = qdict_from_jsonf_nofail( data->expect = qdict_from_jsonf_nofail(
"{ 'event': 'EVENT_C', 'data': {" "{ 'event': 'EVENT_C', 'data': {"
" 'a': 1, 'b': { 'integer': 2, 'string': 'test1' }, 'c': 'test2' } }"); " 'a': 1, 'b': { 'integer': 2, 'string': 'test1' }, 'c': 'test2' } }");
qapi_event_send_event_c(true, 1, true, &b, "test2"); qapi_event_send_event_c(true, 1, &b, "test2");
g_assert(data->emitted); g_assert(data->emitted);
qobject_unref(data->expect); qobject_unref(data->expect);
} }
@ -135,7 +135,7 @@ static void test_event_d(TestEventData *data,
" 'struct1': { 'integer': 2, 'string': 'test1', 'enum1': 'value1' }," " 'struct1': { 'integer': 2, 'string': 'test1', 'enum1': 'value1' },"
" 'string': 'test2', 'enum2': 'value2' }," " 'string': 'test2', 'enum2': 'value2' },"
" 'b': 'test3', 'enum3': 'value3' } }"); " 'b': 'test3', 'enum3': 'value3' } }");
qapi_event_send_event_d(&a, "test3", false, NULL, true, ENUM_ONE_VALUE3); qapi_event_send_event_d(&a, "test3", NULL, true, ENUM_ONE_VALUE3);
g_assert(data->emitted); g_assert(data->emitted);
qobject_unref(data->expect); qobject_unref(data->expect);
} }

2
tests/unit/test-qobject-input-visitor.c
View File

@ -431,7 +431,7 @@ static void test_visitor_in_struct_nested(TestInputVisitorData *data,
g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42); g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string"); g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2"); g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
g_assert(udp->dict1->has_dict3 == false); g_assert(!udp->dict1->dict3);
} }
static void test_visitor_in_list(TestInputVisitorData *data, static void test_visitor_in_list(TestInputVisitorData *data,

2
tests/unit/test-qobject-output-visitor.c
View File

@ -182,7 +182,6 @@ static void test_visitor_out_struct_nested(TestOutputVisitorData *data,
ud2->dict1->dict2->string = g_strdup(strings[2]); ud2->dict1->dict2->string = g_strdup(strings[2]);
ud2->dict1->dict3 = g_malloc0(sizeof(*ud2->dict1->dict3)); ud2->dict1->dict3 = g_malloc0(sizeof(*ud2->dict1->dict3));
ud2->dict1->has_dict3 = true;
ud2->dict1->dict3->userdef = g_new0(UserDefOne, 1); ud2->dict1->dict3->userdef = g_new0(UserDefOne, 1);
ud2->dict1->dict3->userdef->string = g_strdup(string); ud2->dict1->dict3->userdef->string = g_strdup(string);
ud2->dict1->dict3->userdef->integer = value; ud2->dict1->dict3->userdef->integer = value;
@ -284,7 +283,6 @@ static void test_visitor_out_list_qapi_free(TestOutputVisitorData *data,
value->dict1->dict2->userdef->string = g_strdup(string); value->dict1->dict2->userdef->string = g_strdup(string);
value->dict1->dict2->userdef->integer = 42; value->dict1->dict2->userdef->integer = 42;
value->dict1->dict2->string = g_strdup(string); value->dict1->dict2->string = g_strdup(string);
value->dict1->has_dict3 = false;
QAPI_LIST_PREPEND(head, value); QAPI_LIST_PREPEND(head, value);
} }

Some files were not shown because too many files have changed in this diff Show More