david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

QAPI patches for 2018-05-04

Browse Source 
-----BEGIN PGP SIGNATURE-----
 
 iQIcBAABAgAGBQJa7BLUAAoJEDhwtADrkYZTumIQAJC6wXmN+wBYc2MoR2Y8SQgY
 +gTM9J6R6H50ijb7RkkERLTgys7IxCDD/jy2p0yX/Re3ReXbYwzYQXmSFpF1KWGe
 SXB84uDtwSILbvR5iS0TBdQSyO+u5DRboukuLfTEZHjYQUP+guT1we3YwqWGzIKp
 o5kV/7Nq0vPWO5Sbs4FWB0t9hWzWV3Kef9b4gRPn05sWPaq2/sU6A3xai+ty6qS7
 PCm7VwT4z5SACdR4LRiL45h3HdThgr/alJJ6lUr2kaNCBiDBvM4h6d7W+lI/Vi3Y
 rG+wqyPQFyWLXf0uuI3AmSScVUzfYv9C4TcBTJkFnebrFcybPsGwEJLGtaIgFnBU
 1Mcz/TCl1bB4fDvhwV2qexxlXryOWXKn+ygdu9sBSY/QSA+NEqbJQo6cCDqMQ9Qy
 6zqrGxUrM/peVLvhfle4cIbyPslGRGn2s95oQzCJi8TlZxBj8lgW1x1kr7OhSlf4
 rNteSYAHDNSiNVL1PcW3vOS7ndTA6O0vHAtGa+0vbQzAf+RUfFG0sfggG6350O8e
 97Hp4LKT3VpGEuwyQEw6wk3zODNfAgtkkwjQHTnQYHriKB/fcVfY3g7gpYp4zMLF
 GJ3h5KZj71JNoFoxVJniAgkWY8+IP11ggXMyYWSMxMZ3M81EqQ/rbvOvGxn1wjd8
 kHbpUEMmGBHF1VmKs7e1
 =Kukn
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/armbru/tags/pull-qapi-2018-05-04' into staging

QAPI patches for 2018-05-04

# gpg: Signature made Fri 04 May 2018 08:59:16 BST
# gpg:                using RSA key 3870B400EB918653
# gpg: Good signature from "Markus Armbruster <armbru@redhat.com>"
# gpg:                 aka "Markus Armbruster <armbru@pond.sub.org>"
# Primary key fingerprint: 354B C8B3 D7EB 2A6B 6867  4E5F 3870 B400 EB91 8653

* remotes/armbru/tags/pull-qapi-2018-05-04:
  qapi: deprecate CpuInfoFast.arch
  qapi: discriminate CpuInfoFast on SysEmuTarget, not CpuInfoArch
  qapi: change the type of TargetInfo.arch from string to enum SysEmuTarget
  qapi: add SysEmuTarget to "common.json"
  qapi: fill in CpuInfoFast.arch in query-cpus-fast
  qobject: Modify qobject_ref() to return obj
  qobject: Replace qobject_incref/QINCREF qobject_decref/QDECREF
  qobject: use a QObjectBase_ struct
  qobject: Ensure base is at offset 0
  qobject: Use qobject_to() instead of type cast

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2018-05-04 13:49:08 +01:00
commit 7c867af89a
106 changed files with 816 additions and 703 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
arch_init.c
View File

@ -29,6 +29,7 @@
#include "hw/pci/pci.h" #include "hw/pci/pci.h"
#include "hw/audio/soundhw.h" #include "hw/audio/soundhw.h"
#include "qapi/qapi-commands-misc.h" #include "qapi/qapi-commands-misc.h"
#include "qapi/error.h"
#include "qemu/config-file.h" #include "qemu/config-file.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "hw/acpi/acpi.h" #include "hw/acpi/acpi.h"
@ -112,7 +113,8 @@ TargetInfo *qmp_query_target(Error **errp)
{ {
TargetInfo *info = g_malloc0(sizeof(*info)); TargetInfo *info = g_malloc0(sizeof(*info));
info->arch = g_strdup(TARGET_NAME); info->arch = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME, -1,
&error_abort);
return info; return info;
} }

82
block.c
View File

@ -1227,9 +1227,9 @@ BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp); ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
if (ret < 0) { if (ret < 0) {
QDECREF(bs->explicit_options); qobject_unref(bs->explicit_options);
bs->explicit_options = NULL; bs->explicit_options = NULL;
QDECREF(bs->options); qobject_unref(bs->options);
bs->options = NULL; bs->options = NULL;
bdrv_unref(bs); bdrv_unref(bs);
return NULL; return NULL;
@ -1460,7 +1460,7 @@ static QDict *parse_json_filename(const char *filename, Error **errp)
options = qobject_to(QDict, options_obj); options = qobject_to(QDict, options_obj);
if (!options) { if (!options) {
qobject_decref(options_obj); qobject_unref(options_obj);
error_setg(errp, "Invalid JSON object given"); error_setg(errp, "Invalid JSON object given");
return NULL; return NULL;
} }
@ -1490,7 +1490,7 @@ static void parse_json_protocol(QDict *options, const char **pfilename,
/* Options given in the filename have lower priority than options /* Options given in the filename have lower priority than options
* specified directly */ * specified directly */
qdict_join(options, json_options, false); qdict_join(options, json_options, false);
QDECREF(json_options); qobject_unref(json_options);
*pfilename = NULL; *pfilename = NULL;
} }
@ -2273,7 +2273,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
if (reference || qdict_haskey(options, "file.filename")) { if (reference || qdict_haskey(options, "file.filename")) {
backing_filename[0] = '\0'; backing_filename[0] = '\0';
} else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) { } else if (bs->backing_file[0] == '\0' && qdict_size(options) == 0) {
QDECREF(options); qobject_unref(options);
goto free_exit; goto free_exit;
} else { } else {
bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX, bdrv_get_full_backing_filename(bs, backing_filename, PATH_MAX,
@ -2281,7 +2281,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
if (local_err) { if (local_err) {
ret = -EINVAL; ret = -EINVAL;
error_propagate(errp, local_err); error_propagate(errp, local_err);
QDECREF(options); qobject_unref(options);
goto free_exit; goto free_exit;
} }
} }
@ -2289,7 +2289,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
if (!bs->drv || !bs->drv->supports_backing) { if (!bs->drv || !bs->drv->supports_backing) {
ret = -EINVAL; ret = -EINVAL;
error_setg(errp, "Driver doesn't support backing files"); error_setg(errp, "Driver doesn't support backing files");
QDECREF(options); qobject_unref(options);
goto free_exit; goto free_exit;
} }
@ -2323,7 +2323,7 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
free_exit: free_exit:
g_free(backing_filename); g_free(backing_filename);
QDECREF(tmp_parent_options); qobject_unref(tmp_parent_options);
return ret; return ret;
} }
@ -2356,7 +2356,7 @@ bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
error_setg(errp, "A block device must be specified for \"%s\"", error_setg(errp, "A block device must be specified for \"%s\"",
bdref_key); bdref_key);
} }
QDECREF(image_options); qobject_unref(image_options);
goto done; goto done;
} }
@ -2449,7 +2449,7 @@ BlockDriverState *bdrv_open_blockdev_ref(BlockdevRef *ref, Error **errp)
obj = NULL; obj = NULL;
fail: fail:
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
return bs; return bs;
} }
@ -2519,7 +2519,7 @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
} }
out: out:
QDECREF(snapshot_options); qobject_unref(snapshot_options);
g_free(tmp_filename); g_free(tmp_filename);
return bs_snapshot; return bs_snapshot;
} }
@ -2530,7 +2530,7 @@ out:
* options is a QDict of options to pass to the block drivers, or NULL for an * options is a QDict of options to pass to the block drivers, or NULL for an
* empty set of options. The reference to the QDict belongs to the block layer * empty set of options. The reference to the QDict belongs to the block layer
* after the call (even on failure), so if the caller intends to reuse the * after the call (even on failure), so if the caller intends to reuse the
* dictionary, it needs to use QINCREF() before calling bdrv_open. * dictionary, it needs to use qobject_ref() before calling bdrv_open.
* *
* If *pbs is NULL, a new BDS will be created with a pointer to it stored there. * If *pbs is NULL, a new BDS will be created with a pointer to it stored there.
* If it is not NULL, the referenced BDS will be reused. * If it is not NULL, the referenced BDS will be reused.
@ -2561,7 +2561,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
if (reference) { if (reference) {
bool options_non_empty = options ? qdict_size(options) : false; bool options_non_empty = options ? qdict_size(options) : false;
QDECREF(options); qobject_unref(options);
if (filename || options_non_empty) { if (filename || options_non_empty) {
error_setg(errp, "Cannot reference an existing block device with " error_setg(errp, "Cannot reference an existing block device with "
@ -2752,7 +2752,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
bdrv_parent_cb_change_media(bs, true); bdrv_parent_cb_change_media(bs, true);
QDECREF(options); qobject_unref(options);
/* For snapshot=on, create a temporary qcow2 overlay. bs points to the /* For snapshot=on, create a temporary qcow2 overlay. bs points to the
* temporary snapshot afterwards. */ * temporary snapshot afterwards. */
@ -2776,10 +2776,10 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
fail: fail:
blk_unref(file); blk_unref(file);
QDECREF(snapshot_options); qobject_unref(snapshot_options);
QDECREF(bs->explicit_options); qobject_unref(bs->explicit_options);
QDECREF(bs->options); qobject_unref(bs->options);
QDECREF(options); qobject_unref(options);
bs->options = NULL; bs->options = NULL;
bs->explicit_options = NULL; bs->explicit_options = NULL;
bdrv_unref(bs); bdrv_unref(bs);
@ -2788,8 +2788,8 @@ fail:
close_and_fail: close_and_fail:
bdrv_unref(bs); bdrv_unref(bs);
QDECREF(snapshot_options); qobject_unref(snapshot_options);
QDECREF(options); qobject_unref(options);
error_propagate(errp, local_err); error_propagate(errp, local_err);
return NULL; return NULL;
} }
@ -2884,7 +2884,7 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
old_options = qdict_clone_shallow(bs->explicit_options); old_options = qdict_clone_shallow(bs->explicit_options);
} }
bdrv_join_options(bs, options, old_options); bdrv_join_options(bs, options, old_options);
QDECREF(old_options); qobject_unref(old_options);
explicit_options = qdict_clone_shallow(options); explicit_options = qdict_clone_shallow(options);
@ -2899,13 +2899,13 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
qemu_opts_absorb_qdict(opts, options_copy, NULL); qemu_opts_absorb_qdict(opts, options_copy, NULL);
update_flags_from_options(&flags, opts); update_flags_from_options(&flags, opts);
qemu_opts_del(opts); qemu_opts_del(opts);
QDECREF(options_copy); qobject_unref(options_copy);
} }
/* Old values are used for options that aren't set yet */ /* Old values are used for options that aren't set yet */
old_options = qdict_clone_shallow(bs->options); old_options = qdict_clone_shallow(bs->options);
bdrv_join_options(bs, options, old_options); bdrv_join_options(bs, options, old_options);
QDECREF(old_options); qobject_unref(old_options);
/* bdrv_open_inherit() sets and clears some additional flags internally */ /* bdrv_open_inherit() sets and clears some additional flags internally */
flags &= ~BDRV_O_PROTOCOL; flags &= ~BDRV_O_PROTOCOL;
@ -2917,8 +2917,8 @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
bs_entry = g_new0(BlockReopenQueueEntry, 1); bs_entry = g_new0(BlockReopenQueueEntry, 1);
QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry); QSIMPLEQ_INSERT_TAIL(bs_queue, bs_entry, entry);
} else { } else {
QDECREF(bs_entry->state.options); qobject_unref(bs_entry->state.options);
QDECREF(bs_entry->state.explicit_options); qobject_unref(bs_entry->state.explicit_options);
} }
bs_entry->state.bs = bs; bs_entry->state.bs = bs;
@ -3008,9 +3008,9 @@ cleanup:
if (ret && bs_entry->prepared) { if (ret && bs_entry->prepared) {
bdrv_reopen_abort(&bs_entry->state); bdrv_reopen_abort(&bs_entry->state);
} else if (ret) { } else if (ret) {
QDECREF(bs_entry->state.explicit_options); qobject_unref(bs_entry->state.explicit_options);
} }
QDECREF(bs_entry->state.options); qobject_unref(bs_entry->state.options);
g_free(bs_entry); g_free(bs_entry);
} }
g_free(bs_queue); g_free(bs_queue);
@ -3253,7 +3253,7 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state)
} }
/* set BDS specific flags now */ /* set BDS specific flags now */
QDECREF(bs->explicit_options); qobject_unref(bs->explicit_options);
bs->explicit_options = reopen_state->explicit_options; bs->explicit_options = reopen_state->explicit_options;
bs->open_flags = reopen_state->flags; bs->open_flags = reopen_state->flags;
@ -3296,7 +3296,7 @@ void bdrv_reopen_abort(BDRVReopenState *reopen_state)
drv->bdrv_reopen_abort(reopen_state); drv->bdrv_reopen_abort(reopen_state);
} }
QDECREF(reopen_state->explicit_options); qobject_unref(reopen_state->explicit_options);
bdrv_abort_perm_update(reopen_state->bs); bdrv_abort_perm_update(reopen_state->bs);
} }
@ -3343,11 +3343,11 @@ static void bdrv_close(BlockDriverState *bs)
bs->total_sectors = 0; bs->total_sectors = 0;
bs->encrypted = false; bs->encrypted = false;
bs->sg = false; bs->sg = false;
QDECREF(bs->options); qobject_unref(bs->options);
QDECREF(bs->explicit_options); qobject_unref(bs->explicit_options);
bs->options = NULL; bs->options = NULL;
bs->explicit_options = NULL; bs->explicit_options = NULL;
QDECREF(bs->full_open_options); qobject_unref(bs->full_open_options);
bs->full_open_options = NULL; bs->full_open_options = NULL;
bdrv_release_named_dirty_bitmaps(bs); bdrv_release_named_dirty_bitmaps(bs);
@ -5134,8 +5134,8 @@ static bool append_open_options(QDict *d, BlockDriverState *bs)
continue; continue;
} }
qobject_incref(qdict_entry_value(entry)); qdict_put_obj(d, qdict_entry_key(entry),
qdict_put_obj(d, qdict_entry_key(entry), qdict_entry_value(entry)); qobject_ref(qdict_entry_value(entry)));
found_any = true; found_any = true;
} }
@ -5174,21 +5174,21 @@ void bdrv_refresh_filename(BlockDriverState *bs)
* information before refreshing it */ * information before refreshing it */
bs->exact_filename[0] = '\0'; bs->exact_filename[0] = '\0';
if (bs->full_open_options) { if (bs->full_open_options) {
QDECREF(bs->full_open_options); qobject_unref(bs->full_open_options);
bs->full_open_options = NULL; bs->full_open_options = NULL;
} }
opts = qdict_new(); opts = qdict_new();
append_open_options(opts, bs); append_open_options(opts, bs);
drv->bdrv_refresh_filename(bs, opts); drv->bdrv_refresh_filename(bs, opts);
QDECREF(opts); qobject_unref(opts);
} else if (bs->file) { } else if (bs->file) {
/* Try to reconstruct valid information from the underlying file */ /* Try to reconstruct valid information from the underlying file */
bool has_open_options; bool has_open_options;
bs->exact_filename[0] = '\0'; bs->exact_filename[0] = '\0';
if (bs->full_open_options) { if (bs->full_open_options) {
QDECREF(bs->full_open_options); qobject_unref(bs->full_open_options);
bs->full_open_options = NULL; bs->full_open_options = NULL;
} }
@ -5207,12 +5207,12 @@ void bdrv_refresh_filename(BlockDriverState *bs)
* suffices without querying the (exact_)filename of this BDS. */ * suffices without querying the (exact_)filename of this BDS. */
if (bs->file->bs->full_open_options) { if (bs->file->bs->full_open_options) {
qdict_put_str(opts, "driver", drv->format_name); qdict_put_str(opts, "driver", drv->format_name);
QINCREF(bs->file->bs->full_open_options); qdict_put(opts, "file",
qdict_put(opts, "file", bs->file->bs->full_open_options); qobject_ref(bs->file->bs->full_open_options));
bs->full_open_options = opts; bs->full_open_options = opts;
} else { } else {
QDECREF(opts); qobject_unref(opts);
} }
} else if (!bs->full_open_options && qdict_size(bs->options)) { } else if (!bs->full_open_options && qdict_size(bs->options)) {
/* There is no underlying file BDS (at least referenced by BDS.file), /* There is no underlying file BDS (at least referenced by BDS.file),
@ -5246,7 +5246,7 @@ void bdrv_refresh_filename(BlockDriverState *bs)
QString *json = qobject_to_json(QOBJECT(bs->full_open_options)); QString *json = qobject_to_json(QOBJECT(bs->full_open_options));
snprintf(bs->filename, sizeof(bs->filename), "json:%s", snprintf(bs->filename, sizeof(bs->filename), "json:%s",
qstring_get_str(json)); qstring_get_str(json));
QDECREF(json); qobject_unref(json);
} }
} }

7
block/blkdebug.c
View File

@ -845,13 +845,12 @@ static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
opts = qdict_new(); opts = qdict_new();
qdict_put_str(opts, "driver", "blkdebug"); qdict_put_str(opts, "driver", "blkdebug");
QINCREF(bs->file->bs->full_open_options); qdict_put(opts, "image", qobject_ref(bs->file->bs->full_open_options));
qdict_put(opts, "image", bs->file->bs->full_open_options);
for (e = qdict_first(options); e; e = qdict_next(options, e)) { for (e = qdict_first(options); e; e = qdict_next(options, e)) {
if (strcmp(qdict_entry_key(e), "x-image")) { if (strcmp(qdict_entry_key(e), "x-image")) {
qobject_incref(qdict_entry_value(e)); qdict_put_obj(opts, qdict_entry_key(e),
qdict_put_obj(opts, qdict_entry_key(e), qdict_entry_value(e)); qobject_ref(qdict_entry_value(e)));
} }
} }

8
block/blkverify.c
View File

@ -291,10 +291,10 @@ static void blkverify_refresh_filename(BlockDriverState *bs, QDict *options)
QDict *opts = qdict_new(); QDict *opts = qdict_new();
qdict_put_str(opts, "driver", "blkverify"); qdict_put_str(opts, "driver", "blkverify");
QINCREF(bs->file->bs->full_open_options); qdict_put(opts, "raw",
qdict_put(opts, "raw", bs->file->bs->full_open_options); qobject_ref(bs->file->bs->full_open_options));
QINCREF(s->test_file->bs->full_open_options); qdict_put(opts, "test",
qdict_put(opts, "test", s->test_file->bs->full_open_options); qobject_ref(s->test_file->bs->full_open_options));
bs->full_open_options = opts; bs->full_open_options = opts;
} }

4
block/crypto.c
View File

@ -305,7 +305,7 @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
ret = 0; ret = 0;
cleanup: cleanup:
QDECREF(cryptoopts); qobject_unref(cryptoopts);
qapi_free_QCryptoBlockOpenOptions(open_opts); qapi_free_QCryptoBlockOpenOptions(open_opts);
return ret; return ret;
} }
@ -635,7 +635,7 @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
fail: fail:
bdrv_unref(bs); bdrv_unref(bs);
qapi_free_QCryptoBlockCreateOptions(create_opts); qapi_free_QCryptoBlockCreateOptions(create_opts);
QDECREF(cryptoopts); qobject_unref(cryptoopts);
return ret; return ret;
} }

4
block/gluster.c
View File

@ -650,7 +650,7 @@ static int qemu_gluster_parse_json(BlockdevOptionsGluster *gconf,
} }
gsconf = NULL; gsconf = NULL;
QDECREF(backing_options); qobject_unref(backing_options);
backing_options = NULL; backing_options = NULL;
g_free(str); g_free(str);
str = NULL; str = NULL;
@ -663,7 +663,7 @@ out:
qapi_free_SocketAddress(gsconf); qapi_free_SocketAddress(gsconf);
qemu_opts_del(opts); qemu_opts_del(opts);
g_free(str); g_free(str);
QDECREF(backing_options); qobject_unref(backing_options);
errno = EINVAL; errno = EINVAL;
return -errno; return -errno;
} }

2
block/iscsi.c
View File

@ -2143,7 +2143,7 @@ static int coroutine_fn iscsi_co_create_opts(const char *filename, QemuOpts *opt
} else { } else {
ret = iscsi_open(bs, bs_options, 0, NULL); ret = iscsi_open(bs, bs_options, 0, NULL);
} }
QDECREF(bs_options); qobject_unref(bs_options);
if (ret != 0) { if (ret != 0) {
goto out; goto out;

4
block/nbd.c
View File

@ -293,8 +293,8 @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
} }
done: done:
QDECREF(addr); qobject_unref(addr);
qobject_decref(crumpled_addr); qobject_unref(crumpled_addr);
visit_free(iv); visit_free(iv);
return saddr; return saddr;
} }

4
block/nfs.c
View File

@ -567,7 +567,7 @@ static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
v = qobject_input_visitor_new_keyval(crumpled); v = qobject_input_visitor_new_keyval(crumpled);
visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err); visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err);
visit_free(v); visit_free(v);
qobject_decref(crumpled); qobject_unref(crumpled);
if (local_err) { if (local_err) {
return NULL; return NULL;
@ -683,7 +683,7 @@ static int coroutine_fn nfs_file_co_create_opts(const char *url, QemuOpts *opts,
ret = 0; ret = 0;
out: out:
QDECREF(options); qobject_unref(options);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;
} }

3
block/null.c
View File

@ -244,7 +244,6 @@ static int coroutine_fn null_co_block_status(BlockDriverState *bs,
static void null_refresh_filename(BlockDriverState *bs, QDict *opts) static void null_refresh_filename(BlockDriverState *bs, QDict *opts)
{ {
QINCREF(opts);
qdict_del(opts, "filename"); qdict_del(opts, "filename");
if (!qdict_size(opts)) { if (!qdict_size(opts)) {
@ -253,7 +252,7 @@ static void null_refresh_filename(BlockDriverState *bs, QDict *opts)
} }
qdict_put_str(opts, "driver", bs->drv->format_name); qdict_put_str(opts, "driver", bs->drv->format_name);
bs->full_open_options = opts; bs->full_open_options = qobject_ref(opts);
} }
static BlockDriver bdrv_null_co = { static BlockDriver bdrv_null_co = {

3
block/nvme.c
View File

@ -1073,7 +1073,6 @@ static int nvme_reopen_prepare(BDRVReopenState *reopen_state,
static void nvme_refresh_filename(BlockDriverState *bs, QDict *opts) static void nvme_refresh_filename(BlockDriverState *bs, QDict *opts)
{ {
QINCREF(opts);
qdict_del(opts, "filename"); qdict_del(opts, "filename");
if (!qdict_size(opts)) { if (!qdict_size(opts)) {
@ -1082,7 +1081,7 @@ static void nvme_refresh_filename(BlockDriverState *bs, QDict *opts)
} }
qdict_put_str(opts, "driver", bs->drv->format_name); qdict_put_str(opts, "driver", bs->drv->format_name);
bs->full_open_options = opts; bs->full_open_options = qobject_ref(opts);
} }
static void nvme_refresh_limits(BlockDriverState *bs, Error **errp) static void nvme_refresh_limits(BlockDriverState *bs, Error **errp)

4
block/parallels.c
View File

@ -651,7 +651,7 @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
qdict_put_str(qdict, "file", bs->node_name); qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp); qobj = qdict_crumple(qdict, errp);
QDECREF(qdict); qobject_unref(qdict);
qdict = qobject_to(QDict, qobj); qdict = qobject_to(QDict, qobj);
if (qdict == NULL) { if (qdict == NULL) {
ret = -EINVAL; ret = -EINVAL;
@ -682,7 +682,7 @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
ret = 0; ret = 0;
done: done:
QDECREF(qdict); qobject_unref(qdict);
bdrv_unref(bs); bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;

2
block/qapi.c
View File

@ -773,7 +773,7 @@ void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f,
visit_complete(v, &obj); visit_complete(v, &obj);
data = qdict_get(qobject_to(QDict, obj), "data"); data = qdict_get(qobject_to(QDict, obj), "data");
dump_qobject(func_fprintf, f, 1, data); dump_qobject(func_fprintf, f, 1, data);
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
} }

8
block/qcow.c
View File

@ -315,7 +315,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
goto fail; goto fail;
} }
QDECREF(encryptopts); qobject_unref(encryptopts);
qapi_free_QCryptoBlockOpenOptions(crypto_opts); qapi_free_QCryptoBlockOpenOptions(crypto_opts);
qemu_co_mutex_init(&s->lock); qemu_co_mutex_init(&s->lock);
return 0; return 0;
@ -326,7 +326,7 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
g_free(s->cluster_cache); g_free(s->cluster_cache);
g_free(s->cluster_data); g_free(s->cluster_data);
qcrypto_block_free(s->crypto); qcrypto_block_free(s->crypto);
QDECREF(encryptopts); qobject_unref(encryptopts);
qapi_free_QCryptoBlockOpenOptions(crypto_opts); qapi_free_QCryptoBlockOpenOptions(crypto_opts);
return ret; return ret;
} }
@ -995,7 +995,7 @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
qdict_put_str(qdict, "file", bs->node_name); qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp); qobj = qdict_crumple(qdict, errp);
QDECREF(qdict); qobject_unref(qdict);
qdict = qobject_to(QDict, qobj); qdict = qobject_to(QDict, qobj);
if (qdict == NULL) { if (qdict == NULL) {
ret = -EINVAL; ret = -EINVAL;
@ -1025,7 +1025,7 @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
ret = 0; ret = 0;
fail: fail:
QDECREF(qdict); qobject_unref(qdict);
bdrv_unref(bs); bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;

8
block/qcow2.c
View File

@ -1063,7 +1063,7 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,
ret = 0; ret = 0;
fail: fail:
QDECREF(encryptopts); qobject_unref(encryptopts);
qemu_opts_del(opts); qemu_opts_del(opts);
opts = NULL; opts = NULL;
return ret; return ret;
@ -2183,7 +2183,7 @@ static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
qemu_co_mutex_lock(&s->lock); qemu_co_mutex_lock(&s->lock);
ret = qcow2_do_open(bs, options, flags, &local_err); ret = qcow2_do_open(bs, options, flags, &local_err);
qemu_co_mutex_unlock(&s->lock); qemu_co_mutex_unlock(&s->lock);
QDECREF(options); qobject_unref(options);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
error_prepend(errp, "Could not reopen qcow2 layer: "); error_prepend(errp, "Could not reopen qcow2 layer: ");
@ -3139,7 +3139,7 @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
/* Now get the QAPI type BlockdevCreateOptions */ /* Now get the QAPI type BlockdevCreateOptions */
qobj = qdict_crumple(qdict, errp); qobj = qdict_crumple(qdict, errp);
QDECREF(qdict); qobject_unref(qdict);
qdict = qobject_to(QDict, qobj); qdict = qobject_to(QDict, qobj);
if (qdict == NULL) { if (qdict == NULL) {
ret = -EINVAL; ret = -EINVAL;
@ -3168,7 +3168,7 @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
ret = 0; ret = 0;
finish: finish:
QDECREF(qdict); qobject_unref(qdict);
bdrv_unref(bs); bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;

4
block/qed.c
View File

@ -763,7 +763,7 @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
qdict_put_str(qdict, "file", bs->node_name); qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp); qobj = qdict_crumple(qdict, errp);
QDECREF(qdict); qobject_unref(qdict);
qdict = qobject_to(QDict, qobj); qdict = qobject_to(QDict, qobj);
if (qdict == NULL) { if (qdict == NULL) {
ret = -EINVAL; ret = -EINVAL;
@ -789,7 +789,7 @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
ret = bdrv_qed_co_create(create_options, errp); ret = bdrv_qed_co_create(create_options, errp);
fail: fail:
QDECREF(qdict); qobject_unref(qdict);
bdrv_unref(bs); bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;

4
block/quorum.c
View File

@ -1082,8 +1082,8 @@ static void quorum_refresh_filename(BlockDriverState *bs, QDict *options)
children = qlist_new(); children = qlist_new();
for (i = 0; i < s->num_children; i++) { for (i = 0; i < s->num_children; i++) {
QINCREF(s->children[i]->bs->full_open_options); qlist_append(children,
qlist_append(children, s->children[i]->bs->full_open_options); qobject_ref(s->children[i]->bs->full_open_options));
} }
opts = qdict_new(); opts = qdict_new();

14
block/rbd.c
View File

@ -226,7 +226,7 @@ static void qemu_rbd_parse_filename(const char *filename, QDict *options,
done: done:
g_free(buf); g_free(buf);
QDECREF(keypairs); qobject_unref(keypairs);
return; return;
} }
@ -275,17 +275,17 @@ static int qemu_rbd_set_keypairs(rados_t cluster, const char *keypairs_json,
key = qstring_get_str(name); key = qstring_get_str(name);
ret = rados_conf_set(cluster, key, qstring_get_str(value)); ret = rados_conf_set(cluster, key, qstring_get_str(value));
QDECREF(value); qobject_unref(value);
if (ret < 0) { if (ret < 0) {
error_setg_errno(errp, -ret, "invalid conf option %s", key); error_setg_errno(errp, -ret, "invalid conf option %s", key);
QDECREF(name); qobject_unref(name);
ret = -EINVAL; ret = -EINVAL;
break; break;
} }
QDECREF(name); qobject_unref(name);
} }
QDECREF(keypairs); qobject_unref(keypairs);
return ret; return ret;
} }
@ -449,7 +449,7 @@ static int coroutine_fn qemu_rbd_co_create_opts(const char *filename,
} }
exit: exit:
QDECREF(options); qobject_unref(options);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;
} }
@ -664,7 +664,7 @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
v = qobject_input_visitor_new_keyval(crumpled); v = qobject_input_visitor_new_keyval(crumpled);
visit_type_BlockdevOptionsRbd(v, NULL, &opts, &local_err); visit_type_BlockdevOptionsRbd(v, NULL, &opts, &local_err);
visit_free(v); visit_free(v);
qobject_decref(crumpled); qobject_unref(crumpled);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);

12
block/sheepdog.c
View File

@ -567,8 +567,8 @@ static SocketAddress *sd_server_config(QDict *options, Error **errp)
done: done:
visit_free(iv); visit_free(iv);
qobject_decref(crumpled_server); qobject_unref(crumpled_server);
QDECREF(server); qobject_unref(server);
return saddr; return saddr;
} }
@ -1883,7 +1883,7 @@ static int sd_create_prealloc(BlockdevOptionsSheepdog *location, int64_t size,
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
qobject_decref(obj); qobject_unref(obj);
return -EINVAL; return -EINVAL;
} }
@ -1901,7 +1901,7 @@ static int sd_create_prealloc(BlockdevOptionsSheepdog *location, int64_t size,
ret = sd_prealloc(bs, 0, size, errp); ret = sd_prealloc(bs, 0, size, errp);
fail: fail:
bdrv_unref(bs); bdrv_unref(bs);
QDECREF(qdict); qobject_unref(qdict);
return ret; return ret;
} }
@ -2226,7 +2226,7 @@ static int coroutine_fn sd_co_create_opts(const char *filename, QemuOpts *opts,
v = qobject_input_visitor_new_keyval(crumpled); v = qobject_input_visitor_new_keyval(crumpled);
visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err); visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
visit_free(v); visit_free(v);
qobject_decref(crumpled); qobject_unref(crumpled);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
@ -2252,7 +2252,7 @@ static int coroutine_fn sd_co_create_opts(const char *filename, QemuOpts *opts,
ret = sd_co_create(create_options, errp); ret = sd_co_create(create_options, errp);
fail: fail:
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
QDECREF(qdict); qobject_unref(qdict);
return ret; return ret;
} }

4
block/snapshot.c
View File

@ -214,7 +214,7 @@ int bdrv_snapshot_goto(BlockDriverState *bs,
bdrv_ref(file); bdrv_ref(file);
qdict_extract_subqdict(options, &file_options, "file."); qdict_extract_subqdict(options, &file_options, "file.");
QDECREF(file_options); qobject_unref(file_options);
qdict_put_str(options, "file", bdrv_get_node_name(file)); qdict_put_str(options, "file", bdrv_get_node_name(file));
drv->bdrv_close(bs); drv->bdrv_close(bs);
@ -223,7 +223,7 @@ int bdrv_snapshot_goto(BlockDriverState *bs,
ret = bdrv_snapshot_goto(file, snapshot_id, errp); ret = bdrv_snapshot_goto(file, snapshot_id, errp);
open_ret = drv->bdrv_open(bs, options, bs->open_flags, &local_err); open_ret = drv->bdrv_open(bs, options, bs->open_flags, &local_err);
QDECREF(options); qobject_unref(options);
if (open_ret < 0) { if (open_ret < 0) {
bdrv_unref(file); bdrv_unref(file);
bs->drv = NULL; bs->drv = NULL;

4
block/ssh.c
View File

@ -638,7 +638,7 @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
v = qobject_input_visitor_new(crumpled); v = qobject_input_visitor_new(crumpled);
visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err); visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
visit_free(v); visit_free(v);
qobject_decref(crumpled); qobject_unref(crumpled);
if (local_err) { if (local_err) {
error_propagate(errp, local_err); error_propagate(errp, local_err);
@ -917,7 +917,7 @@ static int coroutine_fn ssh_co_create_opts(const char *filename, QemuOpts *opts,
ret = ssh_co_create(create_options, errp); ret = ssh_co_create(create_options, errp);
out: out:
QDECREF(uri_options); qobject_unref(uri_options);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;
} }

2
block/vdi.c
View File

@ -951,7 +951,7 @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
/* Create the vdi image (format layer) */ /* Create the vdi image (format layer) */
ret = vdi_co_do_create(create_options, block_size, errp); ret = vdi_co_do_create(create_options, block_size, errp);
done: done:
QDECREF(qdict); qobject_unref(qdict);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
bdrv_unref(bs_file); bdrv_unref(bs_file);
return ret; return ret;

4
block/vhdx.c
View File

@ -2003,7 +2003,7 @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
qdict_put_str(qdict, "file", bs->node_name); qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp); qobj = qdict_crumple(qdict, errp);
QDECREF(qdict); qobject_unref(qdict);
qdict = qobject_to(QDict, qobj); qdict = qobject_to(QDict, qobj);
if (qdict == NULL) { if (qdict == NULL) {
ret = -EINVAL; ret = -EINVAL;
@ -2049,7 +2049,7 @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
ret = vhdx_co_create(create_options, errp); ret = vhdx_co_create(create_options, errp);
fail: fail:
QDECREF(qdict); qobject_unref(qdict);
bdrv_unref(bs); bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;

4
block/vpc.c
View File

@ -1119,7 +1119,7 @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
qdict_put_str(qdict, "file", bs->node_name); qdict_put_str(qdict, "file", bs->node_name);
qobj = qdict_crumple(qdict, errp); qobj = qdict_crumple(qdict, errp);
QDECREF(qdict); qobject_unref(qdict);
qdict = qobject_to(QDict, qobj); qdict = qobject_to(QDict, qobj);
if (qdict == NULL) { if (qdict == NULL) {
ret = -EINVAL; ret = -EINVAL;
@ -1157,7 +1157,7 @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
ret = vpc_co_create(create_options, errp); ret = vpc_co_create(create_options, errp);
fail: fail:
QDECREF(qdict); qobject_unref(qdict);
bdrv_unref(bs); bdrv_unref(bs);
qapi_free_BlockdevCreateOptions(create_options); qapi_free_BlockdevCreateOptions(create_options);
return ret; return ret;

2
block/vvfat.c
View File

@ -3179,7 +3179,7 @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
qdict_put_str(options, "write-target.driver", "qcow"); qdict_put_str(options, "write-target.driver", "qcow");
s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs, s->qcow = bdrv_open_child(s->qcow_filename, options, "write-target", bs,
&child_vvfat_qcow, false, errp); &child_vvfat_qcow, false, errp);
QDECREF(options); qobject_unref(options);
if (!s->qcow) { if (!s->qcow) {
ret = -EINVAL; ret = -EINVAL;
goto err; goto err;

2
block/vxhs.c
View File

@ -396,7 +396,7 @@ static int vxhs_open(BlockDriverState *bs, QDict *options,
out: out:
g_free(of_vsa_addr); g_free(of_vsa_addr);
QDECREF(backing_options); qobject_unref(backing_options);
qemu_opts_del(tcp_opts); qemu_opts_del(tcp_opts);
qemu_opts_del(opts); qemu_opts_del(opts);
g_free(cacert); g_free(cacert);

16
blockdev.c
View File

@ -576,7 +576,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
blk_rs->read_only = read_only; blk_rs->read_only = read_only;
blk_rs->detect_zeroes = detect_zeroes; blk_rs->detect_zeroes = detect_zeroes;
QDECREF(bs_opts); qobject_unref(bs_opts);
} else { } else {
if (file && !*file) { if (file && !*file) {
file = NULL; file = NULL;
@ -632,16 +632,16 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,
err_no_bs_opts: err_no_bs_opts:
qemu_opts_del(opts); qemu_opts_del(opts);
QDECREF(interval_dict); qobject_unref(interval_dict);
QDECREF(interval_list); qobject_unref(interval_list);
return blk; return blk;
early_err: early_err:
qemu_opts_del(opts); qemu_opts_del(opts);
QDECREF(interval_dict); qobject_unref(interval_dict);
QDECREF(interval_list); qobject_unref(interval_list);
err_no_opts: err_no_opts:
QDECREF(bs_opts); qobject_unref(bs_opts);
return NULL; return NULL;
} }
@ -1130,7 +1130,7 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
fail: fail:
qemu_opts_del(legacy_opts); qemu_opts_del(legacy_opts);
QDECREF(bs_opts); qobject_unref(bs_opts);
return dinfo; return dinfo;
} }
@ -4022,7 +4022,7 @@ void hmp_drive_add_node(Monitor *mon, const char *optstr)
qdict = qemu_opts_to_qdict(opts, NULL); qdict = qemu_opts_to_qdict(opts, NULL);
if (!qdict_get_try_str(qdict, "node-name")) { if (!qdict_get_try_str(qdict, "node-name")) {
QDECREF(qdict); qobject_unref(qdict);
error_report("'node-name' needs to be specified"); error_report("'node-name' needs to be specified");
goto out; goto out;
} }

73
cpus.c
View File

@ -2187,6 +2187,59 @@ CpuInfoList *qmp_query_cpus(Error **errp)
return head; return head;
} }
static CpuInfoArch sysemu_target_to_cpuinfo_arch(SysEmuTarget target)
{
/*
* The @SysEmuTarget -> @CpuInfoArch mapping below is based on the
* TARGET_ARCH -> TARGET_BASE_ARCH mapping in the "configure" script.
*/
switch (target) {
case SYS_EMU_TARGET_I386:
case SYS_EMU_TARGET_X86_64:
return CPU_INFO_ARCH_X86;
case SYS_EMU_TARGET_PPC:
case SYS_EMU_TARGET_PPCEMB:
case SYS_EMU_TARGET_PPC64:
return CPU_INFO_ARCH_PPC;
case SYS_EMU_TARGET_SPARC:
case SYS_EMU_TARGET_SPARC64:
return CPU_INFO_ARCH_SPARC;
case SYS_EMU_TARGET_MIPS:
case SYS_EMU_TARGET_MIPSEL:
case SYS_EMU_TARGET_MIPS64:
case SYS_EMU_TARGET_MIPS64EL:
return CPU_INFO_ARCH_MIPS;
case SYS_EMU_TARGET_TRICORE:
return CPU_INFO_ARCH_TRICORE;
case SYS_EMU_TARGET_S390X:
return CPU_INFO_ARCH_S390;
case SYS_EMU_TARGET_RISCV32:
case SYS_EMU_TARGET_RISCV64:
return CPU_INFO_ARCH_RISCV;
default:
return CPU_INFO_ARCH_OTHER;
}
}
static void cpustate_to_cpuinfo_s390(CpuInfoS390 *info, const CPUState *cpu)
{
#ifdef TARGET_S390X
S390CPU *s390_cpu = S390_CPU(cpu);
CPUS390XState *env = &s390_cpu->env;
info->cpu_state = env->cpu_state;
#else
abort();
#endif
}
/* /*
* fast means: we NEVER interrupt vCPU threads to retrieve * fast means: we NEVER interrupt vCPU threads to retrieve
* information from KVM. * information from KVM.
@ -2196,11 +2249,9 @@ CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
MachineState *ms = MACHINE(qdev_get_machine()); MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms); MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoFastList *head = NULL, *cur_item = NULL; CpuInfoFastList *head = NULL, *cur_item = NULL;
SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME,
-1, &error_abort);
CPUState *cpu; CPUState *cpu;
#if defined(TARGET_S390X)
S390CPU *s390_cpu;
CPUS390XState *env;
#endif
CPU_FOREACH(cpu) { CPU_FOREACH(cpu) {
CpuInfoFastList *info = g_malloc0(sizeof(*info)); CpuInfoFastList *info = g_malloc0(sizeof(*info));
@ -2218,12 +2269,14 @@ CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
info->value->props = props; info->value->props = props;
} }
#if defined(TARGET_S390X) info->value->arch = sysemu_target_to_cpuinfo_arch(target);
s390_cpu = S390_CPU(cpu); info->value->target = target;
env = &s390_cpu->env; if (target == SYS_EMU_TARGET_S390X) {
info->value->arch = CPU_INFO_ARCH_S390; cpustate_to_cpuinfo_s390(&info->value->u.s390x, cpu);
info->value->u.s390.cpu_state = env->cpu_state; } else {
#endif /* do nothing for @CpuInfoOther */
}
if (!cur_item) { if (!cur_item) {
head = cur_item = info; head = cur_item = info;
} else { } else {

2
docs/devel/qapi-code-gen.txt
View File

@ -1340,7 +1340,7 @@ Example:
emit(EXAMPLE_QAPI_EVENT_MY_EVENT, qmp, &err); emit(EXAMPLE_QAPI_EVENT_MY_EVENT, qmp, &err);
error_propagate(errp, err); error_propagate(errp, err);
QDECREF(qmp); qobject_unref(qmp);
} }
const QEnumLookup example_QAPIEvent_lookup = { const QEnumLookup example_QAPIEvent_lookup = {

12
hw/i386/acpi-build.c
View File

@ -198,21 +198,21 @@ static void acpi_get_pm_info(AcpiPmInfo *pm)
} else { } else {
pm->s3_disabled = false; pm->s3_disabled = false;
} }
qobject_decref(o); qobject_unref(o);
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_DISABLED, NULL); o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_DISABLED, NULL);
if (o) { if (o) {
pm->s4_disabled = qnum_get_uint(qobject_to(QNum, o)); pm->s4_disabled = qnum_get_uint(qobject_to(QNum, o));
} else { } else {
pm->s4_disabled = false; pm->s4_disabled = false;
} }
qobject_decref(o); qobject_unref(o);
o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_VAL, NULL); o = object_property_get_qobject(obj, ACPI_PM_PROP_S4_VAL, NULL);
if (o) { if (o) {
pm->s4_val = qnum_get_uint(qobject_to(QNum, o)); pm->s4_val = qnum_get_uint(qobject_to(QNum, o));
} else { } else {
pm->s4_val = false; pm->s4_val = false;
} }
qobject_decref(o); qobject_unref(o);
pm->pcihp_bridge_en = pm->pcihp_bridge_en =
object_property_get_bool(obj, "acpi-pci-hotplug-with-bridge-support", object_property_get_bool(obj, "acpi-pci-hotplug-with-bridge-support",
@ -570,7 +570,7 @@ static void build_append_pci_bus_devices(Aml *parent_scope, PCIBus *bus,
} }
} }
aml_append(parent_scope, method); aml_append(parent_scope, method);
qobject_decref(bsel); qobject_unref(bsel);
} }
/** /**
@ -2614,12 +2614,12 @@ static bool acpi_get_mcfg(AcpiMcfgInfo *mcfg)
return false; return false;
} }
mcfg->mcfg_base = qnum_get_uint(qobject_to(QNum, o)); mcfg->mcfg_base = qnum_get_uint(qobject_to(QNum, o));
qobject_decref(o); qobject_unref(o);
o = object_property_get_qobject(pci_host, PCIE_HOST_MCFG_SIZE, NULL); o = object_property_get_qobject(pci_host, PCIE_HOST_MCFG_SIZE, NULL);
assert(o); assert(o);
mcfg->mcfg_size = qnum_get_uint(qobject_to(QNum, o)); mcfg->mcfg_size = qnum_get_uint(qobject_to(QNum, o));
qobject_decref(o); qobject_unref(o);
return true; return true;
} }

2
hw/ppc/spapr_drc.c
View File

@ -305,7 +305,7 @@ static void prop_get_fdt(Object *obj, Visitor *v, const char *name,
if (!drc->fdt) { if (!drc->fdt) {
visit_type_null(v, NULL, &null, errp); visit_type_null(v, NULL, &null, errp);
QDECREF(null); qobject_unref(null);
return; return;
} }

4
hw/usb/xen-usb.c
View File

@ -763,7 +763,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
if (!usbif->ports[port - 1].dev) { if (!usbif->ports[port - 1].dev) {
goto err; goto err;
} }
QDECREF(qdict); qobject_unref(qdict);
speed = usbif->ports[port - 1].dev->speed; speed = usbif->ports[port - 1].dev->speed;
switch (speed) { switch (speed) {
case USB_SPEED_LOW: case USB_SPEED_LOW:
@ -796,7 +796,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port,
return; return;
err: err:
QDECREF(qdict); qobject_unref(qdict);
xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid);
} }

2
include/qapi/qmp/qbool.h
View File

@ -17,7 +17,7 @@
#include "qapi/qmp/qobject.h" #include "qapi/qmp/qobject.h"
struct QBool { struct QBool {
QObject base; struct QObjectBase_ base;
bool value; bool value;
}; };

2
include/qapi/qmp/qdict.h
View File

@ -25,7 +25,7 @@ typedef struct QDictEntry {
} QDictEntry; } QDictEntry;
struct QDict { struct QDict {
QObject base; struct QObjectBase_ base;
size_t size; size_t size;
QLIST_HEAD(,QDictEntry) table[QDICT_BUCKET_MAX]; QLIST_HEAD(,QDictEntry) table[QDICT_BUCKET_MAX];
}; };

2
include/qapi/qmp/qlist.h
View File

@ -22,7 +22,7 @@ typedef struct QListEntry {
} QListEntry; } QListEntry;
struct QList { struct QList {
QObject base; struct QObjectBase_ base;
QTAILQ_HEAD(,QListEntry) head; QTAILQ_HEAD(,QListEntry) head;
}; };

5
include/qapi/qmp/qnull.h
View File

@ -16,15 +16,14 @@
#include "qapi/qmp/qobject.h" #include "qapi/qmp/qobject.h"
struct QNull { struct QNull {
QObject base; struct QObjectBase_ base;
}; };
extern QNull qnull_; extern QNull qnull_;
static inline QNull *qnull(void) static inline QNull *qnull(void)
{ {
QINCREF(&qnull_); return qobject_ref(&qnull_);
return &qnull_;
} }
bool qnull_is_equal(const QObject *x, const QObject *y); bool qnull_is_equal(const QObject *x, const QObject *y);

2
include/qapi/qmp/qnum.h
View File

@ -45,7 +45,7 @@ typedef enum {
* convert under the hood. * convert under the hood.
*/ */
struct QNum { struct QNum {
QObject base; struct QObjectBase_ base;
QNumKind kind; QNumKind kind;
union { union {
int64_t i64; int64_t i64;

81
include/qapi/qmp/qobject.h
View File

@ -15,17 +15,17 @@
* ------------------------------------ * ------------------------------------
* *
* - Returning references: A function that returns an object may * - Returning references: A function that returns an object may
* return it as either a weak or a strong reference. If the reference * return it as either a weak or a strong reference. If the
* is strong, you are responsible for calling QDECREF() on the reference * reference is strong, you are responsible for calling
* when you are done. * qobject_unref() on the reference when you are done.
* *
* If the reference is weak, the owner of the reference may free it at * If the reference is weak, the owner of the reference may free it at
* any time in the future. Before storing the reference anywhere, you * any time in the future. Before storing the reference anywhere, you
* should call QINCREF() to make the reference strong. * should call qobject_ref() to make the reference strong.
* *
* - Transferring ownership: when you transfer ownership of a reference * - Transferring ownership: when you transfer ownership of a reference
* by calling a function, you are no longer responsible for calling * by calling a function, you are no longer responsible for calling
* QDECREF() when the reference is no longer needed. In other words, * qobject_unref() when the reference is no longer needed. In other words,
* when the function returns you must behave as if the reference to the * when the function returns you must behave as if the reference to the
* passed object was weak. * passed object was weak.
*/ */
@ -34,21 +34,21 @@
#include "qapi/qapi-builtin-types.h" #include "qapi/qapi-builtin-types.h"
struct QObject { /* Not for use outside include/qapi/qmp/ */
struct QObjectBase_ {
QType type; QType type;
size_t refcnt; size_t refcnt;
}; };
/* Get the 'base' part of an object */ /* this struct must have no other members than base */
#define QOBJECT(obj) (&(obj)->base) struct QObject {
struct QObjectBase_ base;
};
/* High-level interface for qobject_incref() */ #define QOBJECT(obj) ({ \
#define QINCREF(obj) \ typeof(obj) _obj = (obj); \
qobject_incref(QOBJECT(obj)) _obj ? container_of(&(_obj)->base, QObject, base) : NULL; \
})
/* High-level interface for qobject_decref() */
#define QDECREF(obj) \
qobject_decref(obj ? QOBJECT(obj) : NULL)
/* Required for qobject_to() */ /* Required for qobject_to() */
#define QTYPE_CAST_TO_QNull QTYPE_QNULL #define QTYPE_CAST_TO_QNull QTYPE_QNULL
@ -61,25 +61,22 @@ struct QObject {
QEMU_BUILD_BUG_MSG(QTYPE__MAX != 7, QEMU_BUILD_BUG_MSG(QTYPE__MAX != 7,
"The QTYPE_CAST_TO_* list needs to be extended"); "The QTYPE_CAST_TO_* list needs to be extended");
#define qobject_to(type, obj) ({ \ #define qobject_to(type, obj) \
QObject *_tmp = qobject_check_type(obj, glue(QTYPE_CAST_TO_, type)); \ ((type *)qobject_check_type(obj, glue(QTYPE_CAST_TO_, type)))
_tmp ? container_of(_tmp, type, base) : (type *)NULL; })
/* Initialize an object to default values */ /* Initialize an object to default values */
static inline void qobject_init(QObject *obj, QType type) static inline void qobject_init(QObject *obj, QType type)
{ {
assert(QTYPE_NONE < type && type < QTYPE__MAX); assert(QTYPE_NONE < type && type < QTYPE__MAX);
obj->refcnt = 1; obj->base.refcnt = 1;
obj->type = type; obj->base.type = type;
} }
/** static inline void qobject_ref_impl(QObject *obj)
* qobject_incref(): Increment QObject's reference count
*/
static inline void qobject_incref(QObject *obj)
{ {
if (obj) if (obj) {
obj->refcnt++; obj->base.refcnt++;
}
} }
/** /**
@ -96,25 +93,39 @@ bool qobject_is_equal(const QObject *x, const QObject *y);
*/ */
void qobject_destroy(QObject *obj); void qobject_destroy(QObject *obj);
/** static inline void qobject_unref_impl(QObject *obj)
* qobject_decref(): Decrement QObject's reference count, deallocate
* when it reaches zero
*/
static inline void qobject_decref(QObject *obj)
{ {
assert(!obj || obj->refcnt); assert(!obj || obj->base.refcnt);
if (obj && --obj->refcnt == 0) { if (obj && --obj->base.refcnt == 0) {
qobject_destroy(obj); qobject_destroy(obj);
} }
} }
/**
* qobject_ref(): Increment QObject's reference count
*
* Returns: the same @obj. The type of @obj will be propagated to the
* return type.
*/
#define qobject_ref(obj) ({ \
typeof(obj) _o = (obj); \
qobject_ref_impl(QOBJECT(_o)); \
_o; \
})
/**
* qobject_unref(): Decrement QObject's reference count, deallocate
* when it reaches zero
*/
#define qobject_unref(obj) qobject_unref_impl(QOBJECT(obj))
/** /**
* qobject_type(): Return the QObject's type * qobject_type(): Return the QObject's type
*/ */
static inline QType qobject_type(const QObject *obj) static inline QType qobject_type(const QObject *obj)
{ {
assert(QTYPE_NONE < obj->type && obj->type < QTYPE__MAX); assert(QTYPE_NONE < obj->base.type && obj->base.type < QTYPE__MAX);
return obj->type; return obj->base.type;
} }
/** /**

2
include/qapi/qmp/qstring.h
View File

@ -16,7 +16,7 @@
#include "qapi/qmp/qobject.h" #include "qapi/qmp/qobject.h"
struct QString { struct QString {
QObject base; struct QObjectBase_ base;
char *string; char *string;
size_t length; size_t length;
size_t capacity; size_t capacity;

4
migration/migration.c
View File

@ -1040,14 +1040,14 @@ void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp)
/* TODO Rewrite "" to null instead */ /* TODO Rewrite "" to null instead */
if (params->has_tls_creds if (params->has_tls_creds
&& params->tls_creds->type == QTYPE_QNULL) { && params->tls_creds->type == QTYPE_QNULL) {
QDECREF(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->has_tls_hostname
&& params->tls_hostname->type == QTYPE_QNULL) { && params->tls_hostname->type == QTYPE_QNULL) {
QDECREF(params->tls_hostname->u.n); qobject_unref(params->tls_hostname->u.n);
params->tls_hostname->type = QTYPE_QSTRING; params->tls_hostname->type = QTYPE_QSTRING;
params->tls_hostname->u.s = strdup(""); params->tls_hostname->u.s = strdup("");
} }

2
migration/qjson.c
View File

@ -109,6 +109,6 @@ void qjson_finish(QJSON *json)
void qjson_destroy(QJSON *json) void qjson_destroy(QJSON *json)
{ {
QDECREF(json->str); qobject_unref(json->str);
g_free(json); g_free(json);
} }

58
monitor.c
View File

@ -329,8 +329,8 @@ int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
static void qmp_request_free(QMPRequest *req) static void qmp_request_free(QMPRequest *req)
{ {
qobject_decref(req->id); qobject_unref(req->id);
qobject_decref(req->req); qobject_unref(req->req);
g_free(req); g_free(req);
} }
@ -346,7 +346,7 @@ static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon) static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
{ {
while (!g_queue_is_empty(mon->qmp.qmp_responses)) { while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
qobject_decref(g_queue_pop_head(mon->qmp.qmp_responses)); qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
} }
} }
@ -391,14 +391,14 @@ static void monitor_flush_locked(Monitor *mon)
rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len); rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
if ((rc < 0 && errno != EAGAIN) || (rc == len)) { if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
/* all flushed or error */ /* all flushed or error */
QDECREF(mon->outbuf); qobject_unref(mon->outbuf);
mon->outbuf = qstring_new(); mon->outbuf = qstring_new();
return; return;
} }
if (rc > 0) { if (rc > 0) {
/* partial write */ /* partial write */
QString *tmp = qstring_from_str(buf + rc); QString *tmp = qstring_from_str(buf + rc);
QDECREF(mon->outbuf); qobject_unref(mon->outbuf);
mon->outbuf = tmp; mon->outbuf = tmp;
} }
if (mon->out_watch == 0) { if (mon->out_watch == 0) {
@ -482,7 +482,7 @@ static void monitor_json_emitter_raw(Monitor *mon,
qstring_append_chr(json, '\n'); qstring_append_chr(json, '\n');
monitor_puts(mon, qstring_get_str(json)); monitor_puts(mon, qstring_get_str(json));
QDECREF(json); qobject_unref(json);
} }
static void monitor_json_emitter(Monitor *mon, QObject *data) static void monitor_json_emitter(Monitor *mon, QObject *data)
@ -494,9 +494,8 @@ static void monitor_json_emitter(Monitor *mon, QObject *data)
* caller won't free the data (which will be finally freed in * caller won't free the data (which will be finally freed in
* responder thread). * responder thread).
*/ */
qobject_incref(data);
qemu_mutex_lock(&mon->qmp.qmp_queue_lock); qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
g_queue_push_tail(mon->qmp.qmp_responses, (void *)data); g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(data));
qemu_mutex_unlock(&mon->qmp.qmp_queue_lock); qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
qemu_bh_schedule(mon_global.qmp_respond_bh); qemu_bh_schedule(mon_global.qmp_respond_bh);
} else { } else {
@ -546,7 +545,7 @@ static void monitor_qmp_bh_responder(void *opaque)
break; break;
} }
monitor_json_emitter_raw(response.mon, response.data); monitor_json_emitter_raw(response.mon, response.data);
qobject_decref(response.data); qobject_unref(response.data);
} }
} }
@ -613,9 +612,8 @@ monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
* last send. Store event for sending when timer fires, * last send. Store event for sending when timer fires,
* replacing a prior stored event if any. * replacing a prior stored event if any.
*/ */
QDECREF(evstate->qdict); qobject_unref(evstate->qdict);
evstate->qdict = qdict; evstate->qdict = qobject_ref(qdict);
QINCREF(evstate->qdict);
} else { } else {
/* /*
* Last send was (at least) evconf->rate ns ago. * Last send was (at least) evconf->rate ns ago.
@ -629,8 +627,7 @@ monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
evstate = g_new(MonitorQAPIEventState, 1); evstate = g_new(MonitorQAPIEventState, 1);
evstate->event = event; evstate->event = event;
evstate->data = data; evstate->data = qobject_ref(data);
QINCREF(evstate->data);
evstate->qdict = NULL; evstate->qdict = NULL;
evstate->timer = timer_new_ns(event_clock_type, evstate->timer = timer_new_ns(event_clock_type,
monitor_qapi_event_handler, monitor_qapi_event_handler,
@ -660,12 +657,12 @@ static void monitor_qapi_event_handler(void *opaque)
int64_t now = qemu_clock_get_ns(event_clock_type); int64_t now = qemu_clock_get_ns(event_clock_type);
monitor_qapi_event_emit(evstate->event, evstate->qdict); monitor_qapi_event_emit(evstate->event, evstate->qdict);
QDECREF(evstate->qdict); qobject_unref(evstate->qdict);
evstate->qdict = NULL; evstate->qdict = NULL;
timer_mod_ns(evstate->timer, now + evconf->rate); timer_mod_ns(evstate->timer, now + evconf->rate);
} else { } else {
g_hash_table_remove(monitor_qapi_event_state, evstate); g_hash_table_remove(monitor_qapi_event_state, evstate);
QDECREF(evstate->data); qobject_unref(evstate->data);
timer_free(evstate->timer); timer_free(evstate->timer);
g_free(evstate); g_free(evstate);
} }
@ -747,7 +744,7 @@ static void monitor_data_destroy(Monitor *mon)
json_message_parser_destroy(&mon->qmp.parser); json_message_parser_destroy(&mon->qmp.parser);
} }
readline_free(mon->rs); readline_free(mon->rs);
QDECREF(mon->outbuf); qobject_unref(mon->outbuf);
qemu_mutex_destroy(&mon->out_lock); qemu_mutex_destroy(&mon->out_lock);
qemu_mutex_destroy(&mon->qmp.qmp_queue_lock); qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
monitor_qmp_cleanup_req_queue_locked(mon); monitor_qmp_cleanup_req_queue_locked(mon);
@ -3362,7 +3359,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
return qdict; return qdict;
fail: fail:
QDECREF(qdict); qobject_unref(qdict);
g_free(key); g_free(key);
return NULL; return NULL;
} }
@ -3387,7 +3384,7 @@ static void handle_hmp_command(Monitor *mon, const char *cmdline)
} }
cmd->cmd(mon, qdict); cmd->cmd(mon, qdict);
QDECREF(qdict); qobject_unref(qdict);
} }
static void cmd_completion(Monitor *mon, const char *name, const char *list) static void cmd_completion(Monitor *mon, const char *name, const char *list)
@ -4048,16 +4045,14 @@ static void monitor_qmp_respond(Monitor *mon, QObject *rsp,
if (rsp) { if (rsp) {
if (id) { if (id) {
/* This is for the qdict below. */ qdict_put_obj(qobject_to(QDict, rsp), "id", qobject_ref(id));
qobject_incref(id);
qdict_put_obj(qobject_to(QDict, rsp), "id", id);
} }
monitor_json_emitter(mon, rsp); monitor_json_emitter(mon, rsp);
} }
qobject_decref(id); qobject_unref(id);
qobject_decref(rsp); qobject_unref(rsp);
} }
/* /*
@ -4080,7 +4075,7 @@ static void monitor_qmp_dispatch_one(QMPRequest *req_obj)
if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) { if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
QString *req_json = qobject_to_json(req); QString *req_json = qobject_to_json(req);
trace_handle_qmp_command(mon, qstring_get_str(req_json)); trace_handle_qmp_command(mon, qstring_get_str(req_json));
QDECREF(req_json); qobject_unref(req_json);
} }
old_mon = cur_mon; old_mon = cur_mon;
@ -4098,7 +4093,7 @@ static void monitor_qmp_dispatch_one(QMPRequest *req_obj)
monitor_resume(mon); monitor_resume(mon);
} }
qobject_decref(req); qobject_unref(req);
} }
/* /*
@ -4190,15 +4185,14 @@ static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
goto err; goto err;
} }
qobject_incref(id);
qdict_del(qdict, "id");
req_obj = g_new0(QMPRequest, 1); req_obj = g_new0(QMPRequest, 1);
req_obj->mon = mon; req_obj->mon = mon;
req_obj->id = id; req_obj->id = qobject_ref(id);
req_obj->req = req; req_obj->req = req;
req_obj->need_resume = false; req_obj->need_resume = false;
qdict_del(qdict, "id");
if (qmp_is_oob(qdict)) { if (qmp_is_oob(qdict)) {
/* Out-Of-Band (OOB) requests are executed directly in parser. */ /* Out-Of-Band (OOB) requests are executed directly in parser. */
trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(req_obj->id) trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(req_obj->id)
@ -4245,7 +4239,7 @@ static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
err: err:
monitor_qmp_respond(mon, NULL, err, NULL); monitor_qmp_respond(mon, NULL, err, NULL);
qobject_decref(req); qobject_unref(req);
} }
static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size) static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
@ -4364,7 +4358,7 @@ static void monitor_qmp_event(void *opaque, int event)
monitor_qmp_caps_reset(mon); monitor_qmp_caps_reset(mon);
data = get_qmp_greeting(mon); data = get_qmp_greeting(mon);
monitor_json_emitter(mon, data); monitor_json_emitter(mon, data);
qobject_decref(data); qobject_unref(data);
mon_refcount++; mon_refcount++;
break; break;
case CHR_EVENT_CLOSED: case CHR_EVENT_CLOSED:

23
qapi/common.json
View File

@ -126,3 +126,26 @@
## ##
{ 'enum': 'OffAutoPCIBAR', { 'enum': 'OffAutoPCIBAR',
'data': [ 'off', 'auto', 'bar0', 'bar1', 'bar2', 'bar3', 'bar4', 'bar5' ] } 'data': [ 'off', 'auto', 'bar0', 'bar1', 'bar2', 'bar3', 'bar4', 'bar5' ] }
##
# @SysEmuTarget:
#
# The comprehensive enumeration of QEMU system emulation ("softmmu")
# targets. Run "./configure --help" in the project root directory, and
# look for the *-softmmu targets near the "--target-list" option. The
# individual target constants are not documented here, for the time
# being.
#
# Notes: The resulting QMP strings can be appended to the "qemu-system-"
# prefix to produce the corresponding QEMU executable name. This
# is true even for "qemu-system-x86_64".
#
# Since: 2.13
##
{ 'enum' : 'SysEmuTarget',
'data' : [ 'aarch64', 'alpha', 'arm', 'cris', 'hppa', 'i386', 'lm32',
'm68k', 'microblaze', 'microblazeel', 'mips', 'mips64',
'mips64el', 'mipsel', 'moxie', 'nios2', 'or1k', 'ppc',
'ppc64', 'ppcemb', 'riscv32', 'riscv64', 's390x', 'sh4',
'sh4eb', 'sparc', 'sparc64', 'tricore', 'unicore32',
'x86_64', 'xtensa', 'xtensaeb' ] }

68
qapi/misc.json
View File

@ -5,6 +5,8 @@
# = Miscellanea # = Miscellanea
## ##
{ 'include': 'common.json' }
## ##
# @qmp_capabilities: # @qmp_capabilities:
# #
@ -556,25 +558,55 @@
# @props: properties describing to which node/socket/core/thread # @props: properties describing to which node/socket/core/thread
# virtual CPU belongs to, provided if supported by board # virtual CPU belongs to, provided if supported by board
# #
# @arch: architecture of the cpu, which determines which additional fields # @arch: base architecture of the cpu; deprecated since 2.13.0 in favor
# will be listed # of @target
#
# @target: the QEMU system emulation target, which determines which
# additional fields will be listed (since 2.13)
# #
# Since: 2.12 # Since: 2.12
# #
## ##
{ 'union': 'CpuInfoFast', { 'union' : 'CpuInfoFast',
'base': {'cpu-index': 'int', 'qom-path': 'str', 'base' : { 'cpu-index' : 'int',
'thread-id': 'int', '*props': 'CpuInstanceProperties', 'qom-path' : 'str',
'arch': 'CpuInfoArch' }, 'thread-id' : 'int',
'discriminator': 'arch', '*props' : 'CpuInstanceProperties',
'data': { 'x86': 'CpuInfoOther', 'arch' : 'CpuInfoArch',
'sparc': 'CpuInfoOther', 'target' : 'SysEmuTarget' },
'ppc': 'CpuInfoOther', 'discriminator' : 'target',
'mips': 'CpuInfoOther', 'data' : { 'aarch64' : 'CpuInfoOther',
'tricore': 'CpuInfoOther', 'alpha' : 'CpuInfoOther',
's390': 'CpuInfoS390', 'arm' : 'CpuInfoOther',
'riscv': 'CpuInfoRISCV', 'cris' : 'CpuInfoOther',
'other': 'CpuInfoOther' } } 'hppa' : 'CpuInfoOther',
'i386' : 'CpuInfoOther',
'lm32' : 'CpuInfoOther',
'm68k' : 'CpuInfoOther',
'microblaze' : 'CpuInfoOther',
'microblazeel' : 'CpuInfoOther',
'mips' : 'CpuInfoOther',
'mips64' : 'CpuInfoOther',
'mips64el' : 'CpuInfoOther',
'mipsel' : 'CpuInfoOther',
'moxie' : 'CpuInfoOther',
'nios2' : 'CpuInfoOther',
'or1k' : 'CpuInfoOther',
'ppc' : 'CpuInfoOther',
'ppc64' : 'CpuInfoOther',
'ppcemb' : 'CpuInfoOther',
'riscv32' : 'CpuInfoOther',
'riscv64' : 'CpuInfoOther',
's390x' : 'CpuInfoS390',
'sh4' : 'CpuInfoOther',
'sh4eb' : 'CpuInfoOther',
'sparc' : 'CpuInfoOther',
'sparc64' : 'CpuInfoOther',
'tricore' : 'CpuInfoOther',
'unicore32' : 'CpuInfoOther',
'x86_64' : 'CpuInfoOther',
'xtensa' : 'CpuInfoOther',
'xtensaeb' : 'CpuInfoOther' } }
## ##
# @query-cpus-fast: # @query-cpus-fast:
@ -600,6 +632,7 @@
# }, # },
# "qom-path": "/machine/unattached/device[0]", # "qom-path": "/machine/unattached/device[0]",
# "arch":"x86", # "arch":"x86",
# "target":"x86_64",
# "cpu-index": 0 # "cpu-index": 0
# }, # },
# { # {
@ -611,6 +644,7 @@
# }, # },
# "qom-path": "/machine/unattached/device[2]", # "qom-path": "/machine/unattached/device[2]",
# "arch":"x86", # "arch":"x86",
# "target":"x86_64",
# "cpu-index": 1 # "cpu-index": 1
# } # }
# ] # ]
@ -2449,12 +2483,12 @@
# #
# Information describing the QEMU target. # Information describing the QEMU target.
# #
# @arch: the target architecture (eg "x86_64", "i386", etc) # @arch: the target architecture
# #
# Since: 1.2.0 # Since: 1.2.0
## ##
{ 'struct': 'TargetInfo', { 'struct': 'TargetInfo',
'data': { 'arch': 'str' } } 'data': { 'arch': 'SysEmuTarget' } }
## ##
# @query-target: # @query-target:

4
qapi/qapi-dealloc-visitor.c
View File

@ -99,7 +99,7 @@ static void qapi_dealloc_type_anything(Visitor *v, const char *name,
QObject **obj, Error **errp) QObject **obj, Error **errp)
{ {
if (obj) { if (obj) {
qobject_decref(*obj); qobject_unref(*obj);
} }
} }
@ -107,7 +107,7 @@ static void qapi_dealloc_type_null(Visitor *v, const char *name,
QNull **obj, Error **errp) QNull **obj, Error **errp)
{ {
if (obj) { if (obj) {
QDECREF(*obj); qobject_unref(*obj);
} }
} }

6
qapi/qmp-dispatch.c
View File

@ -105,7 +105,7 @@ static QObject *do_qmp_dispatch(QmpCommandList *cmds, QObject *request,
args = qdict_new(); args = qdict_new();
} else { } else {
args = qdict_get_qdict(dict, "arguments"); args = qdict_get_qdict(dict, "arguments");
QINCREF(args); qobject_ref(args);
} }
cmd->fn(args, &ret, &local_err); cmd->fn(args, &ret, &local_err);
@ -117,7 +117,7 @@ static QObject *do_qmp_dispatch(QmpCommandList *cmds, QObject *request,
ret = QOBJECT(qdict_new()); ret = QOBJECT(qdict_new());
} }
QDECREF(args); qobject_unref(args);
return ret; return ret;
} }
@ -166,7 +166,7 @@ QObject *qmp_dispatch(QmpCommandList *cmds, QObject *request)
} else if (ret) { } else if (ret) {
qdict_put_obj(rsp, "return", ret); qdict_put_obj(rsp, "return", ret);
} else { } else {
QDECREF(rsp); qobject_unref(rsp);
return NULL; return NULL;
} }

10
qapi/qobject-input-visitor.c
View File

@ -588,8 +588,7 @@ static void qobject_input_type_any(Visitor *v, const char *name, QObject **obj,
return; return;
} }
qobject_incref(qobj); *obj = qobject_ref(qobj);
*obj = qobj;
} }
static void qobject_input_type_null(Visitor *v, const char *name, static void qobject_input_type_null(Visitor *v, const char *name,
@ -652,7 +651,7 @@ static void qobject_input_free(Visitor *v)
qobject_input_stack_object_free(tos); qobject_input_stack_object_free(tos);
} }
qobject_decref(qiv->root); qobject_unref(qiv->root);
if (qiv->errname) { if (qiv->errname) {
g_string_free(qiv->errname, TRUE); g_string_free(qiv->errname, TRUE);
} }
@ -677,8 +676,7 @@ static QObjectInputVisitor *qobject_input_visitor_base_new(QObject *obj)
v->visitor.optional = qobject_input_optional; v->visitor.optional = qobject_input_optional;
v->visitor.free = qobject_input_free; v->visitor.free = qobject_input_free;
v->root = obj; v->root = qobject_ref(obj);
qobject_incref(obj);
return v; return v;
} }
@ -744,7 +742,7 @@ Visitor *qobject_input_visitor_new_str(const char *str,
} }
v = qobject_input_visitor_new_keyval(QOBJECT(args)); v = qobject_input_visitor_new_keyval(QOBJECT(args));
} }
QDECREF(args); qobject_unref(args);
return v; return v;
} }

11
qapi/qobject-output-visitor.c
View File

@ -188,8 +188,8 @@ static void qobject_output_type_any(Visitor *v, const char *name,
QObject **obj, Error **errp) QObject **obj, Error **errp)
{ {
QObjectOutputVisitor *qov = to_qov(v); QObjectOutputVisitor *qov = to_qov(v);
qobject_incref(*obj);
qobject_output_add_obj(qov, name, *obj); qobject_output_add_obj(qov, name, qobject_ref(*obj));
} }
static void qobject_output_type_null(Visitor *v, const char *name, static void qobject_output_type_null(Visitor *v, const char *name,
@ -201,7 +201,7 @@ static void qobject_output_type_null(Visitor *v, const char *name,
/* Finish building, and return the root object. /* Finish building, and return the root object.
* The root object is never null. The caller becomes the object's * The root object is never null. The caller becomes the object's
* owner, and should use qobject_decref() when done with it. */ * owner, and should use qobject_unref() when done with it. */
static void qobject_output_complete(Visitor *v, void *opaque) static void qobject_output_complete(Visitor *v, void *opaque)
{ {
QObjectOutputVisitor *qov = to_qov(v); QObjectOutputVisitor *qov = to_qov(v);
@ -210,8 +210,7 @@ static void qobject_output_complete(Visitor *v, void *opaque)
assert(qov->root && QSLIST_EMPTY(&qov->stack)); assert(qov->root && QSLIST_EMPTY(&qov->stack));
assert(opaque == qov->result); assert(opaque == qov->result);
qobject_incref(qov->root); *qov->result = qobject_ref(qov->root);
*qov->result = qov->root;
qov->result = NULL; qov->result = NULL;
} }
@ -226,7 +225,7 @@ static void qobject_output_free(Visitor *v)
g_free(e); g_free(e);
} }
qobject_decref(qov->root); qobject_unref(qov->root);
g_free(qov); g_free(qov);
} }

5
qemu-doc.texi
View File

@ -2949,6 +2949,11 @@ from qcow2 images.
The ``query-cpus'' command is replaced by the ``query-cpus-fast'' command. The ``query-cpus'' command is replaced by the ``query-cpus-fast'' command.
@subsection query-cpus-fast "arch" output member (since 2.13.0)
The ``arch'' output member of the ``query-cpus-fast'' command is
replaced by the ``target'' output member.
@section System emulator devices @section System emulator devices
@subsection ivshmem (since 2.6.0) @subsection ivshmem (since 2.6.0)

18
qemu-img.c
View File

@ -279,7 +279,7 @@ static BlockBackend *img_open_opts(const char *optstr,
if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE) if (qdict_haskey(options, BDRV_OPT_FORCE_SHARE)
&& !qdict_get_bool(options, BDRV_OPT_FORCE_SHARE)) { && !qdict_get_bool(options, BDRV_OPT_FORCE_SHARE)) {
error_report("--force-share/-U conflicts with image options"); error_report("--force-share/-U conflicts with image options");
QDECREF(options); qobject_unref(options);
return NULL; return NULL;
} }
qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true); qdict_put_bool(options, BDRV_OPT_FORCE_SHARE, true);
@ -561,9 +561,9 @@ static void dump_json_image_check(ImageCheck *check, bool quiet)
str = qobject_to_json_pretty(obj); str = qobject_to_json_pretty(obj);
assert(str != NULL); assert(str != NULL);
qprintf(quiet, "%s\n", qstring_get_str(str)); qprintf(quiet, "%s\n", qstring_get_str(str));
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
QDECREF(str); qobject_unref(str);
} }
static void dump_human_image_check(ImageCheck *check, bool quiet) static void dump_human_image_check(ImageCheck *check, bool quiet)
@ -2384,9 +2384,9 @@ static void dump_json_image_info_list(ImageInfoList *list)
str = qobject_to_json_pretty(obj); str = qobject_to_json_pretty(obj);
assert(str != NULL); assert(str != NULL);
printf("%s\n", qstring_get_str(str)); printf("%s\n", qstring_get_str(str));
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
QDECREF(str); qobject_unref(str);
} }
static void dump_json_image_info(ImageInfo *info) static void dump_json_image_info(ImageInfo *info)
@ -2400,9 +2400,9 @@ static void dump_json_image_info(ImageInfo *info)
str = qobject_to_json_pretty(obj); str = qobject_to_json_pretty(obj);
assert(str != NULL); assert(str != NULL);
printf("%s\n", qstring_get_str(str)); printf("%s\n", qstring_get_str(str));
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
QDECREF(str); qobject_unref(str);
} }
static void dump_human_image_info_list(ImageInfoList *list) static void dump_human_image_info_list(ImageInfoList *list)
@ -4457,9 +4457,9 @@ static void dump_json_block_measure_info(BlockMeasureInfo *info)
str = qobject_to_json_pretty(obj); str = qobject_to_json_pretty(obj);
assert(str != NULL); assert(str != NULL);
printf("%s\n", qstring_get_str(str)); printf("%s\n", qstring_get_str(str));
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
QDECREF(str); qobject_unref(str);
} }
static int img_measure(int argc, char **argv) static int img_measure(int argc, char **argv)

6
qemu-io.c
View File

@ -86,7 +86,7 @@ static int openfile(char *name, int flags, bool writethrough, bool force_share,
if (qemuio_blk) { if (qemuio_blk) {
error_report("file open already, try 'help close'"); error_report("file open already, try 'help close'");
QDECREF(opts); qobject_unref(opts);
return 1; return 1;
} }
@ -97,7 +97,7 @@ static int openfile(char *name, int flags, bool writethrough, bool force_share,
if (qdict_haskey(opts, BDRV_OPT_FORCE_SHARE) if (qdict_haskey(opts, BDRV_OPT_FORCE_SHARE)
&& !qdict_get_bool(opts, BDRV_OPT_FORCE_SHARE)) { && !qdict_get_bool(opts, BDRV_OPT_FORCE_SHARE)) {
error_report("-U conflicts with image options"); error_report("-U conflicts with image options");
QDECREF(opts); qobject_unref(opts);
return 1; return 1;
} }
qdict_put_bool(opts, BDRV_OPT_FORCE_SHARE, true); qdict_put_bool(opts, BDRV_OPT_FORCE_SHARE, true);
@ -243,7 +243,7 @@ static int open_f(BlockBackend *blk, int argc, char **argv)
} else if (optind == argc) { } else if (optind == argc) {
openfile(NULL, flags, writethrough, force_share, opts); openfile(NULL, flags, writethrough, force_share, opts);
} else { } else {
QDECREF(opts); qobject_unref(opts);
qemuio_command_usage(&open_cmd); qemuio_command_usage(&open_cmd);
} }
return 0; return 0;

12
qga/main.c
View File

@ -563,7 +563,7 @@ static int send_response(GAState *s, QObject *payload)
response_qstr = qstring_new(); response_qstr = qstring_new();
qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE); qstring_append_chr(response_qstr, QGA_SENTINEL_BYTE);
qstring_append(response_qstr, qstring_get_str(payload_qstr)); qstring_append(response_qstr, qstring_get_str(payload_qstr));
QDECREF(payload_qstr); qobject_unref(payload_qstr);
} else { } else {
response_qstr = payload_qstr; response_qstr = payload_qstr;
} }
@ -571,7 +571,7 @@ static int send_response(GAState *s, QObject *payload)
qstring_append_chr(response_qstr, '\n'); qstring_append_chr(response_qstr, '\n');
buf = qstring_get_str(response_qstr); buf = qstring_get_str(response_qstr);
status = ga_channel_write_all(s->channel, buf, strlen(buf)); status = ga_channel_write_all(s->channel, buf, strlen(buf));
QDECREF(response_qstr); qobject_unref(response_qstr);
if (status != G_IO_STATUS_NORMAL) { if (status != G_IO_STATUS_NORMAL) {
return -EIO; return -EIO;
} }
@ -592,7 +592,7 @@ static void process_command(GAState *s, QDict *req)
if (ret < 0) { if (ret < 0) {
g_warning("error sending response: %s", strerror(-ret)); g_warning("error sending response: %s", strerror(-ret));
} }
qobject_decref(rsp); qobject_unref(rsp);
} }
} }
@ -609,7 +609,7 @@ static void process_event(JSONMessageParser *parser, GQueue *tokens)
g_debug("process_event: called"); g_debug("process_event: called");
qdict = qobject_to(QDict, json_parser_parse_err(tokens, NULL, &err)); qdict = qobject_to(QDict, json_parser_parse_err(tokens, NULL, &err));
if (err || !qdict) { if (err || !qdict) {
QDECREF(qdict); qobject_unref(qdict);
qdict = qdict_new(); qdict = qdict_new();
if (!err) { if (!err) {
g_warning("failed to parse event: unknown error"); g_warning("failed to parse event: unknown error");
@ -626,7 +626,7 @@ static void process_event(JSONMessageParser *parser, GQueue *tokens)
process_command(s, qdict); process_command(s, qdict);
} else { } else {
if (!qdict_haskey(qdict, "error")) { if (!qdict_haskey(qdict, "error")) {
QDECREF(qdict); qobject_unref(qdict);
qdict = qdict_new(); qdict = qdict_new();
g_warning("unrecognized payload format"); g_warning("unrecognized payload format");
error_setg(&err, QERR_UNSUPPORTED); error_setg(&err, QERR_UNSUPPORTED);
@ -639,7 +639,7 @@ static void process_event(JSONMessageParser *parser, GQueue *tokens)
} }
} }
QDECREF(qdict); qobject_unref(qdict);
} }
/* false return signals GAChannel to close the current client connection */ /* false return signals GAChannel to close the current client connection */

4
qmp.c
View File

@ -710,7 +710,7 @@ void qmp_object_add(const char *type, const char *id,
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict"); error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict");
return; return;
} }
QINCREF(pdict); qobject_ref(pdict);
} else { } else {
pdict = qdict_new(); pdict = qdict_new();
} }
@ -721,7 +721,7 @@ void qmp_object_add(const char *type, const char *id,
if (obj) { if (obj) {
object_unref(obj); object_unref(obj);
} }
QDECREF(pdict); qobject_unref(pdict);
} }
void qmp_object_del(const char *id, Error **errp) void qmp_object_del(const char *id, Error **errp)

10
qobject/json-parser.c
View File

@ -222,7 +222,7 @@ static QString *qstring_from_escaped_str(JSONParserContext *ctxt,
return str; return str;
out: out:
QDECREF(str); qobject_unref(str);
return NULL; return NULL;
} }
@ -311,12 +311,12 @@ static int parse_pair(JSONParserContext *ctxt, QDict *dict, va_list *ap)
qdict_put_obj(dict, qstring_get_str(key), value); qdict_put_obj(dict, qstring_get_str(key), value);
QDECREF(key); qobject_unref(key);
return 0; return 0;
out: out:
QDECREF(key); qobject_unref(key);
return -1; return -1;
} }
@ -371,7 +371,7 @@ static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
return QOBJECT(dict); return QOBJECT(dict);
out: out:
QDECREF(dict); qobject_unref(dict);
return NULL; return NULL;
} }
@ -435,7 +435,7 @@ static QObject *parse_array(JSONParserContext *ctxt, va_list *ap)
return QOBJECT(list); return QOBJECT(list);
out: out:
QDECREF(list); qobject_unref(list);
return NULL; return NULL;
} }

49
qobject/qdict.c
View File

@ -123,7 +123,7 @@ void qdict_put_obj(QDict *qdict, const char *key, QObject *value)
entry = qdict_find(qdict, key, bucket); entry = qdict_find(qdict, key, bucket);
if (entry) { if (entry) {
/* replace key's value */ /* replace key's value */
qobject_decref(entry->value); qobject_unref(entry->value);
entry->value = value; entry->value = value;
} else { } else {
/* allocate a new entry */ /* allocate a new entry */
@ -373,8 +373,7 @@ QDict *qdict_clone_shallow(const QDict *src)
for (i = 0; i < QDICT_BUCKET_MAX; i++) { for (i = 0; i < QDICT_BUCKET_MAX; i++) {
QLIST_FOREACH(entry, &src->table[i], next) { QLIST_FOREACH(entry, &src->table[i], next) {
qobject_incref(entry->value); qdict_put_obj(dest, entry->key, qobject_ref(entry->value));
qdict_put_obj(dest, entry->key, entry->value);
} }
} }
@ -390,7 +389,7 @@ static void qentry_destroy(QDictEntry *e)
assert(e->key != NULL); assert(e->key != NULL);
assert(e->value != NULL); assert(e->value != NULL);
qobject_decref(e->value); qobject_unref(e->value);
g_free(e->key); g_free(e->key);
g_free(e); g_free(e);
} }
@ -480,8 +479,7 @@ void qdict_copy_default(QDict *dst, QDict *src, const char *key)
val = qdict_get(src, key); val = qdict_get(src, key);
if (val) { if (val) {
qobject_incref(val); qdict_put_obj(dst, key, qobject_ref(val));
qdict_put_obj(dst, key, val);
} }
} }
@ -526,8 +524,7 @@ static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
qdict_flatten_qlist(qobject_to(QList, value), target, new_key); qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
} else { } else {
/* All other types are moved to the target unchanged. */ /* All other types are moved to the target unchanged. */
qobject_incref(value); qdict_put_obj(target, new_key, qobject_ref(value));
qdict_put_obj(target, new_key, value);
} }
g_free(new_key); g_free(new_key);
@ -566,8 +563,7 @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
delete = true; delete = true;
} else if (prefix) { } else if (prefix) {
/* All other objects are moved to the target unchanged. */ /* All other objects are moved to the target unchanged. */
qobject_incref(value); qdict_put_obj(target, new_key, qobject_ref(value));
qdict_put_obj(target, new_key, value);
delete = true; delete = true;
} }
@ -610,8 +606,7 @@ void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start)
while (entry != NULL) { while (entry != NULL) {
next = qdict_next(src, entry); next = qdict_next(src, entry);
if (strstart(entry->key, start, &p)) { if (strstart(entry->key, start, &p)) {
qobject_incref(entry->value); qdict_put_obj(*dst, p, qobject_ref(entry->value));
qdict_put_obj(*dst, p, entry->value);
qdict_del(src, entry->key); qdict_del(src, entry->key);
} }
entry = next; entry = next;
@ -684,7 +679,7 @@ void qdict_array_split(QDict *src, QList **dst)
qdict_extract_subqdict(src, &subqdict, prefix); qdict_extract_subqdict(src, &subqdict, prefix);
assert(qdict_size(subqdict) > 0); assert(qdict_size(subqdict) > 0);
} else { } else {
qobject_incref(subqobj); qobject_ref(subqobj);
qdict_del(src, indexstr); qdict_del(src, indexstr);
} }
@ -894,16 +889,14 @@ QObject *qdict_crumple(const QDict *src, Error **errp)
qdict_put_obj(two_level, prefix, QOBJECT(child_dict)); qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
} }
qobject_incref(ent->value); qdict_put_obj(child_dict, suffix, qobject_ref(ent->value));
qdict_put_obj(child_dict, suffix, ent->value);
} else { } else {
if (child) { if (child) {
error_setg(errp, "Key %s prefix is already set as a dict", error_setg(errp, "Key %s prefix is already set as a dict",
prefix); prefix);
goto error; goto error;
} }
qobject_incref(ent->value); qdict_put_obj(two_level, prefix, qobject_ref(ent->value));
qdict_put_obj(two_level, prefix, ent->value);
} }
g_free(prefix); g_free(prefix);
@ -924,11 +917,10 @@ QObject *qdict_crumple(const QDict *src, Error **errp)
qdict_put_obj(multi_level, ent->key, child); qdict_put_obj(multi_level, ent->key, child);
} else { } else {
qobject_incref(ent->value); qdict_put_obj(multi_level, ent->key, qobject_ref(ent->value));
qdict_put_obj(multi_level, ent->key, ent->value);
} }
} }
QDECREF(two_level); qobject_unref(two_level);
two_level = NULL; two_level = NULL;
/* Step 3: detect if we need to turn our dict into list */ /* Step 3: detect if we need to turn our dict into list */
@ -951,10 +943,9 @@ QObject *qdict_crumple(const QDict *src, Error **errp)
goto error; goto error;
} }
qobject_incref(child); qlist_append_obj(qobject_to(QList, dst), qobject_ref(child));
qlist_append_obj(qobject_to(QList, dst), child);
} }
QDECREF(multi_level); qobject_unref(multi_level);
multi_level = NULL; multi_level = NULL;
} else { } else {
dst = QOBJECT(multi_level); dst = QOBJECT(multi_level);
@ -964,9 +955,9 @@ QObject *qdict_crumple(const QDict *src, Error **errp)
error: error:
g_free(prefix); g_free(prefix);
QDECREF(multi_level); qobject_unref(multi_level);
QDECREF(two_level); qobject_unref(two_level);
qobject_decref(dst); qobject_unref(dst);
return NULL; return NULL;
} }
@ -1055,8 +1046,7 @@ void qdict_join(QDict *dest, QDict *src, bool overwrite)
next = qdict_next(src, entry); next = qdict_next(src, entry);
if (overwrite || !qdict_haskey(dest, entry->key)) { if (overwrite || !qdict_haskey(dest, entry->key)) {
qobject_incref(entry->value); qdict_put_obj(dest, entry->key, qobject_ref(entry->value));
qdict_put_obj(dest, entry->key, entry->value);
qdict_del(src, entry->key); qdict_del(src, entry->key);
} }
@ -1088,8 +1078,7 @@ bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp)
} }
qobj = qdict_get(qdict, renames->from); qobj = qdict_get(qdict, renames->from);
qobject_incref(qobj); qdict_put_obj(qdict, renames->to, qobject_ref(qobj));
qdict_put_obj(qdict, renames->to, qobj);
qdict_del(qdict, renames->from); qdict_del(qdict, renames->from);
} }

2
qobject/qjson.c
View File

@ -104,7 +104,7 @@ static void to_json_dict_iter(const char *key, QObject *obj, void *opaque)
qkey = qstring_from_str(key); qkey = qstring_from_str(key);
to_json(QOBJECT(qkey), s->str, s->pretty, s->indent); to_json(QOBJECT(qkey), s->str, s->pretty, s->indent);
QDECREF(qkey); qobject_unref(qkey);
qstring_append(s->str, ": "); qstring_append(s->str, ": ");
to_json(obj, s->str, s->pretty, s->indent); to_json(obj, s->str, s->pretty, s->indent);

4
qobject/qlist.c
View File

@ -39,7 +39,7 @@ static void qlist_copy_elem(QObject *obj, void *opaque)
{ {
QList *dst = opaque; QList *dst = opaque;
qobject_incref(obj); qobject_ref(obj);
qlist_append_obj(dst, obj); qlist_append_obj(dst, obj);
} }
@ -196,7 +196,7 @@ void qlist_destroy_obj(QObject *obj)
QTAILQ_FOREACH_SAFE(entry, &qlist->head, next, next_entry) { QTAILQ_FOREACH_SAFE(entry, &qlist->head, next, next_entry) {
QTAILQ_REMOVE(&qlist->head, entry, next); QTAILQ_REMOVE(&qlist->head, entry, next);
qobject_decref(entry->value); qobject_unref(entry->value);
g_free(entry); g_free(entry);
} }

21
qobject/qobject.c
View File

@ -16,6 +16,15 @@
#include "qapi/qmp/qlist.h" #include "qapi/qmp/qlist.h"
#include "qapi/qmp/qstring.h" #include "qapi/qmp/qstring.h"
QEMU_BUILD_BUG_MSG(
offsetof(QNull, base) != 0 ||
offsetof(QNum, base) != 0 ||
offsetof(QString, base) != 0 ||
offsetof(QDict, base) != 0 ||
offsetof(QList, base) != 0 ||
offsetof(QBool, base) != 0,
"base qobject must be at offset 0");
static void (*qdestroy[QTYPE__MAX])(QObject *) = { static void (*qdestroy[QTYPE__MAX])(QObject *) = {
[QTYPE_NONE] = NULL, /* No such object exists */ [QTYPE_NONE] = NULL, /* No such object exists */
[QTYPE_QNULL] = NULL, /* qnull_ is indestructible */ [QTYPE_QNULL] = NULL, /* qnull_ is indestructible */
@ -28,9 +37,9 @@ static void (*qdestroy[QTYPE__MAX])(QObject *) = {
void qobject_destroy(QObject *obj) void qobject_destroy(QObject *obj)
{ {
assert(!obj->refcnt); assert(!obj->base.refcnt);
assert(QTYPE_QNULL < obj->type && obj->type < QTYPE__MAX); assert(QTYPE_QNULL < obj->base.type && obj->base.type < QTYPE__MAX);
qdestroy[obj->type](obj); qdestroy[obj->base.type](obj);
} }
@ -53,11 +62,11 @@ bool qobject_is_equal(const QObject *x, const QObject *y)
return true; return true;
} }
if (!x || !y || x->type != y->type) { if (!x || !y || x->base.type != y->base.type) {
return false; return false;
} }
assert(QTYPE_NONE < x->type && x->type < QTYPE__MAX); assert(QTYPE_NONE < x->base.type && x->base.type < QTYPE__MAX);
return qis_equal[x->type](x, y); return qis_equal[x->base.type](x, y);
} }

16
qom/object.c
View File

@ -1129,7 +1129,7 @@ void object_property_set_str(Object *obj, const char *value,
QString *qstr = qstring_from_str(value); QString *qstr = qstring_from_str(value);
object_property_set_qobject(obj, QOBJECT(qstr), name, errp); object_property_set_qobject(obj, QOBJECT(qstr), name, errp);
QDECREF(qstr); qobject_unref(qstr);
} }
char *object_property_get_str(Object *obj, const char *name, char *object_property_get_str(Object *obj, const char *name,
@ -1147,7 +1147,7 @@ char *object_property_get_str(Object *obj, const char *name,
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string"); error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name, "string");
} }
qobject_decref(ret); qobject_unref(ret);
return retval; return retval;
} }
@ -1187,7 +1187,7 @@ void object_property_set_bool(Object *obj, bool value,
QBool *qbool = qbool_from_bool(value); QBool *qbool = qbool_from_bool(value);
object_property_set_qobject(obj, QOBJECT(qbool), name, errp); object_property_set_qobject(obj, QOBJECT(qbool), name, errp);
QDECREF(qbool); qobject_unref(qbool);
} }
bool object_property_get_bool(Object *obj, const char *name, bool object_property_get_bool(Object *obj, const char *name,
@ -1208,7 +1208,7 @@ bool object_property_get_bool(Object *obj, const char *name,
retval = qbool_get_bool(qbool); retval = qbool_get_bool(qbool);
} }
qobject_decref(ret); qobject_unref(ret);
return retval; return retval;
} }
@ -1218,7 +1218,7 @@ void object_property_set_int(Object *obj, int64_t value,
QNum *qnum = qnum_from_int(value); QNum *qnum = qnum_from_int(value);
object_property_set_qobject(obj, QOBJECT(qnum), name, errp); object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
QDECREF(qnum); qobject_unref(qnum);
} }
int64_t object_property_get_int(Object *obj, const char *name, int64_t object_property_get_int(Object *obj, const char *name,
@ -1238,7 +1238,7 @@ int64_t object_property_get_int(Object *obj, const char *name,
retval = -1; retval = -1;
} }
qobject_decref(ret); qobject_unref(ret);
return retval; return retval;
} }
@ -1248,7 +1248,7 @@ void object_property_set_uint(Object *obj, uint64_t value,
QNum *qnum = qnum_from_uint(value); QNum *qnum = qnum_from_uint(value);
object_property_set_qobject(obj, QOBJECT(qnum), name, errp); object_property_set_qobject(obj, QOBJECT(qnum), name, errp);
QDECREF(qnum); qobject_unref(qnum);
} }
uint64_t object_property_get_uint(Object *obj, const char *name, uint64_t object_property_get_uint(Object *obj, const char *name,
@ -1267,7 +1267,7 @@ uint64_t object_property_get_uint(Object *obj, const char *name,
retval = 0; retval = 0;
} }
qobject_decref(ret); qobject_unref(ret);
return retval; return retval;
} }

2
qom/object_interfaces.c
View File

@ -140,7 +140,7 @@ Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
qemu_opts_set_id(opts, (char *) id); qemu_opts_set_id(opts, (char *) id);
qemu_opt_set(opts, "qom-type", type, &error_abort); qemu_opt_set(opts, "qom-type", type, &error_abort);
g_free(type); g_free(type);
QDECREF(pdict); qobject_unref(pdict);
return obj; return obj;
} }

8
scripts/coccinelle/qobject.cocci
View File

@ -3,11 +3,11 @@
expression Obj, Key, E; expression Obj, Key, E;
@@ @@
( (
- qobject_incref(QOBJECT(E)); - qobject_ref(QOBJECT(E));
+ QINCREF(E); + qobject_ref(E);
| |
- qobject_decref(QOBJECT(E)); - qobject_unref(QOBJECT(E));
+ QDECREF(E); + qobject_unref(E);
| |
- qdict_put_obj(Obj, Key, QOBJECT(E)); - qdict_put_obj(Obj, Key, QOBJECT(E));
+ qdict_put(Obj, Key, E); + qdict_put(Obj, Key, E);

2
scripts/qapi/common.py
View File

@ -1822,7 +1822,7 @@ def c_name(name, protect=True):
'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not', 'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not',
'not_eq', 'or', 'or_eq', 'xor', 'xor_eq']) 'not_eq', 'or', 'or_eq', 'xor', 'xor_eq'])
# namespace pollution: # namespace pollution:
polluted_words = set(['unix', 'errno', 'mips', 'sparc']) polluted_words = set(['unix', 'errno', 'mips', 'sparc', 'i386'])
name = name.translate(c_name_trans) name = name.translate(c_name_trans)
if protect and (name in c89_words | c99_words | c11_words | gcc_words if protect and (name in c89_words | c99_words | c11_words | gcc_words
| cpp_words | polluted_words): | cpp_words | polluted_words):

2
scripts/qapi/events.py
View File

@ -142,7 +142,7 @@ out:
''') ''')
ret += mcgen(''' ret += mcgen('''
error_propagate(errp, err); error_propagate(errp, err);
QDECREF(qmp); qobject_unref(qmp);
} }
''') ''')
return ret return ret

2
target/ppc/translate_init.c
View File

@ -8364,7 +8364,7 @@ static void getset_compat_deprecated(Object *obj, Visitor *v, const char *name,
"use max-cpu-compat machine property instead"); "use max-cpu-compat machine property instead");
} }
visit_type_null(v, name, &null, NULL); visit_type_null(v, name, &null, NULL);
QDECREF(null); qobject_unref(null);
} }
static const PropertyInfo ppc_compat_deprecated_propinfo = { static const PropertyInfo ppc_compat_deprecated_propinfo = {

2
target/s390x/cpu_models.c
View File

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

6
tests/ahci-test.c
View File

@ -1566,7 +1566,7 @@ static void atapi_wait_tray(bool open)
} else { } else {
g_assert(!qdict_get_bool(data, "tray-open")); g_assert(!qdict_get_bool(data, "tray-open"));
} }
QDECREF(rsp); qobject_unref(rsp);
} }
static void test_atapi_tray(void) static void test_atapi_tray(void)
@ -1596,7 +1596,7 @@ static void test_atapi_tray(void)
"'arguments': {'id': 'cd0'}}"); "'arguments': {'id': 'cd0'}}");
atapi_wait_tray(true); atapi_wait_tray(true);
rsp = qmp_receive(); rsp = qmp_receive();
QDECREF(rsp); qobject_unref(rsp);
qmp_discard_response("{'execute': 'blockdev-remove-medium', " qmp_discard_response("{'execute': 'blockdev-remove-medium', "
"'arguments': {'id': 'cd0'}}"); "'arguments': {'id': 'cd0'}}");
@ -1623,7 +1623,7 @@ static void test_atapi_tray(void)
"'arguments': {'id': 'cd0'}}"); "'arguments': {'id': 'cd0'}}");
atapi_wait_tray(false); atapi_wait_tray(false);
rsp = qmp_receive(); rsp = qmp_receive();
QDECREF(rsp); qobject_unref(rsp);
/* Now, to convince ATAPI we understand the media has changed... */ /* Now, to convince ATAPI we understand the media has changed... */
ahci_atapi_test_ready(ahci, port, false, SENSE_NOT_READY); ahci_atapi_test_ready(ahci, port, false, SENSE_NOT_READY);

108
tests/check-qdict.c
View File

@ -34,7 +34,7 @@ static void qdict_new_test(void)
g_assert(qdict->base.refcnt == 1); g_assert(qdict->base.refcnt == 1);
g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT); g_assert(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
QDECREF(qdict); qobject_unref(qdict);
} }
static void qdict_put_obj_test(void) static void qdict_put_obj_test(void)
@ -54,7 +54,7 @@ static void qdict_put_obj_test(void)
qn = qobject_to(QNum, ent->value); qn = qobject_to(QNum, ent->value);
g_assert_cmpint(qnum_get_int(qn), ==, num); g_assert_cmpint(qnum_get_int(qn), ==, num);
QDECREF(qdict); qobject_unref(qdict);
} }
static void qdict_destroy_simple_test(void) static void qdict_destroy_simple_test(void)
@ -65,7 +65,7 @@ static void qdict_destroy_simple_test(void)
qdict_put_int(qdict, "num", 0); qdict_put_int(qdict, "num", 0);
qdict_put_str(qdict, "str", "foo"); qdict_put_str(qdict, "str", "foo");
QDECREF(qdict); qobject_unref(qdict);
} }
static void qdict_get_test(void) static void qdict_get_test(void)
@ -84,7 +84,7 @@ static void qdict_get_test(void)
qn = qobject_to(QNum, obj); qn = qobject_to(QNum, obj);
g_assert_cmpint(qnum_get_int(qn), ==, value); g_assert_cmpint(qnum_get_int(qn), ==, value);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_get_int_test(void) static void qdict_get_int_test(void)
@ -99,7 +99,7 @@ static void qdict_get_int_test(void)
ret = qdict_get_int(tests_dict, key); ret = qdict_get_int(tests_dict, key);
g_assert(ret == value); g_assert(ret == value);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_get_try_int_test(void) static void qdict_get_try_int_test(void)
@ -121,7 +121,7 @@ static void qdict_get_try_int_test(void)
ret = qdict_get_try_int(tests_dict, "string", -42); ret = qdict_get_try_int(tests_dict, "string", -42);
g_assert_cmpuint(ret, ==, -42); g_assert_cmpuint(ret, ==, -42);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_get_str_test(void) static void qdict_get_str_test(void)
@ -137,7 +137,7 @@ static void qdict_get_str_test(void)
g_assert(p != NULL); g_assert(p != NULL);
g_assert(strcmp(p, str) == 0); g_assert(strcmp(p, str) == 0);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_get_try_str_test(void) static void qdict_get_try_str_test(void)
@ -153,7 +153,7 @@ static void qdict_get_try_str_test(void)
g_assert(p != NULL); g_assert(p != NULL);
g_assert(strcmp(p, str) == 0); g_assert(strcmp(p, str) == 0);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_defaults_test(void) static void qdict_defaults_test(void)
@ -174,8 +174,8 @@ static void qdict_defaults_test(void)
qdict_copy_default(copy, dict, "bar"); qdict_copy_default(copy, dict, "bar");
g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz"); g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
QDECREF(copy); qobject_unref(copy);
QDECREF(dict); qobject_unref(dict);
} }
static void qdict_haskey_not_test(void) static void qdict_haskey_not_test(void)
@ -183,7 +183,7 @@ static void qdict_haskey_not_test(void)
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
g_assert(qdict_haskey(tests_dict, "test") == 0); g_assert(qdict_haskey(tests_dict, "test") == 0);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_haskey_test(void) static void qdict_haskey_test(void)
@ -194,7 +194,7 @@ static void qdict_haskey_test(void)
qdict_put_int(tests_dict, key, 0); qdict_put_int(tests_dict, key, 0);
g_assert(qdict_haskey(tests_dict, key) == 1); g_assert(qdict_haskey(tests_dict, key) == 1);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_del_test(void) static void qdict_del_test(void)
@ -210,7 +210,7 @@ static void qdict_del_test(void)
g_assert(qdict_size(tests_dict) == 0); g_assert(qdict_size(tests_dict) == 0);
g_assert(qdict_haskey(tests_dict, key) == 0); g_assert(qdict_haskey(tests_dict, key) == 0);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qobject_to_qdict_test(void) static void qobject_to_qdict_test(void)
@ -218,7 +218,7 @@ static void qobject_to_qdict_test(void)
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
g_assert(qobject_to(QDict, QOBJECT(tests_dict)) == tests_dict); g_assert(qobject_to(QDict, QOBJECT(tests_dict)) == tests_dict);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_iterapi_test(void) static void qdict_iterapi_test(void)
@ -250,7 +250,7 @@ static void qdict_iterapi_test(void)
g_assert(count == qdict_size(tests_dict)); g_assert(count == qdict_size(tests_dict));
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_flatten_test(void) static void qdict_flatten_test(void)
@ -325,7 +325,7 @@ static void qdict_flatten_test(void)
g_assert(qdict_size(dict3) == 8); g_assert(qdict_size(dict3) == 8);
QDECREF(dict3); qobject_unref(dict3);
} }
static void qdict_array_split_test(void) static void qdict_array_split_test(void)
@ -390,31 +390,31 @@ static void qdict_array_split_test(void)
g_assert(int1); g_assert(int1);
g_assert(qlist_empty(test_list)); g_assert(qlist_empty(test_list));
QDECREF(test_list); qobject_unref(test_list);
g_assert(qdict_get_int(dict1, "a") == 42); g_assert(qdict_get_int(dict1, "a") == 42);
g_assert(qdict_get_int(dict1, "b") == 23); g_assert(qdict_get_int(dict1, "b") == 23);
g_assert(qdict_size(dict1) == 2); g_assert(qdict_size(dict1) == 2);
QDECREF(dict1); qobject_unref(dict1);
g_assert(qdict_get_int(dict2, "x") == 0); g_assert(qdict_get_int(dict2, "x") == 0);
g_assert(qdict_size(dict2) == 1); g_assert(qdict_size(dict2) == 1);
QDECREF(dict2); qobject_unref(dict2);
g_assert_cmpint(qnum_get_int(int1), ==, 66); g_assert_cmpint(qnum_get_int(int1), ==, 66);
QDECREF(int1); qobject_unref(int1);
g_assert(qdict_get_int(test_dict, "4.y") == 1); g_assert(qdict_get_int(test_dict, "4.y") == 1);
g_assert(qdict_get_int(test_dict, "o.o") == 7); g_assert(qdict_get_int(test_dict, "o.o") == 7);
g_assert(qdict_size(test_dict) == 2); g_assert(qdict_size(test_dict) == 2);
QDECREF(test_dict); qobject_unref(test_dict);
/* /*
* Test the split of * Test the split of
@ -455,18 +455,18 @@ static void qdict_array_split_test(void)
g_assert(int1); g_assert(int1);
g_assert(qlist_empty(test_list)); g_assert(qlist_empty(test_list));
QDECREF(test_list); qobject_unref(test_list);
g_assert_cmpint(qnum_get_int(int1), ==, 42); g_assert_cmpint(qnum_get_int(int1), ==, 42);
QDECREF(int1); qobject_unref(int1);
g_assert(qdict_get_int(test_dict, "1") == 23); g_assert(qdict_get_int(test_dict, "1") == 23);
g_assert(qdict_get_int(test_dict, "1.x") == 84); g_assert(qdict_get_int(test_dict, "1.x") == 84);
g_assert(qdict_size(test_dict) == 2); g_assert(qdict_size(test_dict) == 2);
QDECREF(test_dict); qobject_unref(test_dict);
} }
static void qdict_array_entries_test(void) static void qdict_array_entries_test(void)
@ -493,7 +493,7 @@ static void qdict_array_entries_test(void)
g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3); g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL); g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
QDECREF(dict); qobject_unref(dict);
dict = qdict_new(); dict = qdict_new();
qdict_put_int(dict, "1", 0); qdict_put_int(dict, "1", 0);
@ -509,7 +509,7 @@ static void qdict_array_entries_test(void)
qdict_put_int(dict, "2.c", 0); qdict_put_int(dict, "2.c", 0);
g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3); g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
QDECREF(dict); qobject_unref(dict);
} }
static void qdict_join_test(void) static void qdict_join_test(void)
@ -570,11 +570,11 @@ static void qdict_join_test(void)
} }
/* Check the references */ /* Check the references */
g_assert(qdict_get(dict1, "foo")->refcnt == 1); g_assert(qdict_get(dict1, "foo")->base.refcnt == 1);
g_assert(qdict_get(dict1, "bar")->refcnt == 1); g_assert(qdict_get(dict1, "bar")->base.refcnt == 1);
if (!overwrite) { if (!overwrite) {
g_assert(qdict_get(dict2, "foo")->refcnt == 1); g_assert(qdict_get(dict2, "foo")->base.refcnt == 1);
} }
/* Clean up */ /* Clean up */
@ -587,8 +587,8 @@ static void qdict_join_test(void)
} }
while (overwrite ^= true); while (overwrite ^= true);
QDECREF(dict1); qobject_unref(dict1);
QDECREF(dict2); qobject_unref(dict2);
} }
static void qdict_crumple_test_recursive(void) static void qdict_crumple_test_recursive(void)
@ -634,21 +634,21 @@ static void qdict_crumple_test_recursive(void)
g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpint(qdict_size(rule), ==, 2);
g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy")); g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
QDECREF(rule); qobject_unref(rule);
rule = qobject_to(QDict, qlist_pop(rules)); rule = qobject_to(QDict, qlist_pop(rules));
g_assert(rule); g_assert(rule);
g_assert_cmpint(qdict_size(rule), ==, 2); g_assert_cmpint(qdict_size(rule), ==, 2);
g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match")); g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy")); g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
QDECREF(rule); qobject_unref(rule);
/* With recursive crumpling, we should see all names unescaped */ /* With recursive crumpling, we should see all names unescaped */
g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name")); g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name")); g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
QDECREF(src); qobject_unref(src);
QDECREF(dst); qobject_unref(dst);
} }
static void qdict_crumple_test_empty(void) static void qdict_crumple_test_empty(void)
@ -657,12 +657,12 @@ static void qdict_crumple_test_empty(void)
src = qdict_new(); src = qdict_new();
dst = (QDict *)qdict_crumple(src, &error_abort); dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
g_assert_cmpint(qdict_size(dst), ==, 0); g_assert_cmpint(qdict_size(dst), ==, 0);
QDECREF(src); qobject_unref(src);
QDECREF(dst); qobject_unref(dst);
} }
static int qdict_count_entries(QDict *dict) static int qdict_count_entries(QDict *dict)
@ -704,7 +704,7 @@ static void qdict_rename_keys_test(void)
g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL); g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
g_assert_cmpint(qdict_count_entries(copy), ==, 5); g_assert_cmpint(qdict_count_entries(copy), ==, 5);
QDECREF(copy); qobject_unref(copy);
/* Simple rename of all entries */ /* Simple rename of all entries */
renames = (QDictRenames[]) { renames = (QDictRenames[]) {
@ -731,7 +731,7 @@ static void qdict_rename_keys_test(void)
g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL); g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL);
g_assert_cmpint(qdict_count_entries(copy), ==, 5); g_assert_cmpint(qdict_count_entries(copy), ==, 5);
QDECREF(copy); qobject_unref(copy);
/* Renames are processed top to bottom */ /* Renames are processed top to bottom */
renames = (QDictRenames[]) { renames = (QDictRenames[]) {
@ -754,7 +754,7 @@ static void qdict_rename_keys_test(void)
g_assert(!qdict_haskey(copy, "tmp")); g_assert(!qdict_haskey(copy, "tmp"));
g_assert_cmpint(qdict_count_entries(copy), ==, 5); g_assert_cmpint(qdict_count_entries(copy), ==, 5);
QDECREF(copy); qobject_unref(copy);
/* Conflicting rename */ /* Conflicting rename */
renames = (QDictRenames[]) { renames = (QDictRenames[]) {
@ -775,7 +775,7 @@ static void qdict_rename_keys_test(void)
g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL); g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
g_assert_cmpint(qdict_count_entries(copy), ==, 5); g_assert_cmpint(qdict_count_entries(copy), ==, 5);
QDECREF(copy); qobject_unref(copy);
/* Renames in an empty dict */ /* Renames in an empty dict */
renames = (QDictRenames[]) { renames = (QDictRenames[]) {
@ -783,13 +783,13 @@ static void qdict_rename_keys_test(void)
{ NULL , NULL } { NULL , NULL }
}; };
QDECREF(dict); qobject_unref(dict);
dict = qdict_new(); dict = qdict_new();
qdict_rename_keys(dict, renames, &error_abort); qdict_rename_keys(dict, renames, &error_abort);
g_assert(qdict_first(dict) == NULL); g_assert(qdict_first(dict) == NULL);
QDECREF(dict); qobject_unref(dict);
} }
static void qdict_crumple_test_bad_inputs(void) static void qdict_crumple_test_bad_inputs(void)
@ -806,7 +806,7 @@ static void qdict_crumple_test_bad_inputs(void)
g_assert(error != NULL); g_assert(error != NULL);
error_free(error); error_free(error);
error = NULL; error = NULL;
QDECREF(src); qobject_unref(src);
src = qdict_new(); src = qdict_new();
/* rule can't be both a list and a dict */ /* rule can't be both a list and a dict */
@ -817,7 +817,7 @@ static void qdict_crumple_test_bad_inputs(void)
g_assert(error != NULL); g_assert(error != NULL);
error_free(error); error_free(error);
error = NULL; error = NULL;
QDECREF(src); qobject_unref(src);
src = qdict_new(); src = qdict_new();
/* The input should be flat, ie no dicts or lists */ /* The input should be flat, ie no dicts or lists */
@ -828,7 +828,7 @@ static void qdict_crumple_test_bad_inputs(void)
g_assert(error != NULL); g_assert(error != NULL);
error_free(error); error_free(error);
error = NULL; error = NULL;
QDECREF(src); qobject_unref(src);
src = qdict_new(); src = qdict_new();
/* List indexes must not have gaps */ /* List indexes must not have gaps */
@ -839,7 +839,7 @@ static void qdict_crumple_test_bad_inputs(void)
g_assert(error != NULL); g_assert(error != NULL);
error_free(error); error_free(error);
error = NULL; error = NULL;
QDECREF(src); qobject_unref(src);
src = qdict_new(); src = qdict_new();
/* List indexes must be in %zu format */ /* List indexes must be in %zu format */
@ -850,7 +850,7 @@ static void qdict_crumple_test_bad_inputs(void)
g_assert(error != NULL); g_assert(error != NULL);
error_free(error); error_free(error);
error = NULL; error = NULL;
QDECREF(src); qobject_unref(src);
} }
/* /*
@ -871,7 +871,7 @@ static void qdict_put_exists_test(void)
g_assert(qdict_size(tests_dict) == 1); g_assert(qdict_size(tests_dict) == 1);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
static void qdict_get_not_exists_test(void) static void qdict_get_not_exists_test(void)
@ -879,7 +879,7 @@ static void qdict_get_not_exists_test(void)
QDict *tests_dict = qdict_new(); QDict *tests_dict = qdict_new();
g_assert(qdict_get(tests_dict, "foo") == NULL); g_assert(qdict_get(tests_dict, "foo") == NULL);
QDECREF(tests_dict); qobject_unref(tests_dict);
} }
/* /*
@ -951,7 +951,7 @@ static void qdict_stress_test(void)
g_assert(strcmp(str1, str2) == 0); g_assert(strcmp(str1, str2) == 0);
QDECREF(value); qobject_unref(value);
} }
// Delete everything // Delete everything
@ -962,14 +962,14 @@ static void qdict_stress_test(void)
break; break;
qdict_del(qdict, key); qdict_del(qdict, key);
QDECREF(value); qobject_unref(value);
g_assert(qdict_haskey(qdict, key) == 0); g_assert(qdict_haskey(qdict, key) == 0);
} }
fclose(test_file); fclose(test_file);
g_assert(qdict_size(qdict) == 0); g_assert(qdict_size(qdict) == 0);
QDECREF(qdict); qobject_unref(qdict);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

84
tests/check-qjson.c
View File

@ -67,10 +67,10 @@ static void escaped_string(void)
if (test_cases[i].skip == 0) { if (test_cases[i].skip == 0) {
str = qobject_to_json(obj); str = qobject_to_json(obj);
g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].encoded); g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].encoded);
qobject_decref(obj); qobject_unref(obj);
} }
QDECREF(str); qobject_unref(str);
} }
} }
@ -99,9 +99,9 @@ static void simple_string(void)
str = qobject_to_json(obj); str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0); g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
qobject_decref(obj); qobject_unref(obj);
QDECREF(str); qobject_unref(str);
} }
} }
@ -127,7 +127,7 @@ static void single_quote_string(void)
g_assert(str); g_assert(str);
g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0); g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
QDECREF(str); qobject_unref(str);
} }
} }
@ -823,7 +823,7 @@ static void utf8_string(void)
} else { } else {
g_assert(!obj); g_assert(!obj);
} }
qobject_decref(obj); qobject_unref(obj);
obj = QOBJECT(qstring_from_str(utf8_in)); obj = QOBJECT(qstring_from_str(utf8_in));
str = qobject_to_json(obj); str = qobject_to_json(obj);
@ -833,8 +833,8 @@ static void utf8_string(void)
} else { } else {
g_assert(!str); g_assert(!str);
} }
QDECREF(str); qobject_unref(str);
qobject_decref(obj); qobject_unref(obj);
/* /*
* Disabled, because qobject_from_json() is buggy, and I can't * Disabled, because qobject_from_json() is buggy, and I can't
@ -869,7 +869,7 @@ static void vararg_string(void)
g_assert(str); g_assert(str);
g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0); g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
QDECREF(str); qobject_unref(str);
} }
} }
@ -904,10 +904,10 @@ static void simple_number(void)
str = qobject_to_json(QOBJECT(qnum)); str = qobject_to_json(QOBJECT(qnum));
g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0); g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
QDECREF(str); qobject_unref(str);
} }
QDECREF(qnum); qobject_unref(qnum);
} }
} }
@ -928,8 +928,8 @@ static void large_number(void)
str = qobject_to_json(QOBJECT(qnum)); str = qobject_to_json(QOBJECT(qnum));
g_assert_cmpstr(qstring_get_str(str), ==, maxu64); g_assert_cmpstr(qstring_get_str(str), ==, maxu64);
QDECREF(str); qobject_unref(str);
QDECREF(qnum); qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_json(gtu64, &error_abort)); qnum = qobject_to(QNum, qobject_from_json(gtu64, &error_abort));
g_assert(qnum); g_assert(qnum);
@ -939,8 +939,8 @@ static void large_number(void)
str = qobject_to_json(QOBJECT(qnum)); str = qobject_to_json(QOBJECT(qnum));
g_assert_cmpstr(qstring_get_str(str), ==, gtu64); g_assert_cmpstr(qstring_get_str(str), ==, gtu64);
QDECREF(str); qobject_unref(str);
QDECREF(qnum); qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_json(lti64, &error_abort)); qnum = qobject_to(QNum, qobject_from_json(lti64, &error_abort));
g_assert(qnum); g_assert(qnum);
@ -950,8 +950,8 @@ static void large_number(void)
str = qobject_to_json(QOBJECT(qnum)); str = qobject_to_json(QOBJECT(qnum));
g_assert_cmpstr(qstring_get_str(str), ==, "-9223372036854775808"); g_assert_cmpstr(qstring_get_str(str), ==, "-9223372036854775808");
QDECREF(str); qobject_unref(str);
QDECREF(qnum); qobject_unref(qnum);
} }
static void float_number(void) static void float_number(void)
@ -983,10 +983,10 @@ static void float_number(void)
str = qobject_to_json(obj); str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0); g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
QDECREF(str); qobject_unref(str);
} }
QDECREF(qnum); qobject_unref(qnum);
} }
} }
@ -1001,16 +1001,16 @@ static void vararg_number(void)
qnum = qobject_to(QNum, qobject_from_jsonf("%d", value)); qnum = qobject_to(QNum, qobject_from_jsonf("%d", value));
g_assert(qnum_get_try_int(qnum, &val)); g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, value); g_assert_cmpint(val, ==, value);
QDECREF(qnum); qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_jsonf("%lld", value_ll)); qnum = qobject_to(QNum, qobject_from_jsonf("%lld", value_ll));
g_assert(qnum_get_try_int(qnum, &val)); g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, value_ll); g_assert_cmpint(val, ==, value_ll);
QDECREF(qnum); qobject_unref(qnum);
qnum = qobject_to(QNum, qobject_from_jsonf("%f", valuef)); qnum = qobject_to(QNum, qobject_from_jsonf("%f", valuef));
g_assert(qnum_get_double(qnum) == valuef); g_assert(qnum_get_double(qnum) == valuef);
QDECREF(qnum); qobject_unref(qnum);
} }
static void keyword_literal(void) static void keyword_literal(void)
@ -1027,9 +1027,9 @@ static void keyword_literal(void)
str = qobject_to_json(obj); str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), "true") == 0); g_assert(strcmp(qstring_get_str(str), "true") == 0);
QDECREF(str); qobject_unref(str);
QDECREF(qbool); qobject_unref(qbool);
obj = qobject_from_json("false", &error_abort); obj = qobject_from_json("false", &error_abort);
qbool = qobject_to(QBool, obj); qbool = qobject_to(QBool, obj);
@ -1038,20 +1038,20 @@ static void keyword_literal(void)
str = qobject_to_json(obj); str = qobject_to_json(obj);
g_assert(strcmp(qstring_get_str(str), "false") == 0); g_assert(strcmp(qstring_get_str(str), "false") == 0);
QDECREF(str); qobject_unref(str);
QDECREF(qbool); qobject_unref(qbool);
qbool = qobject_to(QBool, qobject_from_jsonf("%i", false)); qbool = qobject_to(QBool, qobject_from_jsonf("%i", false));
g_assert(qbool); g_assert(qbool);
g_assert(qbool_get_bool(qbool) == false); g_assert(qbool_get_bool(qbool) == false);
QDECREF(qbool); qobject_unref(qbool);
/* Test that non-zero values other than 1 get collapsed to true */ /* Test that non-zero values other than 1 get collapsed to true */
qbool = qobject_to(QBool, qobject_from_jsonf("%i", 2)); qbool = qobject_to(QBool, qobject_from_jsonf("%i", 2));
g_assert(qbool); g_assert(qbool);
g_assert(qbool_get_bool(qbool) == true); g_assert(qbool_get_bool(qbool) == true);
QDECREF(qbool); qobject_unref(qbool);
obj = qobject_from_json("null", &error_abort); obj = qobject_from_json("null", &error_abort);
g_assert(obj != NULL); g_assert(obj != NULL);
@ -1060,8 +1060,8 @@ static void keyword_literal(void)
null = qnull(); null = qnull();
g_assert(QOBJECT(null) == obj); g_assert(QOBJECT(null) == obj);
qobject_decref(obj); qobject_unref(obj);
QDECREF(null); qobject_unref(null);
} }
static void simple_dict(void) static void simple_dict(void)
@ -1101,12 +1101,12 @@ static void simple_dict(void)
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj)); g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
str = qobject_to_json(obj); str = qobject_to_json(obj);
qobject_decref(obj); qobject_unref(obj);
obj = qobject_from_json(qstring_get_str(str), &error_abort); obj = qobject_from_json(qstring_get_str(str), &error_abort);
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj)); g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
qobject_decref(obj); qobject_unref(obj);
QDECREF(str); qobject_unref(str);
} }
} }
@ -1158,7 +1158,7 @@ static void large_dict(void)
obj = qobject_from_json(gstr->str, &error_abort); obj = qobject_from_json(gstr->str, &error_abort);
g_assert(obj != NULL); g_assert(obj != NULL);
qobject_decref(obj); qobject_unref(obj);
g_string_free(gstr, true); g_string_free(gstr, true);
} }
@ -1210,12 +1210,12 @@ static void simple_list(void)
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj)); g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
str = qobject_to_json(obj); str = qobject_to_json(obj);
qobject_decref(obj); qobject_unref(obj);
obj = qobject_from_json(qstring_get_str(str), &error_abort); obj = qobject_from_json(qstring_get_str(str), &error_abort);
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj)); g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
qobject_decref(obj); qobject_unref(obj);
QDECREF(str); qobject_unref(str);
} }
} }
@ -1272,13 +1272,13 @@ static void simple_whitespace(void)
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj)); g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
str = qobject_to_json(obj); str = qobject_to_json(obj);
qobject_decref(obj); qobject_unref(obj);
obj = qobject_from_json(qstring_get_str(str), &error_abort); obj = qobject_from_json(qstring_get_str(str), &error_abort);
g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj)); g_assert(qlit_equal_qobject(&test_cases[i].decoded, obj));
qobject_decref(obj); qobject_unref(obj);
QDECREF(str); qobject_unref(str);
} }
} }
@ -1301,7 +1301,7 @@ static void simple_varargs(void)
obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj); obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj);
g_assert(qlit_equal_qobject(&decoded, obj)); g_assert(qlit_equal_qobject(&decoded, obj));
qobject_decref(obj); qobject_unref(obj);
} }
static void empty_input(void) static void empty_input(void)
@ -1410,7 +1410,7 @@ static void limits_nesting(void)
obj = qobject_from_json(make_nest(buf, max_nesting), &error_abort); obj = qobject_from_json(make_nest(buf, max_nesting), &error_abort);
g_assert(obj != NULL); g_assert(obj != NULL);
qobject_decref(obj); qobject_unref(obj);
obj = qobject_from_json(make_nest(buf, max_nesting + 1), &err); obj = qobject_from_json(make_nest(buf, max_nesting + 1), &err);
error_free_or_abort(&err); error_free_or_abort(&err);

8
tests/check-qlist.c
View File

@ -29,7 +29,7 @@ static void qlist_new_test(void)
g_assert(qlist->base.refcnt == 1); g_assert(qlist->base.refcnt == 1);
g_assert(qobject_type(QOBJECT(qlist)) == QTYPE_QLIST); g_assert(qobject_type(QOBJECT(qlist)) == QTYPE_QLIST);
QDECREF(qlist); qobject_unref(qlist);
} }
static void qlist_append_test(void) static void qlist_append_test(void)
@ -47,7 +47,7 @@ static void qlist_append_test(void)
g_assert(entry != NULL); g_assert(entry != NULL);
g_assert(entry->value == QOBJECT(qi)); g_assert(entry->value == QOBJECT(qi));
QDECREF(qlist); qobject_unref(qlist);
} }
static void qobject_to_qlist_test(void) static void qobject_to_qlist_test(void)
@ -58,7 +58,7 @@ static void qobject_to_qlist_test(void)
g_assert(qobject_to(QList, QOBJECT(qlist)) == qlist); g_assert(qobject_to(QList, QOBJECT(qlist)) == qlist);
QDECREF(qlist); qobject_unref(qlist);
} }
static int iter_called; static int iter_called;
@ -96,7 +96,7 @@ static void qlist_iter_test(void)
g_assert(iter_called == iter_max); g_assert(iter_called == iter_max);
QDECREF(qlist); qobject_unref(qlist);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

10
tests/check-qlit.c
View File

@ -62,7 +62,7 @@ static void qlit_equal_qobject_test(void)
qdict_put(qobject_to(QDict, qobj), "bee", qlist_new()); qdict_put(qobject_to(QDict, qobj), "bee", qlist_new());
g_assert(!qlit_equal_qobject(&qlit, qobj)); g_assert(!qlit_equal_qobject(&qlit, qobj));
qobject_decref(qobj); qobject_unref(qobj);
} }
static void qobject_from_qlit_test(void) static void qobject_from_qlit_test(void)
@ -79,15 +79,15 @@ static void qobject_from_qlit_test(void)
bee = qdict_get_qlist(qdict, "bee"); bee = qdict_get_qlist(qdict, "bee");
obj = qlist_pop(bee); obj = qlist_pop(bee);
g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 43); g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 43);
qobject_decref(obj); qobject_unref(obj);
obj = qlist_pop(bee); obj = qlist_pop(bee);
g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 44); g_assert_cmpint(qnum_get_int(qobject_to(QNum, obj)), ==, 44);
qobject_decref(obj); qobject_unref(obj);
obj = qlist_pop(bee); obj = qlist_pop(bee);
g_assert(qbool_get_bool(qobject_to(QBool, obj))); g_assert(qbool_get_bool(qobject_to(QBool, obj)));
qobject_decref(obj); qobject_unref(obj);
qobject_decref(qobj); qobject_unref(qobj);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

10
tests/check-qnull.c
View File

@ -30,7 +30,7 @@ static void qnull_ref_test(void)
g_assert(obj == QOBJECT(&qnull_)); g_assert(obj == QOBJECT(&qnull_));
g_assert(qnull_.base.refcnt == 2); g_assert(qnull_.base.refcnt == 2);
g_assert(qobject_type(obj) == QTYPE_QNULL); g_assert(qobject_type(obj) == QTYPE_QNULL);
qobject_decref(obj); qobject_unref(obj);
g_assert(qnull_.base.refcnt == 1); g_assert(qnull_.base.refcnt == 1);
} }
@ -49,10 +49,10 @@ static void qnull_visit_test(void)
g_assert(qnull_.base.refcnt == 1); g_assert(qnull_.base.refcnt == 1);
obj = QOBJECT(qnull()); obj = QOBJECT(qnull());
v = qobject_input_visitor_new(obj); v = qobject_input_visitor_new(obj);
qobject_decref(obj); qobject_unref(obj);
visit_type_null(v, NULL, &null, &error_abort); visit_type_null(v, NULL, &null, &error_abort);
g_assert(obj == QOBJECT(&qnull_)); g_assert(obj == QOBJECT(&qnull_));
QDECREF(null); qobject_unref(null);
visit_free(v); visit_free(v);
null = NULL; null = NULL;
@ -60,8 +60,8 @@ static void qnull_visit_test(void)
visit_type_null(v, NULL, &null, &error_abort); visit_type_null(v, NULL, &null, &error_abort);
visit_complete(v, &obj); visit_complete(v, &obj);
g_assert(obj == QOBJECT(&qnull_)); g_assert(obj == QOBJECT(&qnull_));
QDECREF(null); qobject_unref(null);
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
g_assert(qnull_.base.refcnt == 1); g_assert(qnull_.base.refcnt == 1);

28
tests/check-qnum.c
View File

@ -35,7 +35,7 @@ static void qnum_from_int_test(void)
g_assert_cmpint(qn->base.refcnt, ==, 1); g_assert_cmpint(qn->base.refcnt, ==, 1);
g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM); g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM);
QDECREF(qn); qobject_unref(qn);
} }
static void qnum_from_uint_test(void) static void qnum_from_uint_test(void)
@ -50,7 +50,7 @@ static void qnum_from_uint_test(void)
g_assert(qn->base.refcnt == 1); g_assert(qn->base.refcnt == 1);
g_assert(qobject_type(QOBJECT(qn)) == QTYPE_QNUM); g_assert(qobject_type(QOBJECT(qn)) == QTYPE_QNUM);
QDECREF(qn); qobject_unref(qn);
} }
static void qnum_from_double_test(void) static void qnum_from_double_test(void)
@ -65,7 +65,7 @@ static void qnum_from_double_test(void)
g_assert_cmpint(qn->base.refcnt, ==, 1); g_assert_cmpint(qn->base.refcnt, ==, 1);
g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM); g_assert_cmpint(qobject_type(QOBJECT(qn)), ==, QTYPE_QNUM);
QDECREF(qn); qobject_unref(qn);
} }
static void qnum_from_int64_test(void) static void qnum_from_int64_test(void)
@ -76,7 +76,7 @@ static void qnum_from_int64_test(void)
qn = qnum_from_int(value); qn = qnum_from_int(value);
g_assert_cmpint((int64_t) qn->u.i64, ==, value); g_assert_cmpint((int64_t) qn->u.i64, ==, value);
QDECREF(qn); qobject_unref(qn);
} }
static void qnum_get_int_test(void) static void qnum_get_int_test(void)
@ -87,7 +87,7 @@ static void qnum_get_int_test(void)
qn = qnum_from_int(value); qn = qnum_from_int(value);
g_assert_cmpint(qnum_get_int(qn), ==, value); g_assert_cmpint(qnum_get_int(qn), ==, value);
QDECREF(qn); qobject_unref(qn);
} }
static void qnum_get_uint_test(void) static void qnum_get_uint_test(void)
@ -100,25 +100,25 @@ static void qnum_get_uint_test(void)
qn = qnum_from_uint(value); qn = qnum_from_uint(value);
g_assert(qnum_get_try_uint(qn, &val)); g_assert(qnum_get_try_uint(qn, &val));
g_assert_cmpuint(val, ==, value); g_assert_cmpuint(val, ==, value);
QDECREF(qn); qobject_unref(qn);
qn = qnum_from_int(value); qn = qnum_from_int(value);
g_assert(qnum_get_try_uint(qn, &val)); g_assert(qnum_get_try_uint(qn, &val));
g_assert_cmpuint(val, ==, value); g_assert_cmpuint(val, ==, value);
QDECREF(qn); qobject_unref(qn);
/* invalid cases */ /* invalid cases */
qn = qnum_from_int(-1); qn = qnum_from_int(-1);
g_assert(!qnum_get_try_uint(qn, &val)); g_assert(!qnum_get_try_uint(qn, &val));
QDECREF(qn); qobject_unref(qn);
qn = qnum_from_uint(-1ULL); qn = qnum_from_uint(-1ULL);
g_assert(!qnum_get_try_int(qn, &ival)); g_assert(!qnum_get_try_int(qn, &ival));
QDECREF(qn); qobject_unref(qn);
qn = qnum_from_double(0.42); qn = qnum_from_double(0.42);
g_assert(!qnum_get_try_uint(qn, &val)); g_assert(!qnum_get_try_uint(qn, &val));
QDECREF(qn); qobject_unref(qn);
} }
static void qobject_to_qnum_test(void) static void qobject_to_qnum_test(void)
@ -127,11 +127,11 @@ static void qobject_to_qnum_test(void)
qn = qnum_from_int(0); qn = qnum_from_int(0);
g_assert(qobject_to(QNum, QOBJECT(qn)) == qn); g_assert(qobject_to(QNum, QOBJECT(qn)) == qn);
QDECREF(qn); qobject_unref(qn);
qn = qnum_from_double(0); qn = qnum_from_double(0);
g_assert(qobject_to(QNum, QOBJECT(qn)) == qn); g_assert(qobject_to(QNum, QOBJECT(qn)) == qn);
QDECREF(qn); qobject_unref(qn);
} }
static void qnum_to_string_test(void) static void qnum_to_string_test(void)
@ -143,13 +143,13 @@ static void qnum_to_string_test(void)
tmp = qnum_to_string(qn); tmp = qnum_to_string(qn);
g_assert_cmpstr(tmp, ==, "123456"); g_assert_cmpstr(tmp, ==, "123456");
g_free(tmp); g_free(tmp);
QDECREF(qn); qobject_unref(qn);
qn = qnum_from_double(0.42); qn = qnum_from_double(0.42);
tmp = qnum_to_string(qn); tmp = qnum_to_string(qn);
g_assert_cmpstr(tmp, ==, "0.42"); g_assert_cmpstr(tmp, ==, "0.42");
g_free(tmp); g_free(tmp);
QDECREF(qn); qobject_unref(qn);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

2
tests/check-qobject.c
View File

@ -80,7 +80,7 @@ static void do_free_all(int _, ...)
va_start(ap, _); va_start(ap, _);
while ((obj = va_arg(ap, QObject *)) != NULL) { while ((obj = va_arg(ap, QObject *)) != NULL) {
qobject_decref(obj); qobject_unref(obj);
} }
va_end(ap); va_end(ap);
} }

10
tests/check-qstring.c
View File

@ -31,7 +31,7 @@ static void qstring_from_str_test(void)
g_assert(strcmp(str, qstring->string) == 0); g_assert(strcmp(str, qstring->string) == 0);
g_assert(qobject_type(QOBJECT(qstring)) == QTYPE_QSTRING); g_assert(qobject_type(QOBJECT(qstring)) == QTYPE_QSTRING);
QDECREF(qstring); qobject_unref(qstring);
} }
static void qstring_get_str_test(void) static void qstring_get_str_test(void)
@ -44,7 +44,7 @@ static void qstring_get_str_test(void)
ret_str = qstring_get_str(qstring); ret_str = qstring_get_str(qstring);
g_assert(strcmp(ret_str, str) == 0); g_assert(strcmp(ret_str, str) == 0);
QDECREF(qstring); qobject_unref(qstring);
} }
static void qstring_append_chr_test(void) static void qstring_append_chr_test(void)
@ -59,7 +59,7 @@ static void qstring_append_chr_test(void)
qstring_append_chr(qstring, str[i]); qstring_append_chr(qstring, str[i]);
g_assert(strcmp(str, qstring_get_str(qstring)) == 0); g_assert(strcmp(str, qstring_get_str(qstring)) == 0);
QDECREF(qstring); qobject_unref(qstring);
} }
static void qstring_from_substr_test(void) static void qstring_from_substr_test(void)
@ -70,7 +70,7 @@ static void qstring_from_substr_test(void)
g_assert(qs != NULL); g_assert(qs != NULL);
g_assert(strcmp(qstring_get_str(qs), "tualiza") == 0); g_assert(strcmp(qstring_get_str(qs), "tualiza") == 0);
QDECREF(qs); qobject_unref(qs);
} }
@ -81,7 +81,7 @@ static void qobject_to_qstring_test(void)
qstring = qstring_from_str("foo"); qstring = qstring_from_str("foo");
g_assert(qobject_to(QString, QOBJECT(qstring)) == qstring); g_assert(qobject_to(QString, QOBJECT(qstring)) == qstring);
QDECREF(qstring); qobject_unref(qstring);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

4
tests/cpu-plug-test.c
View File

@ -42,7 +42,7 @@ static void test_plug_with_cpu_add(gconstpointer data)
" 'arguments': { 'id': %d } }", i); " 'arguments': { 'id': %d } }", i);
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
} }
qtest_end(); qtest_end();
@ -66,7 +66,7 @@ static void test_plug_without_cpu_add(gconstpointer data)
s->sockets * s->cores * s->threads); s->sockets * s->cores * s->threads);
g_assert(response); g_assert(response);
g_assert(qdict_haskey(response, "error")); g_assert(qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
qtest_end(); qtest_end();
g_free(args); g_free(args);

24
tests/device-introspect-test.c
View File

@ -40,8 +40,8 @@ static QList *qom_list_types(const char *implements, bool abstract)
" 'arguments': %p }", args); " 'arguments': %p }", args);
g_assert(qdict_haskey(resp, "return")); g_assert(qdict_haskey(resp, "return"));
ret = qdict_get_qlist(resp, "return"); ret = qdict_get_qlist(resp, "return");
QINCREF(ret); qobject_ref(ret);
QDECREF(resp); qobject_unref(resp);
return ret; return ret;
} }
@ -54,7 +54,7 @@ static QDict *qom_type_index(QList *types)
QLIST_FOREACH_ENTRY(types, e) { QLIST_FOREACH_ENTRY(types, e) {
QDict *d = qobject_to(QDict, qlist_entry_obj(e)); QDict *d = qobject_to(QDict, qlist_entry_obj(e));
const char *name = qdict_get_str(d, "name"); const char *name = qdict_get_str(d, "name");
QINCREF(d); qobject_ref(d);
qdict_put(index, name, d); qdict_put(index, name, d);
} }
return index; return index;
@ -108,7 +108,7 @@ static void test_one_device(const char *type)
resp = qmp("{'execute': 'device-list-properties'," resp = qmp("{'execute': 'device-list-properties',"
" 'arguments': {'typename': %s}}", " 'arguments': {'typename': %s}}",
type); type);
QDECREF(resp); qobject_unref(resp);
help = hmp("device_add \"%s,help\"", type); help = hmp("device_add \"%s,help\"", type);
g_free(help); g_free(help);
@ -129,7 +129,7 @@ static void test_device_intro_list(void)
qtest_start(common_args); qtest_start(common_args);
types = device_type_list(true); types = device_type_list(true);
QDECREF(types); qobject_unref(types);
help = hmp("device_add help"); help = hmp("device_add help");
g_free(help); g_free(help);
@ -157,8 +157,8 @@ static void test_qom_list_parents(const char *parent)
g_assert(qom_has_parent(index, name, parent)); g_assert(qom_has_parent(index, name, parent));
} }
QDECREF(types); qobject_unref(types);
QDECREF(index); qobject_unref(index);
} }
static void test_qom_list_fields(void) static void test_qom_list_fields(void)
@ -187,8 +187,8 @@ static void test_qom_list_fields(void)
test_qom_list_parents("device"); test_qom_list_parents("device");
test_qom_list_parents("sys-bus-device"); test_qom_list_parents("sys-bus-device");
QDECREF(all_types); qobject_unref(all_types);
QDECREF(non_abstract); qobject_unref(non_abstract);
qtest_end(); qtest_end();
} }
@ -222,7 +222,7 @@ static void test_device_intro_concrete(void)
test_one_device(type); test_one_device(type);
} }
QDECREF(types); qobject_unref(types);
qtest_end(); qtest_end();
} }
@ -255,8 +255,8 @@ static void test_abstract_interfaces(void)
g_assert(qdict_haskey(d, "abstract") && qdict_get_bool(d, "abstract")); g_assert(qdict_haskey(d, "abstract") && qdict_get_bool(d, "abstract"));
} }
QDECREF(all_types); qobject_unref(all_types);
QDECREF(index); qobject_unref(index);
qtest_end(); qtest_end();
} }

4
tests/drive_del-test.c
View File

@ -41,7 +41,7 @@ static void device_del(void)
response = qmp_receive(); response = qmp_receive();
g_assert(response); g_assert(response);
g_assert(qdict_haskey(response, "return")); g_assert(qdict_haskey(response, "return"));
QDECREF(response); qobject_unref(response);
} }
static void test_drive_without_dev(void) static void test_drive_without_dev(void)
@ -78,7 +78,7 @@ static void test_after_failed_device_add(void)
g_assert(response); g_assert(response);
error = qdict_get_qdict(response, "error"); error = qdict_get_qdict(response, "error");
g_assert_cmpstr(qdict_get_try_str(error, "class"), ==, "GenericError"); g_assert_cmpstr(qdict_get_try_str(error, "class"), ==, "GenericError");
QDECREF(response); qobject_unref(response);
/* Delete the drive */ /* Delete the drive */
drive_del(); drive_del();

8
tests/libqos/libqos.c
View File

@ -100,14 +100,14 @@ void migrate(QOSState *from, QOSState *to, const char *uri)
sub = qdict_get_qdict(rsp, "return"); sub = qdict_get_qdict(rsp, "return");
g_assert(qdict_haskey(sub, "running")); g_assert(qdict_haskey(sub, "running"));
running = qdict_get_bool(sub, "running"); running = qdict_get_bool(sub, "running");
QDECREF(rsp); qobject_unref(rsp);
/* Issue the migrate command. */ /* Issue the migrate command. */
rsp = qtest_qmp(from->qts, rsp = qtest_qmp(from->qts,
"{ 'execute': 'migrate', 'arguments': { 'uri': %s }}", "{ 'execute': 'migrate', 'arguments': { 'uri': %s }}",
uri); uri);
g_assert(qdict_haskey(rsp, "return")); g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp); qobject_unref(rsp);
/* Wait for STOP event, but only if we were running: */ /* Wait for STOP event, but only if we were running: */
if (running) { if (running) {
@ -132,12 +132,12 @@ void migrate(QOSState *from, QOSState *to, const char *uri)
/* "setup", "active", "completed", "failed", "cancelled" */ /* "setup", "active", "completed", "failed", "cancelled" */
if (strcmp(st, "completed") == 0) { if (strcmp(st, "completed") == 0) {
QDECREF(rsp); qobject_unref(rsp);
break; break;
} }
if ((strcmp(st, "setup") == 0) || (strcmp(st, "active") == 0)) { if ((strcmp(st, "setup") == 0) || (strcmp(st, "active") == 0)) {
QDECREF(rsp); qobject_unref(rsp);
g_usleep(5000); g_usleep(5000);
continue; continue;
} }

2
tests/libqos/pci-pc.c
View File

@ -170,7 +170,7 @@ void qpci_unplug_acpi_device_test(const char *id, uint8_t slot)
g_free(cmd); g_free(cmd);
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
outb(ACPI_PCIHP_ADDR + PCI_EJ_BASE, 1 << slot); outb(ACPI_PCIHP_ADDR + PCI_EJ_BASE, 1 << slot);

24
tests/libqtest.c
View File

@ -517,8 +517,8 @@ void qmp_fd_sendv(int fd, const char *fmt, va_list ap)
/* Send QMP request */ /* Send QMP request */
socket_send(fd, str, qstring_get_length(qstr)); socket_send(fd, str, qstring_get_length(qstr));
QDECREF(qstr); qobject_unref(qstr);
qobject_decref(qobj); qobject_unref(qobj);
} }
} }
@ -585,7 +585,7 @@ void qtest_async_qmp(QTestState *s, const char *fmt, ...)
void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap) void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap)
{ {
QDict *response = qtest_qmpv(s, fmt, ap); QDict *response = qtest_qmpv(s, fmt, ap);
QDECREF(response); qobject_unref(response);
} }
void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...) void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...)
@ -596,7 +596,7 @@ void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...)
va_start(ap, fmt); va_start(ap, fmt);
response = qtest_qmpv(s, fmt, ap); response = qtest_qmpv(s, fmt, ap);
va_end(ap); va_end(ap);
QDECREF(response); qobject_unref(response);
} }
QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event) QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
@ -609,7 +609,7 @@ QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
(strcmp(qdict_get_str(response, "event"), event) == 0)) { (strcmp(qdict_get_str(response, "event"), event) == 0)) {
return response; return response;
} }
QDECREF(response); qobject_unref(response);
} }
} }
@ -618,7 +618,7 @@ void qtest_qmp_eventwait(QTestState *s, const char *event)
QDict *response; QDict *response;
response = qtest_qmp_eventwait_ref(s, event); response = qtest_qmp_eventwait_ref(s, event);
QDECREF(response); qobject_unref(response);
} }
char *qtest_hmpv(QTestState *s, const char *fmt, va_list ap) char *qtest_hmpv(QTestState *s, const char *fmt, va_list ap)
@ -634,12 +634,12 @@ char *qtest_hmpv(QTestState *s, const char *fmt, va_list ap)
ret = g_strdup(qdict_get_try_str(resp, "return")); ret = g_strdup(qdict_get_try_str(resp, "return"));
while (ret == NULL && qdict_get_try_str(resp, "event")) { while (ret == NULL && qdict_get_try_str(resp, "event")) {
/* Ignore asynchronous QMP events */ /* Ignore asynchronous QMP events */
QDECREF(resp); qobject_unref(resp);
resp = qtest_qmp_receive(s); resp = qtest_qmp_receive(s);
ret = g_strdup(qdict_get_try_str(resp, "return")); ret = g_strdup(qdict_get_try_str(resp, "return"));
} }
g_assert(ret); g_assert(ret);
QDECREF(resp); qobject_unref(resp);
g_free(cmd); g_free(cmd);
return ret; return ret;
} }
@ -1021,7 +1021,7 @@ void qtest_cb_for_every_machine(void (*cb)(const char *machine))
} }
qtest_end(); qtest_end();
QDECREF(response); qobject_unref(response);
} }
/* /*
@ -1050,7 +1050,7 @@ void qtest_qmp_device_add(const char *driver, const char *id, const char *fmt,
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */ g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
} }
/* /*
@ -1095,6 +1095,6 @@ void qtest_qmp_device_del(const char *id)
g_assert(event); g_assert(event);
g_assert_cmpstr(qdict_get_str(event, "event"), ==, "DEVICE_DELETED"); g_assert_cmpstr(qdict_get_str(event, "event"), ==, "DEVICE_DELETED");
QDECREF(response1); qobject_unref(response1);
QDECREF(response2); qobject_unref(response2);
} }

2
tests/machine-none-test.c
View File

@ -88,7 +88,7 @@ static void test_machine_cpu_cli(void)
response = qmp("{ 'execute': 'quit' }"); response = qmp("{ 'execute': 'quit' }");
g_assert(qdict_haskey(response, "return")); g_assert(qdict_haskey(response, "return"));
QDECREF(response); qobject_unref(response);
qtest_quit(global_qtest); qtest_quit(global_qtest);
} }

26
tests/migration-test.c
View File

@ -195,7 +195,7 @@ static QDict *wait_command(QTestState *who, const char *command)
if (!strcmp(event_string, "STOP")) { if (!strcmp(event_string, "STOP")) {
got_stop = true; got_stop = true;
} }
QDECREF(response); qobject_unref(response);
response = qtest_qmp_receive(who); response = qtest_qmp_receive(who);
} }
return response; return response;
@ -221,7 +221,7 @@ static uint64_t get_migration_pass(QTestState *who)
rsp_ram = qdict_get_qdict(rsp_return, "ram"); rsp_ram = qdict_get_qdict(rsp_return, "ram");
result = qdict_get_try_int(rsp_ram, "dirty-sync-count", 0); result = qdict_get_try_int(rsp_ram, "dirty-sync-count", 0);
} }
QDECREF(rsp); qobject_unref(rsp);
return result; return result;
} }
@ -232,7 +232,7 @@ static void read_blocktime(QTestState *who)
rsp = wait_command(who, "{ 'execute': 'query-migrate' }"); rsp = wait_command(who, "{ 'execute': 'query-migrate' }");
rsp_return = qdict_get_qdict(rsp, "return"); rsp_return = qdict_get_qdict(rsp, "return");
g_assert(qdict_haskey(rsp_return, "postcopy-blocktime")); g_assert(qdict_haskey(rsp_return, "postcopy-blocktime"));
QDECREF(rsp); qobject_unref(rsp);
} }
static void wait_for_migration_complete(QTestState *who) static void wait_for_migration_complete(QTestState *who)
@ -247,7 +247,7 @@ static void wait_for_migration_complete(QTestState *who)
status = qdict_get_str(rsp_return, "status"); status = qdict_get_str(rsp_return, "status");
completed = strcmp(status, "completed") == 0; completed = strcmp(status, "completed") == 0;
g_assert_cmpstr(status, !=, "failed"); g_assert_cmpstr(status, !=, "failed");
QDECREF(rsp); qobject_unref(rsp);
if (completed) { if (completed) {
return; return;
} }
@ -334,7 +334,7 @@ static void migrate_check_parameter(QTestState *who, const char *parameter,
qdict_get_try_int(rsp_return, parameter, -1)); qdict_get_try_int(rsp_return, parameter, -1));
g_assert_cmpstr(result, ==, value); g_assert_cmpstr(result, ==, value);
g_free(result); g_free(result);
QDECREF(rsp); qobject_unref(rsp);
} }
static void migrate_set_parameter(QTestState *who, const char *parameter, static void migrate_set_parameter(QTestState *who, const char *parameter,
@ -349,7 +349,7 @@ static void migrate_set_parameter(QTestState *who, const char *parameter,
rsp = qtest_qmp(who, cmd); rsp = qtest_qmp(who, cmd);
g_free(cmd); g_free(cmd);
g_assert(qdict_haskey(rsp, "return")); g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp); qobject_unref(rsp);
migrate_check_parameter(who, parameter, value); migrate_check_parameter(who, parameter, value);
} }
@ -367,7 +367,7 @@ static void migrate_set_capability(QTestState *who, const char *capability,
rsp = qtest_qmp(who, cmd); rsp = qtest_qmp(who, cmd);
g_free(cmd); g_free(cmd);
g_assert(qdict_haskey(rsp, "return")); g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp); qobject_unref(rsp);
} }
static void migrate(QTestState *who, const char *uri) static void migrate(QTestState *who, const char *uri)
@ -381,7 +381,7 @@ static void migrate(QTestState *who, const char *uri)
rsp = qtest_qmp(who, cmd); rsp = qtest_qmp(who, cmd);
g_free(cmd); g_free(cmd);
g_assert(qdict_haskey(rsp, "return")); g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp); qobject_unref(rsp);
} }
static void migrate_start_postcopy(QTestState *who) static void migrate_start_postcopy(QTestState *who)
@ -390,7 +390,7 @@ static void migrate_start_postcopy(QTestState *who)
rsp = wait_command(who, "{ 'execute': 'migrate-start-postcopy' }"); rsp = wait_command(who, "{ 'execute': 'migrate-start-postcopy' }");
g_assert(qdict_haskey(rsp, "return")); g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp); qobject_unref(rsp);
} }
static void test_migrate_start(QTestState **from, QTestState **to, static void test_migrate_start(QTestState **from, QTestState **to,
@ -503,7 +503,7 @@ static void deprecated_set_downtime(QTestState *who, const double value)
rsp = qtest_qmp(who, cmd); rsp = qtest_qmp(who, cmd);
g_free(cmd); g_free(cmd);
g_assert(qdict_haskey(rsp, "return")); g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp); qobject_unref(rsp);
result_int = value * 1000L; result_int = value * 1000L;
expected = g_strdup_printf("%" PRId64, result_int); expected = g_strdup_printf("%" PRId64, result_int);
migrate_check_parameter(who, "downtime-limit", expected); migrate_check_parameter(who, "downtime-limit", expected);
@ -520,7 +520,7 @@ static void deprecated_set_speed(QTestState *who, const char *value)
rsp = qtest_qmp(who, cmd); rsp = qtest_qmp(who, cmd);
g_free(cmd); g_free(cmd);
g_assert(qdict_haskey(rsp, "return")); g_assert(qdict_haskey(rsp, "return"));
QDECREF(rsp); qobject_unref(rsp);
migrate_check_parameter(who, "max-bandwidth", value); migrate_check_parameter(who, "max-bandwidth", value);
} }
@ -597,7 +597,7 @@ static void test_baddest(void)
g_assert(!strcmp(status, "setup") || !(strcmp(status, "failed"))); g_assert(!strcmp(status, "setup") || !(strcmp(status, "failed")));
failed = !strcmp(status, "failed"); failed = !strcmp(status, "failed");
QDECREF(rsp); qobject_unref(rsp);
} while (!failed); } while (!failed);
/* Is the machine currently running? */ /* Is the machine currently running? */
@ -606,7 +606,7 @@ static void test_baddest(void)
rsp_return = qdict_get_qdict(rsp, "return"); rsp_return = qdict_get_qdict(rsp, "return");
g_assert(qdict_haskey(rsp_return, "running")); g_assert(qdict_haskey(rsp_return, "running"));
g_assert(qdict_get_bool(rsp_return, "running")); g_assert(qdict_get_bool(rsp_return, "running"));
QDECREF(rsp); qobject_unref(rsp);
test_migrate_end(from, to, false); test_migrate_end(from, to, false);
} }

16
tests/numa-test.c
View File

@ -111,10 +111,10 @@ static void test_query_cpus(const void *data)
} else { } else {
g_assert_cmpint(node, ==, 1); g_assert_cmpint(node, ==, 1);
} }
qobject_decref(e); qobject_unref(e);
} }
QDECREF(resp); qobject_unref(resp);
qtest_end(); qtest_end();
g_free(cli); g_free(cli);
} }
@ -164,10 +164,10 @@ static void pc_numa_cpu(const void *data)
} else { } else {
g_assert(false); g_assert(false);
} }
qobject_decref(e); qobject_unref(e);
} }
QDECREF(resp); qobject_unref(resp);
qtest_end(); qtest_end();
g_free(cli); g_free(cli);
} }
@ -209,10 +209,10 @@ static void spapr_numa_cpu(const void *data)
} else { } else {
g_assert(false); g_assert(false);
} }
qobject_decref(e); qobject_unref(e);
} }
QDECREF(resp); qobject_unref(resp);
qtest_end(); qtest_end();
g_free(cli); g_free(cli);
} }
@ -252,10 +252,10 @@ static void aarch64_numa_cpu(const void *data)
} else { } else {
g_assert(false); g_assert(false);
} }
qobject_decref(e); qobject_unref(e);
} }
QDECREF(resp); qobject_unref(resp);
qtest_end(); qtest_end();
g_free(cli); g_free(cli);
} }

2
tests/pvpanic-test.c
View File

@ -28,7 +28,7 @@ static void test_panic(void)
data = qdict_get_qdict(response, "data"); data = qdict_get_qdict(response, "data");
g_assert(qdict_haskey(data, "action")); g_assert(qdict_haskey(data, "action"));
g_assert_cmpstr(qdict_get_str(data, "action"), ==, "pause"); g_assert_cmpstr(qdict_get_str(data, "action"), ==, "pause");
QDECREF(response); qobject_unref(response);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

2
tests/q35-test.c
View File

@ -109,7 +109,7 @@ static void test_smram_lock(void)
response = qmp("{'execute': 'system_reset', 'arguments': {} }"); response = qmp("{'execute': 'system_reset', 'arguments': {} }");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
/* check open is settable again */ /* check open is settable again */
smram_set_bit(pcidev, MCH_HOST_BRIDGE_SMRAM_D_OPEN, false); smram_set_bit(pcidev, MCH_HOST_BRIDGE_SMRAM_D_OPEN, false);

38
tests/qmp-test.c
View File

@ -52,27 +52,27 @@ static void test_malformed(QTestState *qts)
/* Not even a dictionary */ /* Not even a dictionary */
resp = qtest_qmp(qts, "null"); resp = qtest_qmp(qts, "null");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError"); g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
QDECREF(resp); qobject_unref(resp);
/* No "execute" key */ /* No "execute" key */
resp = qtest_qmp(qts, "{}"); resp = qtest_qmp(qts, "{}");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError"); g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
QDECREF(resp); qobject_unref(resp);
/* "execute" isn't a string */ /* "execute" isn't a string */
resp = qtest_qmp(qts, "{ 'execute': true }"); resp = qtest_qmp(qts, "{ 'execute': true }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError"); g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
QDECREF(resp); qobject_unref(resp);
/* "arguments" isn't a dictionary */ /* "arguments" isn't a dictionary */
resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'arguments': [] }"); resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'arguments': [] }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError"); g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
QDECREF(resp); qobject_unref(resp);
/* extra key */ /* extra key */
resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'extra': true }"); resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'extra': true }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError"); g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
QDECREF(resp); qobject_unref(resp);
} }
static void test_qmp_protocol(void) static void test_qmp_protocol(void)
@ -90,12 +90,12 @@ static void test_qmp_protocol(void)
test_version(qdict_get(q, "version")); test_version(qdict_get(q, "version"));
capabilities = qdict_get_qlist(q, "capabilities"); capabilities = qdict_get_qlist(q, "capabilities");
g_assert(capabilities && qlist_empty(capabilities)); g_assert(capabilities && qlist_empty(capabilities));
QDECREF(resp); qobject_unref(resp);
/* Test valid command before handshake */ /* Test valid command before handshake */
resp = qtest_qmp(qts, "{ 'execute': 'query-version' }"); resp = qtest_qmp(qts, "{ 'execute': 'query-version' }");
g_assert_cmpstr(get_error_class(resp), ==, "CommandNotFound"); g_assert_cmpstr(get_error_class(resp), ==, "CommandNotFound");
QDECREF(resp); qobject_unref(resp);
/* Test malformed commands before handshake */ /* Test malformed commands before handshake */
test_malformed(qts); test_malformed(qts);
@ -104,17 +104,17 @@ static void test_qmp_protocol(void)
resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }"); resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }");
ret = qdict_get_qdict(resp, "return"); ret = qdict_get_qdict(resp, "return");
g_assert(ret && !qdict_size(ret)); g_assert(ret && !qdict_size(ret));
QDECREF(resp); qobject_unref(resp);
/* Test repeated handshake */ /* Test repeated handshake */
resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }"); resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }");
g_assert_cmpstr(get_error_class(resp), ==, "CommandNotFound"); g_assert_cmpstr(get_error_class(resp), ==, "CommandNotFound");
QDECREF(resp); qobject_unref(resp);
/* Test valid command */ /* Test valid command */
resp = qtest_qmp(qts, "{ 'execute': 'query-version' }"); resp = qtest_qmp(qts, "{ 'execute': 'query-version' }");
test_version(qdict_get(resp, "return")); test_version(qdict_get(resp, "return"));
QDECREF(resp); qobject_unref(resp);
/* Test malformed commands */ /* Test malformed commands */
test_malformed(qts); test_malformed(qts);
@ -124,13 +124,13 @@ static void test_qmp_protocol(void)
ret = qdict_get_qdict(resp, "return"); ret = qdict_get_qdict(resp, "return");
g_assert(ret); g_assert(ret);
g_assert_cmpstr(qdict_get_try_str(resp, "id"), ==, "cookie#1"); g_assert_cmpstr(qdict_get_try_str(resp, "id"), ==, "cookie#1");
QDECREF(resp); qobject_unref(resp);
/* Test command failure with 'id' */ /* Test command failure with 'id' */
resp = qtest_qmp(qts, "{ 'execute': 'human-monitor-command', 'id': 2 }"); resp = qtest_qmp(qts, "{ 'execute': 'human-monitor-command', 'id': 2 }");
g_assert_cmpstr(get_error_class(resp), ==, "GenericError"); g_assert_cmpstr(get_error_class(resp), ==, "GenericError");
g_assert_cmpint(qdict_get_int(resp, "id"), ==, 2); g_assert_cmpint(qdict_get_int(resp, "id"), ==, 2);
QDECREF(resp); qobject_unref(resp);
qtest_quit(qts); qtest_quit(qts);
} }
@ -159,21 +159,21 @@ static void test_qmp_oob(void)
qstr = qobject_to(QString, entry->value); qstr = qobject_to(QString, entry->value);
g_assert(qstr); g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, "oob"); g_assert_cmpstr(qstring_get_str(qstr), ==, "oob");
QDECREF(resp); qobject_unref(resp);
/* Try a fake capability, it should fail. */ /* Try a fake capability, it should fail. */
resp = qtest_qmp(qts, resp = qtest_qmp(qts,
"{ 'execute': 'qmp_capabilities', " "{ 'execute': 'qmp_capabilities', "
" 'arguments': { 'enable': [ 'cap-does-not-exist' ] } }"); " 'arguments': { 'enable': [ 'cap-does-not-exist' ] } }");
g_assert(qdict_haskey(resp, "error")); g_assert(qdict_haskey(resp, "error"));
QDECREF(resp); qobject_unref(resp);
/* Now, enable OOB in current QMP session, it should succeed. */ /* Now, enable OOB in current QMP session, it should succeed. */
resp = qtest_qmp(qts, resp = qtest_qmp(qts,
"{ 'execute': 'qmp_capabilities', " "{ 'execute': 'qmp_capabilities', "
" 'arguments': { 'enable': [ 'oob' ] } }"); " 'arguments': { 'enable': [ 'oob' ] } }");
g_assert(qdict_haskey(resp, "return")); g_assert(qdict_haskey(resp, "return"));
QDECREF(resp); qobject_unref(resp);
/* /*
* Try any command that does not support OOB but with OOB flag. We * Try any command that does not support OOB but with OOB flag. We
@ -183,7 +183,7 @@ static void test_qmp_oob(void)
"{ 'execute': 'query-cpus'," "{ 'execute': 'query-cpus',"
" 'control': { 'run-oob': true } }"); " 'control': { 'run-oob': true } }");
g_assert(qdict_haskey(resp, "error")); g_assert(qdict_haskey(resp, "error"));
QDECREF(resp); qobject_unref(resp);
/* /*
* First send the "x-oob-test" command with lock=true and * First send the "x-oob-test" command with lock=true and
@ -210,7 +210,7 @@ static void test_qmp_oob(void)
!g_strcmp0(cmd_id, "unlock-cmd")) { !g_strcmp0(cmd_id, "unlock-cmd")) {
acks++; acks++;
} }
QDECREF(resp); qobject_unref(resp);
} }
qtest_quit(qts); qtest_quit(qts);
@ -271,7 +271,7 @@ static void test_query(const void *data)
-1, &error_abort), -1, &error_abort),
==, expected_error_class); ==, expected_error_class);
} }
QDECREF(resp); qobject_unref(resp);
qtest_end(); qtest_end();
} }
@ -321,7 +321,7 @@ static void qmp_schema_init(QmpSchema *schema)
visit_type_SchemaInfoList(qiv, NULL, &schema->list, &error_abort); visit_type_SchemaInfoList(qiv, NULL, &schema->list, &error_abort);
visit_free(qiv); visit_free(qiv);
QDECREF(resp); qobject_unref(resp);
qtest_end(); qtest_end();
schema->hash = g_hash_table_new(g_str_hash, g_str_equal); schema->hash = g_hash_table_new(g_str_hash, g_str_equal);

8
tests/qom-test.c
View File

@ -57,7 +57,7 @@ static void test_properties(const char *path, bool recurse)
g_assert(response); g_assert(response);
if (!recurse) { if (!recurse) {
QDECREF(response); qobject_unref(response);
return; return;
} }
@ -82,10 +82,10 @@ static void test_properties(const char *path, bool recurse)
path, prop); path, prop);
/* qom-get may fail but should not, e.g., segfault. */ /* qom-get may fail but should not, e.g., segfault. */
g_assert(tmp); g_assert(tmp);
QDECREF(tmp); qobject_unref(tmp);
} }
} }
QDECREF(response); qobject_unref(response);
} }
static void test_machine(gconstpointer data) static void test_machine(gconstpointer data)
@ -101,7 +101,7 @@ static void test_machine(gconstpointer data)
response = qmp("{ 'execute': 'quit' }"); response = qmp("{ 'execute': 'quit' }");
g_assert(qdict_haskey(response, "return")); g_assert(qdict_haskey(response, "return"));
QDECREF(response); qobject_unref(response);
qtest_end(); qtest_end();
g_free(args); g_free(args);

12
tests/tco-test.c
View File

@ -241,8 +241,8 @@ static QDict *get_watchdog_action(void)
QDict *data; QDict *data;
data = qdict_get_qdict(ev, "data"); data = qdict_get_qdict(ev, "data");
QINCREF(data); qobject_ref(data);
QDECREF(ev); qobject_unref(ev);
return data; return data;
} }
@ -265,7 +265,7 @@ static void test_tco_second_timeout_pause(void)
clock_step(ticks * TCO_TICK_NSEC * 2); clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action(); ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "pause")); g_assert(!strcmp(qdict_get_str(ad, "action"), "pause"));
QDECREF(ad); qobject_unref(ad);
stop_tco(&td); stop_tco(&td);
test_end(&td); test_end(&td);
@ -290,7 +290,7 @@ static void test_tco_second_timeout_reset(void)
clock_step(ticks * TCO_TICK_NSEC * 2); clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action(); ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "reset")); g_assert(!strcmp(qdict_get_str(ad, "action"), "reset"));
QDECREF(ad); qobject_unref(ad);
stop_tco(&td); stop_tco(&td);
test_end(&td); test_end(&td);
@ -315,7 +315,7 @@ static void test_tco_second_timeout_shutdown(void)
clock_step(ticks * TCO_TICK_NSEC * 2); clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action(); ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "shutdown")); g_assert(!strcmp(qdict_get_str(ad, "action"), "shutdown"));
QDECREF(ad); qobject_unref(ad);
stop_tco(&td); stop_tco(&td);
test_end(&td); test_end(&td);
@ -340,7 +340,7 @@ static void test_tco_second_timeout_none(void)
clock_step(ticks * TCO_TICK_NSEC * 2); clock_step(ticks * TCO_TICK_NSEC * 2);
ad = get_watchdog_action(); ad = get_watchdog_action();
g_assert(!strcmp(qdict_get_str(ad, "action"), "none")); g_assert(!strcmp(qdict_get_str(ad, "action"), "none"));
QDECREF(ad); qobject_unref(ad);
stop_tco(&td); stop_tco(&td);
test_end(&td); test_end(&td);

2
tests/test-char.c
View File

@ -322,7 +322,7 @@ static void char_socket_test_common(Chardev *chr)
qdict = qobject_to(QDict, addr); qdict = qobject_to(QDict, addr);
port = qdict_get_str(qdict, "port"); port = qdict_get_str(qdict, "port");
tmp = g_strdup_printf("tcp:127.0.0.1:%s", port); tmp = g_strdup_printf("tcp:127.0.0.1:%s", port);
QDECREF(qdict); qobject_unref(qdict);
qemu_chr_fe_init(&be, chr, &error_abort); qemu_chr_fe_init(&be, chr, &error_abort);
qemu_chr_fe_set_handlers(&be, socket_can_read, socket_read, qemu_chr_fe_set_handlers(&be, socket_can_read, socket_read,

82
tests/test-keyval.c
View File

@ -30,7 +30,7 @@ static void test_keyval_parse(void)
/* Nothing */ /* Nothing */
qdict = keyval_parse("", NULL, &error_abort); qdict = keyval_parse("", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 0); g_assert_cmpuint(qdict_size(qdict), ==, 0);
QDECREF(qdict); qobject_unref(qdict);
/* Empty key (qemu_opts_parse() accepts this) */ /* Empty key (qemu_opts_parse() accepts this) */
qdict = keyval_parse("=val", NULL, &err); qdict = keyval_parse("=val", NULL, &err);
@ -70,7 +70,7 @@ static void test_keyval_parse(void)
qdict = keyval_parse(params + 2, NULL, &error_abort); qdict = keyval_parse(params + 2, NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1); g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, long_key + 1), ==, "v"); g_assert_cmpstr(qdict_get_try_str(qdict, long_key + 1), ==, "v");
QDECREF(qdict); qobject_unref(qdict);
/* Long key fragment */ /* Long key fragment */
qdict = keyval_parse(params, NULL, &error_abort); qdict = keyval_parse(params, NULL, &error_abort);
@ -79,7 +79,7 @@ static void test_keyval_parse(void)
g_assert(sub_qdict); g_assert(sub_qdict);
g_assert_cmpuint(qdict_size(sub_qdict), ==, 1); g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(sub_qdict, long_key + 1), ==, "v"); g_assert_cmpstr(qdict_get_try_str(sub_qdict, long_key + 1), ==, "v");
QDECREF(qdict); qobject_unref(qdict);
g_free(params); g_free(params);
/* Crap after valid key */ /* Crap after valid key */
@ -92,13 +92,13 @@ static void test_keyval_parse(void)
g_assert_cmpuint(qdict_size(qdict), ==, 2); g_assert_cmpuint(qdict_size(qdict), ==, 2);
g_assert_cmpstr(qdict_get_try_str(qdict, "a"), ==, "3"); g_assert_cmpstr(qdict_get_try_str(qdict, "a"), ==, "3");
g_assert_cmpstr(qdict_get_try_str(qdict, "b"), ==, "2,x"); g_assert_cmpstr(qdict_get_try_str(qdict, "b"), ==, "2,x");
QDECREF(qdict); qobject_unref(qdict);
/* Even when it doesn't in qemu_opts_parse() */ /* Even when it doesn't in qemu_opts_parse() */
qdict = keyval_parse("id=foo,id=bar", NULL, &error_abort); qdict = keyval_parse("id=foo,id=bar", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1); g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "bar"); g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "bar");
QDECREF(qdict); qobject_unref(qdict);
/* Dotted keys */ /* Dotted keys */
qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort); qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
@ -111,7 +111,7 @@ static void test_keyval_parse(void)
g_assert_cmpuint(qdict_size(sub_qdict), ==, 1); g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(sub_qdict, "c"), ==, "2"); g_assert_cmpstr(qdict_get_try_str(sub_qdict, "c"), ==, "2");
g_assert_cmpstr(qdict_get_try_str(qdict, "d"), ==, "3"); g_assert_cmpstr(qdict_get_try_str(qdict, "d"), ==, "3");
QDECREF(qdict); qobject_unref(qdict);
/* Inconsistent dotted keys */ /* Inconsistent dotted keys */
qdict = keyval_parse("a.b=1,a=2", NULL, &err); qdict = keyval_parse("a.b=1,a=2", NULL, &err);
@ -125,7 +125,7 @@ static void test_keyval_parse(void)
qdict = keyval_parse("x=y,", NULL, &error_abort); qdict = keyval_parse("x=y,", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1); g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, "y"); g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, "y");
QDECREF(qdict); qobject_unref(qdict);
/* Except when it isn't */ /* Except when it isn't */
qdict = keyval_parse(",", NULL, &err); qdict = keyval_parse(",", NULL, &err);
@ -136,13 +136,13 @@ static void test_keyval_parse(void)
qdict = keyval_parse("x=,,id=bar", NULL, &error_abort); qdict = keyval_parse("x=,,id=bar", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1); g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, ",id=bar"); g_assert_cmpstr(qdict_get_try_str(qdict, "x"), ==, ",id=bar");
QDECREF(qdict); qobject_unref(qdict);
/* Anti-social ID is left to caller (qemu_opts_parse() rejects it) */ /* Anti-social ID is left to caller (qemu_opts_parse() rejects it) */
qdict = keyval_parse("id=666", NULL, &error_abort); qdict = keyval_parse("id=666", NULL, &error_abort);
g_assert_cmpuint(qdict_size(qdict), ==, 1); g_assert_cmpuint(qdict_size(qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "666"); g_assert_cmpstr(qdict_get_try_str(qdict, "id"), ==, "666");
QDECREF(qdict); qobject_unref(qdict);
/* Implied value not supported (unlike qemu_opts_parse()) */ /* Implied value not supported (unlike qemu_opts_parse()) */
qdict = keyval_parse("an,noaus,noaus=", NULL, &err); qdict = keyval_parse("an,noaus,noaus=", NULL, &err);
@ -160,7 +160,7 @@ static void test_keyval_parse(void)
g_assert_cmpstr(qdict_get_try_str(qdict, "implied"), ==, "an"); g_assert_cmpstr(qdict_get_try_str(qdict, "implied"), ==, "an");
g_assert_cmpstr(qdict_get_try_str(qdict, "aus"), ==, "off"); g_assert_cmpstr(qdict_get_try_str(qdict, "aus"), ==, "off");
g_assert_cmpstr(qdict_get_try_str(qdict, "noaus"), ==, ""); g_assert_cmpstr(qdict_get_try_str(qdict, "noaus"), ==, "");
QDECREF(qdict); qobject_unref(qdict);
/* Implied dotted key */ /* Implied dotted key */
qdict = keyval_parse("val", "eins.zwei", &error_abort); qdict = keyval_parse("val", "eins.zwei", &error_abort);
@ -169,7 +169,7 @@ static void test_keyval_parse(void)
g_assert(sub_qdict); g_assert(sub_qdict);
g_assert_cmpuint(qdict_size(sub_qdict), ==, 1); g_assert_cmpuint(qdict_size(sub_qdict), ==, 1);
g_assert_cmpstr(qdict_get_try_str(sub_qdict, "zwei"), ==, "val"); g_assert_cmpstr(qdict_get_try_str(sub_qdict, "zwei"), ==, "val");
QDECREF(qdict); qobject_unref(qdict);
/* Implied key with empty value (qemu_opts_parse() accepts this) */ /* Implied key with empty value (qemu_opts_parse() accepts this) */
qdict = keyval_parse(",", "implied", &err); qdict = keyval_parse(",", "implied", &err);
@ -198,7 +198,7 @@ static void check_list012(QList *qlist)
qstr = qobject_to(QString, qlist_pop(qlist)); qstr = qobject_to(QString, qlist_pop(qlist));
g_assert(qstr); g_assert(qstr);
g_assert_cmpstr(qstring_get_str(qstr), ==, expected[i]); g_assert_cmpstr(qstring_get_str(qstr), ==, expected[i]);
QDECREF(qstr); qobject_unref(qstr);
} }
g_assert(qlist_empty(qlist)); g_assert(qlist_empty(qlist));
} }
@ -218,14 +218,14 @@ static void test_keyval_parse_list(void)
NULL, &error_abort); NULL, &error_abort);
g_assert_cmpint(qdict_size(qdict), ==, 1); g_assert_cmpint(qdict_size(qdict), ==, 1);
check_list012(qdict_get_qlist(qdict, "list")); check_list012(qdict_get_qlist(qdict, "list"));
QDECREF(qdict); qobject_unref(qdict);
/* Multiple indexes, last one wins */ /* Multiple indexes, last one wins */
qdict = keyval_parse("list.1=goner,list.0=null,list.01=eins,list.2=zwei", qdict = keyval_parse("list.1=goner,list.0=null,list.01=eins,list.2=zwei",
NULL, &error_abort); NULL, &error_abort);
g_assert_cmpint(qdict_size(qdict), ==, 1); g_assert_cmpint(qdict_size(qdict), ==, 1);
check_list012(qdict_get_qlist(qdict, "list")); check_list012(qdict_get_qlist(qdict, "list"));
QDECREF(qdict); qobject_unref(qdict);
/* List at deeper nesting */ /* List at deeper nesting */
qdict = keyval_parse("a.list.1=eins,a.list.00=null,a.list.2=zwei", qdict = keyval_parse("a.list.1=eins,a.list.00=null,a.list.2=zwei",
@ -234,7 +234,7 @@ static void test_keyval_parse_list(void)
sub_qdict = qdict_get_qdict(qdict, "a"); sub_qdict = qdict_get_qdict(qdict, "a");
g_assert_cmpint(qdict_size(sub_qdict), ==, 1); g_assert_cmpint(qdict_size(sub_qdict), ==, 1);
check_list012(qdict_get_qlist(sub_qdict, "list")); check_list012(qdict_get_qlist(sub_qdict, "list"));
QDECREF(qdict); qobject_unref(qdict);
/* Inconsistent dotted keys: both list and dictionary */ /* Inconsistent dotted keys: both list and dictionary */
qdict = keyval_parse("a.b.c=1,a.b.0=2", NULL, &err); qdict = keyval_parse("a.b.c=1,a.b.0=2", NULL, &err);
@ -262,7 +262,7 @@ static void test_keyval_visit_bool(void)
qdict = keyval_parse("bool1=on,bool2=off", NULL, &error_abort); qdict = keyval_parse("bool1=on,bool2=off", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_bool(v, "bool1", &b, &error_abort); visit_type_bool(v, "bool1", &b, &error_abort);
g_assert(b); g_assert(b);
@ -274,7 +274,7 @@ static void test_keyval_visit_bool(void)
qdict = keyval_parse("bool1=offer", NULL, &error_abort); qdict = keyval_parse("bool1=offer", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_bool(v, "bool1", &b, &err); visit_type_bool(v, "bool1", &b, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
@ -292,7 +292,7 @@ static void test_keyval_visit_number(void)
/* Lower limit zero */ /* Lower limit zero */
qdict = keyval_parse("number1=0", NULL, &error_abort); qdict = keyval_parse("number1=0", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &error_abort); visit_type_uint64(v, "number1", &u, &error_abort);
g_assert_cmpuint(u, ==, 0); g_assert_cmpuint(u, ==, 0);
@ -304,7 +304,7 @@ static void test_keyval_visit_number(void)
qdict = keyval_parse("number1=18446744073709551615,number2=-1", qdict = keyval_parse("number1=18446744073709551615,number2=-1",
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &error_abort); visit_type_uint64(v, "number1", &u, &error_abort);
g_assert_cmphex(u, ==, UINT64_MAX); g_assert_cmphex(u, ==, UINT64_MAX);
@ -318,7 +318,7 @@ static void test_keyval_visit_number(void)
qdict = keyval_parse("number1=18446744073709551616", qdict = keyval_parse("number1=18446744073709551616",
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &err); visit_type_uint64(v, "number1", &u, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
@ -329,7 +329,7 @@ static void test_keyval_visit_number(void)
qdict = keyval_parse("number1=-18446744073709551616", qdict = keyval_parse("number1=-18446744073709551616",
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &err); visit_type_uint64(v, "number1", &u, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
@ -340,7 +340,7 @@ static void test_keyval_visit_number(void)
qdict = keyval_parse("number1=0x2a,number2=052", qdict = keyval_parse("number1=0x2a,number2=052",
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &error_abort); visit_type_uint64(v, "number1", &u, &error_abort);
g_assert_cmpuint(u, ==, 42); g_assert_cmpuint(u, ==, 42);
@ -354,7 +354,7 @@ static void test_keyval_visit_number(void)
qdict = keyval_parse("number1=3.14,number2=08", qdict = keyval_parse("number1=3.14,number2=08",
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_uint64(v, "number1", &u, &err); visit_type_uint64(v, "number1", &u, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
@ -374,7 +374,7 @@ static void test_keyval_visit_size(void)
/* Lower limit zero */ /* Lower limit zero */
qdict = keyval_parse("sz1=0", NULL, &error_abort); qdict = keyval_parse("sz1=0", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort); visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmpuint(sz, ==, 0); g_assert_cmpuint(sz, ==, 0);
@ -390,7 +390,7 @@ static void test_keyval_visit_size(void)
"sz3=9007199254740993", "sz3=9007199254740993",
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort); visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmphex(sz, ==, 0x1fffffffffffff); g_assert_cmphex(sz, ==, 0x1fffffffffffff);
@ -407,7 +407,7 @@ static void test_keyval_visit_size(void)
"sz2=9223372036854775295", /* 7ffffffffffffdff */ "sz2=9223372036854775295", /* 7ffffffffffffdff */
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort); visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmphex(sz, ==, 0x7ffffffffffffc00); g_assert_cmphex(sz, ==, 0x7ffffffffffffc00);
@ -422,7 +422,7 @@ static void test_keyval_visit_size(void)
"sz2=18446744073709550591", /* fffffffffffffbff */ "sz2=18446744073709550591", /* fffffffffffffbff */
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort); visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmphex(sz, ==, 0xfffffffffffff800); g_assert_cmphex(sz, ==, 0xfffffffffffff800);
@ -437,7 +437,7 @@ static void test_keyval_visit_size(void)
"sz2=18446744073709550592", /* fffffffffffffc00 */ "sz2=18446744073709550592", /* fffffffffffffc00 */
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &err); visit_type_size(v, "sz1", &sz, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
@ -450,7 +450,7 @@ static void test_keyval_visit_size(void)
qdict = keyval_parse("sz1=8b,sz2=1.5k,sz3=2M,sz4=0.1G,sz5=16777215T", qdict = keyval_parse("sz1=8b,sz2=1.5k,sz3=2M,sz4=0.1G,sz5=16777215T",
NULL, &error_abort); NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &error_abort); visit_type_size(v, "sz1", &sz, &error_abort);
g_assert_cmpuint(sz, ==, 8); g_assert_cmpuint(sz, ==, 8);
@ -469,7 +469,7 @@ static void test_keyval_visit_size(void)
/* Beyond limit with suffix */ /* Beyond limit with suffix */
qdict = keyval_parse("sz1=16777216T", NULL, &error_abort); qdict = keyval_parse("sz1=16777216T", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &err); visit_type_size(v, "sz1", &sz, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
@ -479,7 +479,7 @@ static void test_keyval_visit_size(void)
/* Trailing crap */ /* Trailing crap */
qdict = keyval_parse("sz1=16E,sz2=16Gi", NULL, &error_abort); qdict = keyval_parse("sz1=16E,sz2=16Gi", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_size(v, "sz1", &sz, &err); visit_type_size(v, "sz1", &sz, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
@ -498,7 +498,7 @@ static void test_keyval_visit_dict(void)
qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort); qdict = keyval_parse("a.b.c=1,a.b.c=2,d=3", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_struct(v, "a", NULL, 0, &error_abort); visit_start_struct(v, "a", NULL, 0, &error_abort);
visit_start_struct(v, "b", NULL, 0, &error_abort); visit_start_struct(v, "b", NULL, 0, &error_abort);
@ -516,7 +516,7 @@ static void test_keyval_visit_dict(void)
qdict = keyval_parse("a.b=", NULL, &error_abort); qdict = keyval_parse("a.b=", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_struct(v, "a", NULL, 0, &error_abort); visit_start_struct(v, "a", NULL, 0, &error_abort);
visit_type_int(v, "c", &i, &err); /* a.c missing */ visit_type_int(v, "c", &i, &err); /* a.c missing */
@ -539,7 +539,7 @@ static void test_keyval_visit_list(void)
qdict = keyval_parse("a.0=,a.1=I,a.2.0=II", NULL, &error_abort); qdict = keyval_parse("a.0=,a.1=I,a.2.0=II", NULL, &error_abort);
/* TODO empty list */ /* TODO empty list */
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_list(v, "a", NULL, 0, &error_abort); visit_start_list(v, "a", NULL, 0, &error_abort);
visit_type_str(v, NULL, &s, &error_abort); visit_type_str(v, NULL, &s, &error_abort);
@ -562,7 +562,7 @@ static void test_keyval_visit_list(void)
qdict = keyval_parse("a.0=,b.0.0=head", NULL, &error_abort); qdict = keyval_parse("a.0=,b.0.0=head", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_start_list(v, "a", NULL, 0, &error_abort); visit_start_list(v, "a", NULL, 0, &error_abort);
visit_check_list(v, &err); /* a[0] unexpected */ visit_check_list(v, &err); /* a[0] unexpected */
@ -591,7 +591,7 @@ static void test_keyval_visit_optional(void)
qdict = keyval_parse("a.b=1", NULL, &error_abort); qdict = keyval_parse("a.b=1", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_optional(v, "b", &present); visit_optional(v, "b", &present);
g_assert(!present); /* b missing */ g_assert(!present); /* b missing */
@ -627,7 +627,7 @@ static void test_keyval_visit_alternate(void)
*/ */
qdict = keyval_parse("a=1,b=2,c=on", NULL, &error_abort); qdict = keyval_parse("a=1,b=2,c=on", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_AltStrObj(v, "a", &aso, &error_abort); visit_type_AltStrObj(v, "a", &aso, &error_abort);
g_assert_cmpint(aso->type, ==, QTYPE_QSTRING); g_assert_cmpint(aso->type, ==, QTYPE_QSTRING);
@ -651,19 +651,19 @@ static void test_keyval_visit_any(void)
qdict = keyval_parse("a.0=null,a.1=1", NULL, &error_abort); qdict = keyval_parse("a.0=null,a.1=1", NULL, &error_abort);
v = qobject_input_visitor_new_keyval(QOBJECT(qdict)); v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
QDECREF(qdict); qobject_unref(qdict);
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_any(v, "a", &any, &error_abort); visit_type_any(v, "a", &any, &error_abort);
qlist = qobject_to(QList, any); qlist = qobject_to(QList, any);
g_assert(qlist); g_assert(qlist);
qstr = qobject_to(QString, qlist_pop(qlist)); qstr = qobject_to(QString, qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "null"); g_assert_cmpstr(qstring_get_str(qstr), ==, "null");
QDECREF(qstr); qobject_unref(qstr);
qstr = qobject_to(QString, qlist_pop(qlist)); qstr = qobject_to(QString, qlist_pop(qlist));
g_assert_cmpstr(qstring_get_str(qstr), ==, "1"); g_assert_cmpstr(qstring_get_str(qstr), ==, "1");
g_assert(qlist_empty(qlist)); g_assert(qlist_empty(qlist));
QDECREF(qstr); qobject_unref(qstr);
qobject_decref(any); qobject_unref(any);
visit_check_struct(v, &error_abort); visit_check_struct(v, &error_abort);
visit_end_struct(v, NULL); visit_end_struct(v, NULL);
visit_free(v); visit_free(v);

26
tests/test-netfilter.c
View File

@ -29,7 +29,7 @@ static void add_one_netfilter(void)
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
response = qmp("{'execute': 'object-del'," response = qmp("{'execute': 'object-del',"
" 'arguments': {" " 'arguments': {"
@ -37,7 +37,7 @@ static void add_one_netfilter(void)
"}}"); "}}");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
} }
/* add a netfilter to a netdev and then remove the netdev */ /* add a netfilter to a netdev and then remove the netdev */
@ -57,7 +57,7 @@ static void remove_netdev_with_one_netfilter(void)
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
response = qmp("{'execute': 'netdev_del'," response = qmp("{'execute': 'netdev_del',"
" 'arguments': {" " 'arguments': {"
@ -65,7 +65,7 @@ static void remove_netdev_with_one_netfilter(void)
"}}"); "}}");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
/* add back the netdev */ /* add back the netdev */
response = qmp("{'execute': 'netdev_add'," response = qmp("{'execute': 'netdev_add',"
@ -75,7 +75,7 @@ static void remove_netdev_with_one_netfilter(void)
"}}"); "}}");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
} }
/* add multi(2) netfilters to a netdev and then remove them */ /* add multi(2) netfilters to a netdev and then remove them */
@ -95,7 +95,7 @@ static void add_multi_netfilter(void)
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
response = qmp("{'execute': 'object-add'," response = qmp("{'execute': 'object-add',"
" 'arguments': {" " 'arguments': {"
@ -109,7 +109,7 @@ static void add_multi_netfilter(void)
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
response = qmp("{'execute': 'object-del'," response = qmp("{'execute': 'object-del',"
" 'arguments': {" " 'arguments': {"
@ -117,7 +117,7 @@ static void add_multi_netfilter(void)
"}}"); "}}");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
response = qmp("{'execute': 'object-del'," response = qmp("{'execute': 'object-del',"
" 'arguments': {" " 'arguments': {"
@ -125,7 +125,7 @@ static void add_multi_netfilter(void)
"}}"); "}}");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
} }
/* add multi(2) netfilters to a netdev and then remove the netdev */ /* add multi(2) netfilters to a netdev and then remove the netdev */
@ -145,7 +145,7 @@ static void remove_netdev_with_multi_netfilter(void)
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
response = qmp("{'execute': 'object-add'," response = qmp("{'execute': 'object-add',"
" 'arguments': {" " 'arguments': {"
@ -159,7 +159,7 @@ static void remove_netdev_with_multi_netfilter(void)
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
response = qmp("{'execute': 'netdev_del'," response = qmp("{'execute': 'netdev_del',"
" 'arguments': {" " 'arguments': {"
@ -167,7 +167,7 @@ static void remove_netdev_with_multi_netfilter(void)
"}}"); "}}");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
/* add back the netdev */ /* add back the netdev */
response = qmp("{'execute': 'netdev_add'," response = qmp("{'execute': 'netdev_add',"
@ -177,7 +177,7 @@ static void remove_netdev_with_multi_netfilter(void)
"}}"); "}}");
g_assert(response); g_assert(response);
g_assert(!qdict_haskey(response, "error")); g_assert(!qdict_haskey(response, "error"));
QDECREF(response); qobject_unref(response);
} }
int main(int argc, char **argv) int main(int argc, char **argv)

14
tests/test-qemu-opts.c
View File

@ -887,7 +887,7 @@ static void test_opts_to_qdict_basic(void)
g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42"); g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
g_assert_false(qdict_haskey(dict, "number2")); g_assert_false(qdict_haskey(dict, "number2"));
QDECREF(dict); qobject_unref(dict);
qemu_opts_del(opts); qemu_opts_del(opts);
} }
@ -914,7 +914,7 @@ static void test_opts_to_qdict_filtered(void)
g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42"); g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
g_assert_false(qdict_haskey(dict, "number2")); g_assert_false(qdict_haskey(dict, "number2"));
g_assert_false(qdict_haskey(dict, "bool1")); g_assert_false(qdict_haskey(dict, "bool1"));
QDECREF(dict); qobject_unref(dict);
dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, false); dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, false);
g_assert(dict != NULL); g_assert(dict != NULL);
@ -924,7 +924,7 @@ static void test_opts_to_qdict_filtered(void)
g_assert_false(qdict_haskey(dict, "str3")); g_assert_false(qdict_haskey(dict, "str3"));
g_assert_false(qdict_haskey(dict, "number1")); g_assert_false(qdict_haskey(dict, "number1"));
g_assert_false(qdict_haskey(dict, "number2")); g_assert_false(qdict_haskey(dict, "number2"));
QDECREF(dict); qobject_unref(dict);
/* Now delete converted options from opts */ /* Now delete converted options from opts */
dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, true); dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_01, true);
@ -935,7 +935,7 @@ static void test_opts_to_qdict_filtered(void)
g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42"); g_assert_cmpstr(qdict_get_str(dict, "number1"), ==, "42");
g_assert_false(qdict_haskey(dict, "number2")); g_assert_false(qdict_haskey(dict, "number2"));
g_assert_false(qdict_haskey(dict, "bool1")); g_assert_false(qdict_haskey(dict, "bool1"));
QDECREF(dict); qobject_unref(dict);
dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, true); dict = qemu_opts_to_qdict_filtered(opts, NULL, &opts_list_02, true);
g_assert(dict != NULL); g_assert(dict != NULL);
@ -945,7 +945,7 @@ static void test_opts_to_qdict_filtered(void)
g_assert_false(qdict_haskey(dict, "str3")); g_assert_false(qdict_haskey(dict, "str3"));
g_assert_false(qdict_haskey(dict, "number1")); g_assert_false(qdict_haskey(dict, "number1"));
g_assert_false(qdict_haskey(dict, "number2")); g_assert_false(qdict_haskey(dict, "number2"));
QDECREF(dict); qobject_unref(dict);
g_assert_true(QTAILQ_EMPTY(&opts->head)); g_assert_true(QTAILQ_EMPTY(&opts->head));
@ -978,13 +978,13 @@ static void test_opts_to_qdict_duplicates(void)
dict = qemu_opts_to_qdict(opts, NULL); dict = qemu_opts_to_qdict(opts, NULL);
g_assert(dict != NULL); g_assert(dict != NULL);
g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b"); g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
QDECREF(dict); qobject_unref(dict);
/* The last one still wins if entries are deleted, and both are deleted */ /* The last one still wins if entries are deleted, and both are deleted */
dict = qemu_opts_to_qdict_filtered(opts, NULL, NULL, true); dict = qemu_opts_to_qdict_filtered(opts, NULL, NULL, true);
g_assert(dict != NULL); g_assert(dict != NULL);
g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b"); g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "b");
QDECREF(dict); qobject_unref(dict);
g_assert_true(QTAILQ_EMPTY(&opts->head)); g_assert_true(QTAILQ_EMPTY(&opts->head));

76
tests/test-qga.c
View File

@ -180,7 +180,7 @@ static void test_qga_sync_delimited(gconstpointer fix)
v = qdict_get_int(ret, "return"); v = qdict_get_int(ret, "return");
g_assert_cmpint(r, ==, v); g_assert_cmpint(r, ==, v);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_sync(gconstpointer fix) static void test_qga_sync(gconstpointer fix)
@ -212,7 +212,7 @@ static void test_qga_sync(gconstpointer fix)
v = qdict_get_int(ret, "return"); v = qdict_get_int(ret, "return");
g_assert_cmpint(r, ==, v); g_assert_cmpint(r, ==, v);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_ping(gconstpointer fix) static void test_qga_ping(gconstpointer fix)
@ -224,7 +224,7 @@ static void test_qga_ping(gconstpointer fix)
g_assert_nonnull(ret); g_assert_nonnull(ret);
qmp_assert_no_error(ret); qmp_assert_no_error(ret);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_invalid_args(gconstpointer fix) static void test_qga_invalid_args(gconstpointer fix)
@ -244,7 +244,7 @@ static void test_qga_invalid_args(gconstpointer fix)
g_assert_cmpstr(class, ==, "GenericError"); g_assert_cmpstr(class, ==, "GenericError");
g_assert_cmpstr(desc, ==, "Parameter 'foo' is unexpected"); g_assert_cmpstr(desc, ==, "Parameter 'foo' is unexpected");
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_invalid_cmd(gconstpointer fix) static void test_qga_invalid_cmd(gconstpointer fix)
@ -263,7 +263,7 @@ static void test_qga_invalid_cmd(gconstpointer fix)
g_assert_cmpstr(class, ==, "CommandNotFound"); g_assert_cmpstr(class, ==, "CommandNotFound");
g_assert_cmpint(strlen(desc), >, 0); g_assert_cmpint(strlen(desc), >, 0);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_info(gconstpointer fix) static void test_qga_info(gconstpointer fix)
@ -280,7 +280,7 @@ static void test_qga_info(gconstpointer fix)
version = qdict_get_try_str(val, "version"); version = qdict_get_try_str(val, "version");
g_assert_cmpstr(version, ==, QEMU_VERSION); g_assert_cmpstr(version, ==, QEMU_VERSION);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_get_vcpus(gconstpointer fix) static void test_qga_get_vcpus(gconstpointer fix)
@ -300,7 +300,7 @@ static void test_qga_get_vcpus(gconstpointer fix)
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online")); g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "logical-id")); g_assert(qdict_haskey(qobject_to(QDict, entry->value), "logical-id"));
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_get_fsinfo(gconstpointer fix) static void test_qga_get_fsinfo(gconstpointer fix)
@ -324,7 +324,7 @@ static void test_qga_get_fsinfo(gconstpointer fix)
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "disk")); g_assert(qdict_haskey(qobject_to(QDict, entry->value), "disk"));
} }
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_get_memory_block_info(gconstpointer fix) static void test_qga_get_memory_block_info(gconstpointer fix)
@ -344,7 +344,7 @@ static void test_qga_get_memory_block_info(gconstpointer fix)
g_assert_cmpint(size, >, 0); g_assert_cmpint(size, >, 0);
} }
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_get_memory_blocks(gconstpointer fix) static void test_qga_get_memory_blocks(gconstpointer fix)
@ -369,7 +369,7 @@ static void test_qga_get_memory_blocks(gconstpointer fix)
} }
} }
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_network_get_interfaces(gconstpointer fix) static void test_qga_network_get_interfaces(gconstpointer fix)
@ -388,7 +388,7 @@ static void test_qga_network_get_interfaces(gconstpointer fix)
entry = qlist_first(list); entry = qlist_first(list);
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name")); g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_file_ops(gconstpointer fix) static void test_qga_file_ops(gconstpointer fix)
@ -410,7 +410,7 @@ static void test_qga_file_ops(gconstpointer fix)
g_assert_nonnull(ret); g_assert_nonnull(ret);
qmp_assert_no_error(ret); qmp_assert_no_error(ret);
id = qdict_get_int(ret, "return"); id = qdict_get_int(ret, "return");
QDECREF(ret); qobject_unref(ret);
enc = g_base64_encode(helloworld, sizeof(helloworld)); enc = g_base64_encode(helloworld, sizeof(helloworld));
/* write */ /* write */
@ -426,7 +426,7 @@ static void test_qga_file_ops(gconstpointer fix)
eof = qdict_get_bool(val, "eof"); eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, sizeof(helloworld)); g_assert_cmpint(count, ==, sizeof(helloworld));
g_assert_cmpint(eof, ==, 0); g_assert_cmpint(eof, ==, 0);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* flush */ /* flush */
@ -434,7 +434,7 @@ static void test_qga_file_ops(gconstpointer fix)
" 'arguments': {'handle': %" PRId64 "} }", " 'arguments': {'handle': %" PRId64 "} }",
id); id);
ret = qmp_fd(fixture->fd, cmd); ret = qmp_fd(fixture->fd, cmd);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* close */ /* close */
@ -442,7 +442,7 @@ static void test_qga_file_ops(gconstpointer fix)
" 'arguments': {'handle': %" PRId64 "} }", " 'arguments': {'handle': %" PRId64 "} }",
id); id);
ret = qmp_fd(fixture->fd, cmd); ret = qmp_fd(fixture->fd, cmd);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* check content */ /* check content */
@ -462,7 +462,7 @@ static void test_qga_file_ops(gconstpointer fix)
g_assert_nonnull(ret); g_assert_nonnull(ret);
qmp_assert_no_error(ret); qmp_assert_no_error(ret);
id = qdict_get_int(ret, "return"); id = qdict_get_int(ret, "return");
QDECREF(ret); qobject_unref(ret);
/* read */ /* read */
cmd = g_strdup_printf("{'execute': 'guest-file-read'," cmd = g_strdup_printf("{'execute': 'guest-file-read',"
@ -477,7 +477,7 @@ static void test_qga_file_ops(gconstpointer fix)
g_assert(eof); g_assert(eof);
g_assert_cmpstr(b64, ==, enc); g_assert_cmpstr(b64, ==, enc);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
g_free(enc); g_free(enc);
@ -493,7 +493,7 @@ static void test_qga_file_ops(gconstpointer fix)
g_assert_cmpint(count, ==, 0); g_assert_cmpint(count, ==, 0);
g_assert(eof); g_assert(eof);
g_assert_cmpstr(b64, ==, ""); g_assert_cmpstr(b64, ==, "");
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* seek */ /* seek */
@ -508,7 +508,7 @@ static void test_qga_file_ops(gconstpointer fix)
eof = qdict_get_bool(val, "eof"); eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, 6); g_assert_cmpint(count, ==, 6);
g_assert(!eof); g_assert(!eof);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* partial read */ /* partial read */
@ -527,7 +527,7 @@ static void test_qga_file_ops(gconstpointer fix)
g_assert_cmpmem(dec, count, helloworld + 6, sizeof(helloworld) - 6); g_assert_cmpmem(dec, count, helloworld + 6, sizeof(helloworld) - 6);
g_free(dec); g_free(dec);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* close */ /* close */
@ -535,7 +535,7 @@ static void test_qga_file_ops(gconstpointer fix)
" 'arguments': {'handle': %" PRId64 "} }", " 'arguments': {'handle': %" PRId64 "} }",
id); id);
ret = qmp_fd(fixture->fd, cmd); ret = qmp_fd(fixture->fd, cmd);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
} }
@ -555,7 +555,7 @@ static void test_qga_file_write_read(gconstpointer fix)
g_assert_nonnull(ret); g_assert_nonnull(ret);
qmp_assert_no_error(ret); qmp_assert_no_error(ret);
id = qdict_get_int(ret, "return"); id = qdict_get_int(ret, "return");
QDECREF(ret); qobject_unref(ret);
enc = g_base64_encode(helloworld, sizeof(helloworld)); enc = g_base64_encode(helloworld, sizeof(helloworld));
/* write */ /* write */
@ -571,7 +571,7 @@ static void test_qga_file_write_read(gconstpointer fix)
eof = qdict_get_bool(val, "eof"); eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, sizeof(helloworld)); g_assert_cmpint(count, ==, sizeof(helloworld));
g_assert_cmpint(eof, ==, 0); g_assert_cmpint(eof, ==, 0);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* read (check implicit flush) */ /* read (check implicit flush) */
@ -586,7 +586,7 @@ static void test_qga_file_write_read(gconstpointer fix)
g_assert_cmpint(count, ==, 0); g_assert_cmpint(count, ==, 0);
g_assert(eof); g_assert(eof);
g_assert_cmpstr(b64, ==, ""); g_assert_cmpstr(b64, ==, "");
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* seek to 0 */ /* seek to 0 */
@ -601,7 +601,7 @@ static void test_qga_file_write_read(gconstpointer fix)
eof = qdict_get_bool(val, "eof"); eof = qdict_get_bool(val, "eof");
g_assert_cmpint(count, ==, 0); g_assert_cmpint(count, ==, 0);
g_assert(!eof); g_assert(!eof);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
/* read */ /* read */
@ -616,7 +616,7 @@ static void test_qga_file_write_read(gconstpointer fix)
g_assert_cmpint(count, ==, sizeof(helloworld)); g_assert_cmpint(count, ==, sizeof(helloworld));
g_assert(eof); g_assert(eof);
g_assert_cmpstr(b64, ==, enc); g_assert_cmpstr(b64, ==, enc);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
g_free(enc); g_free(enc);
@ -625,7 +625,7 @@ static void test_qga_file_write_read(gconstpointer fix)
" 'arguments': {'handle': %" PRId64 "} }", " 'arguments': {'handle': %" PRId64 "} }",
id); id);
ret = qmp_fd(fixture->fd, cmd); ret = qmp_fd(fixture->fd, cmd);
QDECREF(ret); qobject_unref(ret);
g_free(cmd); g_free(cmd);
} }
@ -642,7 +642,7 @@ static void test_qga_get_time(gconstpointer fix)
time = qdict_get_int(ret, "return"); time = qdict_get_int(ret, "return");
g_assert_cmpint(time, >, 0); g_assert_cmpint(time, >, 0);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_blacklist(gconstpointer data) static void test_qga_blacklist(gconstpointer data)
@ -661,7 +661,7 @@ static void test_qga_blacklist(gconstpointer data)
desc = qdict_get_try_str(error, "desc"); desc = qdict_get_try_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError"); g_assert_cmpstr(class, ==, "GenericError");
g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
QDECREF(ret); qobject_unref(ret);
ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}"); ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}");
g_assert_nonnull(ret); g_assert_nonnull(ret);
@ -670,12 +670,12 @@ static void test_qga_blacklist(gconstpointer data)
desc = qdict_get_try_str(error, "desc"); desc = qdict_get_try_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError"); g_assert_cmpstr(class, ==, "GenericError");
g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
QDECREF(ret); qobject_unref(ret);
/* check something work */ /* check something work */
ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}"); ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
qmp_assert_no_error(ret); qmp_assert_no_error(ret);
QDECREF(ret); qobject_unref(ret);
fixture_tear_down(&fix, NULL); fixture_tear_down(&fix, NULL);
} }
@ -772,7 +772,7 @@ static void test_qga_fsfreeze_status(gconstpointer fix)
status = qdict_get_try_str(ret, "return"); status = qdict_get_try_str(ret, "return");
g_assert_cmpstr(status, ==, "thawed"); g_assert_cmpstr(status, ==, "thawed");
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_guest_exec(gconstpointer fix) static void test_qga_guest_exec(gconstpointer fix)
@ -795,7 +795,7 @@ static void test_qga_guest_exec(gconstpointer fix)
val = qdict_get_qdict(ret, "return"); val = qdict_get_qdict(ret, "return");
pid = qdict_get_int(val, "pid"); pid = qdict_get_int(val, "pid");
g_assert_cmpint(pid, >, 0); g_assert_cmpint(pid, >, 0);
QDECREF(ret); qobject_unref(ret);
/* wait for completion */ /* wait for completion */
now = g_get_monotonic_time(); now = g_get_monotonic_time();
@ -807,7 +807,7 @@ static void test_qga_guest_exec(gconstpointer fix)
val = qdict_get_qdict(ret, "return"); val = qdict_get_qdict(ret, "return");
exited = qdict_get_bool(val, "exited"); exited = qdict_get_bool(val, "exited");
if (!exited) { if (!exited) {
QDECREF(ret); qobject_unref(ret);
} }
} while (!exited && } while (!exited &&
g_get_monotonic_time() < now + 5 * G_TIME_SPAN_SECOND); g_get_monotonic_time() < now + 5 * G_TIME_SPAN_SECOND);
@ -822,7 +822,7 @@ static void test_qga_guest_exec(gconstpointer fix)
g_assert_cmpint(len, ==, 12); g_assert_cmpint(len, ==, 12);
g_assert_cmpstr((char *)decoded, ==, "\" test_str \""); g_assert_cmpstr((char *)decoded, ==, "\" test_str \"");
g_free(decoded); g_free(decoded);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_guest_exec_invalid(gconstpointer fix) static void test_qga_guest_exec_invalid(gconstpointer fix)
@ -841,7 +841,7 @@ static void test_qga_guest_exec_invalid(gconstpointer fix)
desc = qdict_get_str(error, "desc"); desc = qdict_get_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError"); g_assert_cmpstr(class, ==, "GenericError");
g_assert_cmpint(strlen(desc), >, 0); g_assert_cmpint(strlen(desc), >, 0);
QDECREF(ret); qobject_unref(ret);
/* invalid pid */ /* invalid pid */
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec-status'," ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec-status',"
@ -853,7 +853,7 @@ static void test_qga_guest_exec_invalid(gconstpointer fix)
desc = qdict_get_str(error, "desc"); desc = qdict_get_str(error, "desc");
g_assert_cmpstr(class, ==, "GenericError"); g_assert_cmpstr(class, ==, "GenericError");
g_assert_cmpint(strlen(desc), >, 0); g_assert_cmpint(strlen(desc), >, 0);
QDECREF(ret); qobject_unref(ret);
} }
static void test_qga_guest_get_osinfo(gconstpointer data) static void test_qga_guest_get_osinfo(gconstpointer data)
@ -905,7 +905,7 @@ static void test_qga_guest_get_osinfo(gconstpointer data)
g_assert_nonnull(str); g_assert_nonnull(str);
g_assert_cmpstr(str, ==, "unit-test"); g_assert_cmpstr(str, ==, "unit-test");
QDECREF(ret); qobject_unref(ret);
g_free(env[0]); g_free(env[0]);
fixture_tear_down(&fixture, NULL); fixture_tear_down(&fixture, NULL);
} }

24
tests/test-qmp-cmds.c
View File

@ -106,8 +106,8 @@ static void test_dispatch_cmd(void)
assert(resp != NULL); assert(resp != NULL);
assert(!qdict_haskey(qobject_to(QDict, resp), "error")); assert(!qdict_haskey(qobject_to(QDict, resp), "error"));
qobject_decref(resp); qobject_unref(resp);
QDECREF(req); qobject_unref(req);
} }
/* test commands that return an error due to invalid parameters */ /* test commands that return an error due to invalid parameters */
@ -123,8 +123,8 @@ static void test_dispatch_cmd_failure(void)
assert(resp != NULL); assert(resp != NULL);
assert(qdict_haskey(qobject_to(QDict, resp), "error")); assert(qdict_haskey(qobject_to(QDict, resp), "error"));
qobject_decref(resp); qobject_unref(resp);
QDECREF(req); qobject_unref(req);
/* check that with extra arguments it throws an error */ /* check that with extra arguments it throws an error */
req = qdict_new(); req = qdict_new();
@ -137,8 +137,8 @@ static void test_dispatch_cmd_failure(void)
assert(resp != NULL); assert(resp != NULL);
assert(qdict_haskey(qobject_to(QDict, resp), "error")); assert(qdict_haskey(qobject_to(QDict, resp), "error"));
qobject_decref(resp); qobject_unref(resp);
QDECREF(req); qobject_unref(req);
} }
static QObject *test_qmp_dispatch(QDict *req) static QObject *test_qmp_dispatch(QDict *req)
@ -153,8 +153,8 @@ static QObject *test_qmp_dispatch(QDict *req)
assert(resp && !qdict_haskey(resp, "error")); assert(resp && !qdict_haskey(resp, "error"));
ret = qdict_get(resp, "return"); ret = qdict_get(resp, "return");
assert(ret); assert(ret);
qobject_incref(ret); qobject_ref(ret);
qobject_decref(resp_obj); qobject_unref(resp_obj);
return ret; return ret;
} }
@ -195,7 +195,7 @@ static void test_dispatch_cmd_io(void)
assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422); assert(qdict_get_int(ret_dict_dict2_userdef, "integer") == 422);
assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2")); assert(!strcmp(qdict_get_str(ret_dict_dict2_userdef, "string"), "hello2"));
assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4")); assert(!strcmp(qdict_get_str(ret_dict_dict2, "string"), "blah4"));
QDECREF(ret); qobject_unref(ret);
qdict_put_int(args3, "a", 66); qdict_put_int(args3, "a", 66);
qdict_put(req, "arguments", args3); qdict_put(req, "arguments", args3);
@ -204,9 +204,9 @@ static void test_dispatch_cmd_io(void)
ret3 = qobject_to(QNum, test_qmp_dispatch(req)); ret3 = qobject_to(QNum, test_qmp_dispatch(req));
g_assert(qnum_get_try_int(ret3, &val)); g_assert(qnum_get_try_int(ret3, &val));
g_assert_cmpint(val, ==, 66); g_assert_cmpint(val, ==, 66);
QDECREF(ret3); qobject_unref(ret3);
QDECREF(req); qobject_unref(req);
} }
/* test generated dealloc functions for generated types */ /* test generated dealloc functions for generated types */
@ -257,7 +257,7 @@ static void test_dealloc_partial(void)
v = qobject_input_visitor_new(QOBJECT(ud2_dict)); v = qobject_input_visitor_new(QOBJECT(ud2_dict));
visit_type_UserDefTwo(v, NULL, &ud2, &err); visit_type_UserDefTwo(v, NULL, &ud2, &err);
visit_free(v); visit_free(v);
QDECREF(ud2_dict); qobject_unref(ud2_dict);
} }
/* verify that visit_type_XXX() cleans up properly on error */ /* verify that visit_type_XXX() cleans up properly on error */

2
tests/test-qmp-event.c
View File

@ -133,7 +133,7 @@ static void event_prepare(TestEventData *data,
static void event_teardown(TestEventData *data, static void event_teardown(TestEventData *data,
const void *unused) const void *unused)
{ {
QDECREF(data->expect); qobject_unref(data->expect);
test_event_data = NULL; test_event_data = NULL;
g_mutex_unlock(&test_event_lock); g_mutex_unlock(&test_event_lock);

10
tests/test-qobject-input-visitor.c
View File

@ -35,7 +35,7 @@ typedef struct TestInputVisitorData {
static void visitor_input_teardown(TestInputVisitorData *data, static void visitor_input_teardown(TestInputVisitorData *data,
const void *unused) const void *unused)
{ {
qobject_decref(data->obj); qobject_unref(data->obj);
data->obj = NULL; data->obj = NULL;
if (data->qiv) { if (data->qiv) {
@ -483,7 +483,7 @@ static void test_visitor_in_any(TestInputVisitorData *data,
g_assert(qnum); g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val)); g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42); g_assert_cmpint(val, ==, -42);
qobject_decref(res); qobject_unref(res);
v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }"); v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
visit_type_any(v, NULL, &res, &error_abort); visit_type_any(v, NULL, &res, &error_abort);
@ -505,7 +505,7 @@ static void test_visitor_in_any(TestInputVisitorData *data,
qstring = qobject_to(QString, qobj); qstring = qobject_to(QString, qobj);
g_assert(qstring); g_assert(qstring);
g_assert_cmpstr(qstring_get_str(qstring), ==, "foo"); g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
qobject_decref(res); qobject_unref(res);
} }
static void test_visitor_in_null(TestInputVisitorData *data, static void test_visitor_in_null(TestInputVisitorData *data,
@ -530,7 +530,7 @@ static void test_visitor_in_null(TestInputVisitorData *data,
visit_start_struct(v, NULL, NULL, 0, &error_abort); visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_null(v, "a", &null, &error_abort); visit_type_null(v, "a", &null, &error_abort);
g_assert(qobject_type(QOBJECT(null)) == QTYPE_QNULL); g_assert(qobject_type(QOBJECT(null)) == QTYPE_QNULL);
QDECREF(null); qobject_unref(null);
visit_type_null(v, "b", &null, &err); visit_type_null(v, "b", &null, &err);
error_free_or_abort(&err); error_free_or_abort(&err);
g_assert(!null); g_assert(!null);
@ -1262,7 +1262,7 @@ static void do_test_visitor_in_qmp_introspect(TestInputVisitorData *data,
g_assert(schema); g_assert(schema);
qapi_free_SchemaInfoList(schema); qapi_free_SchemaInfoList(schema);
qobject_decref(obj); qobject_unref(obj);
visit_free(v); visit_free(v);
} }

18
tests/test-qobject-output-visitor.c
View File

@ -40,7 +40,7 @@ static void visitor_output_teardown(TestOutputVisitorData *data,
{ {
visit_free(data->ov); visit_free(data->ov);
data->ov = NULL; data->ov = NULL;
qobject_decref(data->obj); qobject_unref(data->obj);
data->obj = NULL; data->obj = NULL;
} }
@ -346,7 +346,7 @@ static void test_visitor_out_any(TestOutputVisitorData *data,
g_assert(qnum); g_assert(qnum);
g_assert(qnum_get_try_int(qnum, &val)); g_assert(qnum_get_try_int(qnum, &val));
g_assert_cmpint(val, ==, -42); g_assert_cmpint(val, ==, -42);
qobject_decref(qobj); qobject_unref(qobj);
visitor_reset(data); visitor_reset(data);
qdict = qdict_new(); qdict = qdict_new();
@ -355,7 +355,7 @@ static void test_visitor_out_any(TestOutputVisitorData *data,
qdict_put_str(qdict, "string", "foo"); qdict_put_str(qdict, "string", "foo");
qobj = QOBJECT(qdict); qobj = QOBJECT(qdict);
visit_type_any(data->ov, NULL, &qobj, &error_abort); visit_type_any(data->ov, NULL, &qobj, &error_abort);
qobject_decref(qobj); qobject_unref(qobj);
qdict = qobject_to(QDict, visitor_get(data)); qdict = qobject_to(QDict, visitor_get(data));
g_assert(qdict); g_assert(qdict);
qnum = qobject_to(QNum, qdict_get(qdict, "integer")); qnum = qobject_to(QNum, qdict_get(qdict, "integer"));
@ -630,7 +630,7 @@ static void check_native_list(QObject *qobj,
qvalue = qobject_to(QNum, tmp); qvalue = qobject_to(QNum, tmp);
g_assert(qnum_get_try_uint(qvalue, &val)); g_assert(qnum_get_try_uint(qvalue, &val));
g_assert_cmpint(val, ==, i); g_assert_cmpint(val, ==, i);
qobject_decref(qlist_pop(qlist)); qobject_unref(qlist_pop(qlist));
} }
break; break;
@ -654,7 +654,7 @@ static void check_native_list(QObject *qobj,
qvalue = qobject_to(QNum, tmp); qvalue = qobject_to(QNum, tmp);
g_assert(qnum_get_try_int(qvalue, &val)); g_assert(qnum_get_try_int(qvalue, &val));
g_assert_cmpint(val, ==, i); g_assert_cmpint(val, ==, i);
qobject_decref(qlist_pop(qlist)); qobject_unref(qlist_pop(qlist));
} }
break; break;
case USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN: case USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN:
@ -665,7 +665,7 @@ static void check_native_list(QObject *qobj,
g_assert(tmp); g_assert(tmp);
qvalue = qobject_to(QBool, tmp); qvalue = qobject_to(QBool, tmp);
g_assert_cmpint(qbool_get_bool(qvalue), ==, i % 3 == 0); g_assert_cmpint(qbool_get_bool(qvalue), ==, i % 3 == 0);
qobject_decref(qlist_pop(qlist)); qobject_unref(qlist_pop(qlist));
} }
break; break;
case USER_DEF_NATIVE_LIST_UNION_KIND_STRING: case USER_DEF_NATIVE_LIST_UNION_KIND_STRING:
@ -678,7 +678,7 @@ static void check_native_list(QObject *qobj,
qvalue = qobject_to(QString, tmp); qvalue = qobject_to(QString, tmp);
sprintf(str, "%d", i); sprintf(str, "%d", i);
g_assert_cmpstr(qstring_get_str(qvalue), ==, str); g_assert_cmpstr(qstring_get_str(qvalue), ==, str);
qobject_decref(qlist_pop(qlist)); qobject_unref(qlist_pop(qlist));
} }
break; break;
case USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER: case USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER:
@ -695,7 +695,7 @@ static void check_native_list(QObject *qobj,
g_string_printf(double_actual, "%.6f", qnum_get_double(qvalue)); g_string_printf(double_actual, "%.6f", qnum_get_double(qvalue));
g_assert_cmpstr(double_actual->str, ==, double_expected->str); g_assert_cmpstr(double_actual->str, ==, double_expected->str);
qobject_decref(qlist_pop(qlist)); qobject_unref(qlist_pop(qlist));
g_string_free(double_expected, true); g_string_free(double_expected, true);
g_string_free(double_actual, true); g_string_free(double_actual, true);
} }
@ -703,7 +703,7 @@ static void check_native_list(QObject *qobj,
default: default:
g_assert_not_reached(); g_assert_not_reached();
} }
QDECREF(qlist); qobject_unref(qlist);
} }
static void test_native_list(TestOutputVisitorData *data, static void test_native_list(TestOutputVisitorData *data,

6
tests/test-visitor-serialization.c
View File

@ -1036,10 +1036,10 @@ static void qmp_deserialize(void **native_out, void *datap,
output_json = qobject_to_json(obj_orig); output_json = qobject_to_json(obj_orig);
obj = qobject_from_json(qstring_get_str(output_json), &error_abort); obj = qobject_from_json(qstring_get_str(output_json), &error_abort);
QDECREF(output_json); qobject_unref(output_json);
d->qiv = qobject_input_visitor_new(obj); d->qiv = qobject_input_visitor_new(obj);
qobject_decref(obj_orig); qobject_unref(obj_orig);
qobject_decref(obj); qobject_unref(obj);
visit(d->qiv, native_out, errp); visit(d->qiv, native_out, errp);
} }

14
tests/test-x86-cpuid-compat.c
View File

@ -19,7 +19,7 @@ static char *get_cpu0_qom_path(void)
cpu0 = qobject_to(QDict, qlist_peek(ret)); cpu0 = qobject_to(QDict, qlist_peek(ret));
path = g_strdup(qdict_get_str(cpu0, "qom_path")); path = g_strdup(qdict_get_str(cpu0, "qom_path"));
QDECREF(resp); qobject_unref(resp);
return path; return path;
} }
@ -30,8 +30,8 @@ static QObject *qom_get(const char *path, const char *prop)
" 'property': %s } }", " 'property': %s } }",
path, prop); path, prop);
QObject *ret = qdict_get(resp, "return"); QObject *ret = qdict_get(resp, "return");
qobject_incref(ret); qobject_ref(ret);
QDECREF(resp); qobject_unref(resp);
return ret; return ret;
} }
@ -41,7 +41,7 @@ static bool qom_get_bool(const char *path, const char *prop)
QBool *value = qobject_to(QBool, qom_get(path, prop)); QBool *value = qobject_to(QBool, qom_get(path, prop));
bool b = qbool_get_bool(value); bool b = qbool_get_bool(value);
QDECREF(value); qobject_unref(value);
return b; return b;
} }
#endif #endif
@ -66,7 +66,7 @@ static void test_cpuid_prop(const void *data)
g_assert_cmpint(val, ==, args->expected_value); g_assert_cmpint(val, ==, args->expected_value);
qtest_end(); qtest_end();
QDECREF(value); qobject_unref(value);
g_free(path); g_free(path);
} }
@ -142,8 +142,8 @@ static void test_feature_flag(const void *data)
g_assert(!!(value & (1U << args->bitnr)) == args->expected_value); g_assert(!!(value & (1U << args->bitnr)) == args->expected_value);
QDECREF(present); qobject_unref(present);
QDECREF(filtered); qobject_unref(filtered);
g_free(path); g_free(path);
} }

4
tests/tmp105-test.c
View File

@ -74,7 +74,7 @@ static int qmp_tmp105_get_temperature(const char *id)
"'property': 'temperature' } }", id); "'property': 'temperature' } }", id);
g_assert(qdict_haskey(response, "return")); g_assert(qdict_haskey(response, "return"));
ret = qdict_get_int(response, "return"); ret = qdict_get_int(response, "return");
QDECREF(response); qobject_unref(response);
return ret; return ret;
} }
@ -85,7 +85,7 @@ static void qmp_tmp105_set_temperature(const char *id, int value)
response = qmp("{ 'execute': 'qom-set', 'arguments': { 'path': %s, " response = qmp("{ 'execute': 'qom-set', 'arguments': { 'path': %s, "
"'property': 'temperature', 'value': %d } }", id, value); "'property': 'temperature', 'value': %d } }", id, value);
g_assert(qdict_haskey(response, "return")); g_assert(qdict_haskey(response, "return"));
QDECREF(response); qobject_unref(response);
} }
#define TMP105_PRECISION (1000/16) #define TMP105_PRECISION (1000/16)

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